ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 262 by gezelter, Fri Jan 14 20:09:26 2005 UTC vs.
Revision 1197 by chuckv, Thu Dec 6 20:40:07 2007 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3	>	# Generated by GNU Autoconf 2.59 for OOPSE 4.0.
4		#
5		# Report bugs to <gezelter@nd.edu>.
6		#
#	Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269		# Identity of this package.
270		PACKAGE_NAME='OOPSE'
271		PACKAGE_TARNAME='oopse'
272	<	PACKAGE_VERSION='2.0'
273	<	PACKAGE_STRING='OOPSE 2.0'
272	>	PACKAGE_VERSION='4.0'
273	>	PACKAGE_STRING='OOPSE 4.0'
274		PACKAGE_BUGREPORT='gezelter@nd.edu'
275
276		ac_unique_file="src/applications/oopse/oopse.cpp"
#	Line 312 | Line 312 | ac_includes_default="\
312		# include <unistd.h>
313		#endif"
314
315	<	ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR 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 USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_CXXFLAGS CGAL_LDFLAGS CGAL_CPPFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316		ac_subst_files=''
317
318		# Initialize some variables set by options.
#	Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753		ac_env_target_alias_value=$target_alias
754		ac_cv_env_target_alias_set=${target_alias+set}
755		ac_cv_env_target_alias_value=$target_alias
756	–	ac_env_CC_set=${CC+set}
757	–	ac_env_CC_value=$CC
758	–	ac_cv_env_CC_set=${CC+set}
759	–	ac_cv_env_CC_value=$CC
760	–	ac_env_CFLAGS_set=${CFLAGS+set}
761	–	ac_env_CFLAGS_value=$CFLAGS
762	–	ac_cv_env_CFLAGS_set=${CFLAGS+set}
763	–	ac_cv_env_CFLAGS_value=$CFLAGS
764	–	ac_env_LDFLAGS_set=${LDFLAGS+set}
765	–	ac_env_LDFLAGS_value=$LDFLAGS
766	–	ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767	–	ac_cv_env_LDFLAGS_value=$LDFLAGS
768	–	ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769	–	ac_env_CPPFLAGS_value=$CPPFLAGS
770	–	ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771	–	ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756		ac_env_CXX_set=${CXX+set}
757		ac_env_CXX_value=$CXX
758		ac_cv_env_CXX_set=${CXX+set}
#	Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761		ac_env_CXXFLAGS_value=$CXXFLAGS
762		ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763		ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764	<	ac_env_F90_set=${F90+set}
765	<	ac_env_F90_value=$F90
766	<	ac_cv_env_F90_set=${F90+set}
767	<	ac_cv_env_F90_value=$F90
768	<	ac_env_F90FLAGS_set=${F90FLAGS+set}
769	<	ac_env_F90FLAGS_value=$F90FLAGS
770	<	ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771	<	ac_cv_env_F90FLAGS_value=$F90FLAGS
764	>	ac_env_LDFLAGS_set=${LDFLAGS+set}
765	>	ac_env_LDFLAGS_value=$LDFLAGS
766	>	ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767	>	ac_cv_env_LDFLAGS_value=$LDFLAGS
768	>	ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769	>	ac_env_CPPFLAGS_value=$CPPFLAGS
770	>	ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771	>	ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772	>	ac_env_CC_set=${CC+set}
773	>	ac_env_CC_value=$CC
774	>	ac_cv_env_CC_set=${CC+set}
775	>	ac_cv_env_CC_value=$CC
776	>	ac_env_CFLAGS_set=${CFLAGS+set}
777	>	ac_env_CFLAGS_value=$CFLAGS
778	>	ac_cv_env_CFLAGS_set=${CFLAGS+set}
779	>	ac_cv_env_CFLAGS_value=$CFLAGS
780	>	ac_env_FC_set=${FC+set}
781	>	ac_env_FC_value=$FC
782	>	ac_cv_env_FC_set=${FC+set}
783	>	ac_cv_env_FC_value=$FC
784	>	ac_env_FCFLAGS_set=${FCFLAGS+set}
785	>	ac_env_FCFLAGS_value=$FCFLAGS
786	>	ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787	>	ac_cv_env_FCFLAGS_value=$FCFLAGS
788		ac_env_CPP_set=${CPP+set}
789		ac_env_CPP_value=$CPP
790		ac_cv_env_CPP_set=${CPP+set}
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 4.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 4.0:";;
866		esac
867		cat <<\_ACEOF
868
869		Optional Features:
870		--disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871		--enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872	+	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873		--enable-debug          Compile OOPSE in debug mode
874	+	--enable-single         compile OOPSE in single precision
875	+	--enable-float          synonym for --enable-single
876		--enable-doxygen        enable documentation generation with doxygen (auto)
877		--enable-dot            use 'dot' to generate graphs in doxygen (auto)
878		--enable-html-docs      enable HTML generation with doxygen (yes)
879		--enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
873	–	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880
881		Optional Packages:
882		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
884	+	--with-perl-shebang     override what perl thinks is the way for the kernel
885	+	to start it (seldom needed)
886	+	--with-zlib=DIR         root directory path of zlib installation (defaults
887	+	to /usr/local or /usr if not found in /usr/local)
888	+	--with-fftw=DIR         root directory path of fftw installation (defaults
889	+	to /usr/local or /usr if not found in /usr/local)
890		--with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891	<	--with-sprng=<prefix>   compile with SPRNG installed in <prefix>
892	<	[default=/usr/local]
881	<	--with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
891	>	--with-cgalmakefile=makefile
892	>	Use the following CGAL makefile
893
894		Some influential environment variables:
895	<	CC          C compiler command
896	<	CFLAGS      C compiler flags
895	>	CXX         C++ compiler command
896	>	CXXFLAGS    C++ compiler flags
897		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
898		nonstandard directory <lib dir>
899		CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
900		headers in a nonstandard directory <include dir>
901	<	CXX         C++ compiler command
902	<	CXXFLAGS    C++ compiler flags
903	<	F90         Fortran 90 compiler command
904	<	F90FLAGS    Fortran 90 compiler flags
901	>	CC          C compiler command
902	>	CFLAGS      C compiler flags
903	>	FC          Fortran compiler command
904	>	FCFLAGS     Fortran compiler flags
905		CPP         C preprocessor
906	+	CXXCPP      C++ preprocessor
907
908		Use these variables to override the choices made by `configure' or to help
909		it to find libraries and programs with nonstandard names/locations.
#	Line 992 | Line 1004 | if $ac_init_version; then
1004		test -n "$ac_init_help" && exit 0
1005		if $ac_init_version; then
1006		cat <<\_ACEOF
1007	<	OOPSE configure 2.0
1007	>	OOPSE configure 4.0
1008		generated by GNU Autoconf 2.59
1009
1010		Copyright (C) 2003 Free Software Foundation, Inc.
#	Line 1006 | Line 1018 | running configure, to aid debugging if configure makes
1018		This file contains any messages produced by compilers while
1019		running configure, to aid debugging if configure makes a mistake.
1020
1021	<	It was created by OOPSE $as_me 2.0, which was
1021	>	It was created by OOPSE $as_me 4.0, which was
1022		generated by GNU Autoconf 2.59.  Invocation command line was
1023
1024		$ $0 $@
#	Line 1368 | Line 1380 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1380		ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1381
1382
1383	<	# This file is part of Autoconf.                       -*- Autoconf -*-
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).
1383	>	ac_config_headers="$ac_config_headers src/config.h"
1384
1385
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
1386
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
1387
1388
1389
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
1390
1391
1392
1491	–	## ----------------------- ##
1492	–	## 1. Language selection.  ##
1493	–	## ----------------------- ##
1393
1495	–	# ----------------------------- #
1496	–	# 1b. The Fortran 90 language.  #
1497	–	# ----------------------------- #
1394
1499	–	# AC_LANG(Fortran 90)
1500	–	# -------------------
1395
1396
1397
1504	–	# _AC_LANG_ABBREV(Fortran 90)
1505	–	# ---------------------------
1398
1399
1400
1509	–	# ----------------------------- #
1510	–	# 1c. The Fortran 95 language.  #
1511	–	# ----------------------------- #
1401
1513	–	# AC_LANG(Fortran 95)
1514	–	# -------------------
1402
1403
1404
1518	–	# _AC_LANG_ABBREV(Fortran 95)
1519	–	# ---------------------------
1405
1406
1407
1523	–	## ---------------------- ##
1524	–	## 2.Producing programs.  ##
1525	–	## ---------------------- ##
1408
1527	–	# ------------------------ #
1528	–	# 2b. Fortran 90 sources.  #
1529	–	# ------------------------ #
1409
1531	–	# AC_LANG_SOURCE(Fortran 90)(BODY)
1532	–	# --------------------------------
1410
1411
1412
1536	–	# AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1537	–	# -----------------------------------------------
1413
1414
1540	–	# AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1541	–	# --------------------------------------------
1415
1416
1417
1545	–	# ------------------------ #
1546	–	# 2c. Fortran 95 sources.  #
1547	–	# ------------------------ #
1418
1549	–	# AC_LANG_SOURCE(Fortran 95)(BODY)
1550	–	# --------------------------------
1419
1420
1553	–	# AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1554	–	# -----------------------------------------------
1421
1422
1557	–	# AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1558	–	# --------------------------------------------
1423
1424
1425
1562	–	## -------------------------------------------- ##
1563	–	## 3. Looking for Compilers and Preprocessors.  ##
1564	–	## -------------------------------------------- ##
1426
1566	–	# ----------------------------- #
1567	–	# 3b. The Fortran 90 compiler.  #
1568	–	# ----------------------------- #
1427
1428	+	#
1429	+	#
1430	+	#
1431
1571	–	# AC_LANG_PREPROC(Fortran 90)
1572	–	# ---------------------------
1573	–	# Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1432
1433
1434
1435	<	# AC_LANG_COMPILER(Fortran 90)
1436	<	# ----------------------------
1437	<	# Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1438	<	# AC_REQUIRE'able.
1435	>
1436	>
1437	>	# AC_F90_MODULE_NAMES
1438	>	# -------------------
1439	>	#
1440	>	# Figure out how the Fortran 90 compiler constructs module file names
1441	>	#
1442	>	# AC_F90_MODULE_NAMES
1443
1444
1445
1584	–	# AC_PROG_F90([COMPILERS...])
1585	–	# ---------------------------
1586	–	# COMPILERS is a space separated list of Fortran 90 compilers to search
1587	–	# for.
1588	–	#
1589	–	# Compilers are ordered by
1590	–	#  1. F90, F95
1591	–	#  2. Good/tested native compilers, bad/untested native compilers
1592	–	#
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
1446
1447
1601	–	# ----------------------------- #
1602	–	# 3c. The Fortran 95 compiler.  #
1603	–	# ----------------------------- #
1448
1449
1606	–	# AC_LANG_PREPROC(Fortran 95)
1607	–	# ---------------------------
1608	–	# Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1450
1451
1452
1612	–	# AC_LANG_COMPILER(Fortran 95)
1613	–	# ----------------------------
1614	–	# Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1615	–	# AC_REQUIRE'able.
1453
1454
1455
1619	–	# AC_PROG_F95([COMPILERS...])
1620	–	# ---------------------------
1621	–	# COMPILERS is a space separated list of Fortran 95 compilers to search
1622	–	# for.
1623	–	#
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
1456
1457
1633	–	## ------------------------------- ##
1634	–	## 4. Compilers' characteristics.  ##
1635	–	## ------------------------------- ##
1458
1459
1638	–	# ---------------------------------------- #
1639	–	# 4b. Fortan 90 compiler characteristics.  #
1640	–	# ---------------------------------------- #
1460
1461
1643	–	# _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1644	–	# -------------------------------------------------
1645	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1646	–	# (which default value, $ac_cv_prog_f90_v, is computed by
1647	–	# _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1648	–	# output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1649	–	# so that any link flags that are echoed by the compiler appear as
1650	–	# space-separated items.
1651	–	# _AC_PROG_F90_V_OUTPUT
1462
1463
1654	–	# _AC_PROG_F90_V
1655	–	# --------------
1656	–	#
1657	–	# 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
1464
1465
1664	–	# AC_F90_LIBRARY_LDFLAGS
1665	–	# ----------------------
1666	–	#
1667	–	# 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
1466
1467
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
1468
1709	–	# The replacement is empty.
1469
1470
1471
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
1472
1473
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
1474
1475
1730	–	# ---------------------------------------- #
1731	–	# 4c. Fortan 95 compiler characteristics.  #
1732	–	# ---------------------------------------- #
1476
1477
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
1478
1479
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
1480
1481
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
1482
1483
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
1484
1801	–	# The replacement is empty.
1485
1486
1487
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
1488
1489
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
1490
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
1491
1492
1493
#	Line 1883 | Line 1547 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1547
1548
1549
1886	–	# set program name
1887	–	PROGNAME="oopse"
1550
1551
1552	<	# there are two ways to do debugging.  One with the --enable-debug flag
1553	<	# and one using the DEBUG environment variable
1552	>	# This is taken from http://autoqt.sourceforge.net/
1553	>	# Copyright (c) 2002, Geoffrey Wossum
1554	>	# All rights reserved.
1555
1556	<	debug=0
1557	<	# Check whether --enable-debug or --disable-debug was given.
1558	<	if test "${enable_debug+set}" = set; then
1896	<	enableval="$enable_debug"
1897	<	debug=1
1898	<	fi;
1899	<	if test "${DEBUG}"; then
1556	>	# Redistribution and use in source and binary forms, with or without
1557	>	# modification, are permitted provided that the following conditions are
1558	>	# met:
1559
1560	<	cat >>confdefs.h <<\_ACEOF
1561	<	#define debug 1
1903	<	_ACEOF
1560	>	#  - Redistributions of source code must retain the above copyright notice,
1561	>	#    this list of conditions and the following disclaimer.
1562
1563	<	msg="$msg, debug mode"
1564	<	fi
1563	>	#  - Redistributions in binary form must reproduce the above copyright
1564	>	#    notice, this list of conditions and the following disclaimer in the
1565	>	#    documentation and/or other materials provided with the distribution.
1566
1567	+	#  - Neither the name of Geoffrey Wossum nor the names of its
1568	+	#    contributors may be used to endorse or promote products derived from
1569	+	#    this software without specific prior written permission.
1570
1571	+
1572	+	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1573	+	# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
1574	+	# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1575	+	# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1576	+	# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1577	+	# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1578	+	# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1579	+	# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1580	+	# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1581	+	# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1582	+	# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1583	+
1584	+
1585	+	# Check for Qt compiler flags, linker flags, and binary packages
1586	+
1587	+
1588	+
1589		# who am i
1590		# Make sure we can run config.sub.
1591		$ac_config_sub sun4 >/dev/null 2>&1 ||
#	Line 1964 | Line 1644 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1644
1645
1646
1647	<	ac_ext=c
1648	<	ac_cpp='$CPP $CPPFLAGS'
1649	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1650	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1651	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
1647	>	# set program name
1648	>	PROGNAME="oopse"
1649	>
1650	>
1651	>
1652	>
1653	>	OBJEXT=".$OBJEXT"
1654	>
1655	>	OOPSE=oopse
1656	>
1657	>	if test "x${prefix}" = "xNONE"
1658	>	then
1659	>	OOPSE_HOME=${ac_default_prefix}/oopse
1660	>	else
1661	>	OOPSE_HOME=${prefix}/oopse
1662	>	fi
1663	>	# Check whether --enable-oopse-home or --disable-oopse-home was given.
1664	>	if test "${enable_oopse_home+set}" = set; then
1665	>	enableval="$enable_oopse_home"
1666	>	OOPSE_HOME="${enableval}"
1667	>	fi;
1668	>
1669	>	# there are two ways to do debugging.  One with the --enable-debug flag
1670	>	# and one using the DEBUG environment variable
1671	>
1672	>	debug=0
1673	>	# Check whether --enable-debug or --disable-debug was given.
1674	>	if test "${enable_debug+set}" = set; then
1675	>	enableval="$enable_debug"
1676	>	debug=1
1677	>	fi;
1678	>	if test "${DEBUG}"; then
1679	>
1680	>	cat >>confdefs.h <<\_ACEOF
1681	>	#define debug 1
1682	>	_ACEOF
1683	>
1684	>	msg="$msg, debug mode"
1685	>	fi
1686	>
1687	>
1688	>	# Check whether --enable-single or --disable-single was given.
1689	>	if test "${enable_single+set}" = set; then
1690	>	enableval="$enable_single"
1691	>	ok=$enableval
1692	>	else
1693	>	ok=no
1694	>	fi;
1695	>	# Check whether --enable-float or --disable-float was given.
1696	>	if test "${enable_float+set}" = set; then
1697	>	enableval="$enable_float"
1698	>	ok=$enableval
1699	>	fi;
1700	>	if test "$ok" = "yes"; then
1701	>
1702	>	cat >>confdefs.h <<\_ACEOF
1703	>	#define SINGLE_PRECISION 1
1704	>	_ACEOF
1705	>
1706	>	USE_SINGLE_PRECISION=yes
1707	>
1708	>	fi
1709	>
1710	>	# Checks for programs.
1711	>	ac_ext=cc
1712	>	ac_cpp='$CXXCPP $CPPFLAGS'
1713	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1714	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1715	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1716		if test -n "$ac_tool_prefix"; then
1717	<	for ac_prog in icc xlc gcc cc
1717	>	for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1718		do
1719		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1720		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1721		echo "$as_me:$LINENO: checking for $ac_word" >&5
1722		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1723	<	if test "${ac_cv_prog_CC+set}" = set; then
1723	>	if test "${ac_cv_prog_CXX+set}" = set; then
1724		echo $ECHO_N "(cached) $ECHO_C" >&6
1725		else
1726	<	if test -n "$CC"; then
1727	<	ac_cv_prog_CC="$CC" # Let the user override the test.
1726	>	if test -n "$CXX"; then
1727	>	ac_cv_prog_CXX="$CXX" # Let the user override the test.
1728		else
1729		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1730		for as_dir in $PATH
#	Line 1989 | Line 1733 | do
1733		test -z "$as_dir" && as_dir=.
1734		for ac_exec_ext in '' $ac_executable_extensions; do
1735		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1736	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1736	>	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1737		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1738		break 2
1739		fi
#	Line 1998 | Line 1742 | fi
1742
1743		fi
1744		fi
1745	<	CC=$ac_cv_prog_CC
1746	<	if test -n "$CC"; then
1747	<	echo "$as_me:$LINENO: result: $CC" >&5
1748	<	echo "${ECHO_T}$CC" >&6
1745	>	CXX=$ac_cv_prog_CXX
1746	>	if test -n "$CXX"; then
1747	>	echo "$as_me:$LINENO: result: $CXX" >&5
1748	>	echo "${ECHO_T}$CXX" >&6
1749		else
1750		echo "$as_me:$LINENO: result: no" >&5
1751		echo "${ECHO_T}no" >&6
1752		fi
1753
1754	<	test -n "$CC" && break
1754	>	test -n "$CXX" && break
1755		done
1756		fi
1757	<	if test -z "$CC"; then
1758	<	ac_ct_CC=$CC
1759	<	for ac_prog in icc xlc gcc cc
1757	>	if test -z "$CXX"; then
1758	>	ac_ct_CXX=$CXX
1759	>	for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1760		do
1761		# Extract the first word of "$ac_prog", so it can be a program name with args.
1762		set dummy $ac_prog; ac_word=$2
1763		echo "$as_me:$LINENO: checking for $ac_word" >&5
1764		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1765	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1765	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1766		echo $ECHO_N "(cached) $ECHO_C" >&6
1767		else
1768	<	if test -n "$ac_ct_CC"; then
1769	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1768	>	if test -n "$ac_ct_CXX"; then
1769	>	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1770		else
1771		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1772		for as_dir in $PATH
#	Line 2031 | Line 1775 | do
1775		test -z "$as_dir" && as_dir=.
1776		for ac_exec_ext in '' $ac_executable_extensions; do
1777		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1778	<	ac_cv_prog_ac_ct_CC="$ac_prog"
1778	>	ac_cv_prog_ac_ct_CXX="$ac_prog"
1779		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1780		break 2
1781		fi
#	Line 2040 | Line 1784 | fi
1784
1785		fi
1786		fi
1787	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
1788	<	if test -n "$ac_ct_CC"; then
1789	<	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1790	<	echo "${ECHO_T}$ac_ct_CC" >&6
1787	>	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1788	>	if test -n "$ac_ct_CXX"; then
1789	>	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1790	>	echo "${ECHO_T}$ac_ct_CXX" >&6
1791		else
1792		echo "$as_me:$LINENO: result: no" >&5
1793		echo "${ECHO_T}no" >&6
1794		fi
1795
1796	<	test -n "$ac_ct_CC" && break
1796	>	test -n "$ac_ct_CXX" && break
1797		done
1798	+	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1799
1800	<	CC=$ac_ct_CC
1800	>	CXX=$ac_ct_CXX
1801		fi
1802
1803
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	–
1804		# Provide some information about the compiler.
1805		echo "$as_me:$LINENO:" \
1806	<	"checking for C compiler version" >&5
1806	>	"checking for C++ compiler version" >&5
1807		ac_compiler=`set X $ac_compile; echo $2`
1808		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1809		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2102 | Line 1841 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1841		# Try to create an executable without -o first, disregard a.out.
1842		# It will help us diagnose broken compilers, and finding out an intuition
1843		# of exeext.
1844	<	echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1845	<	echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1844	>	echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1845	>	echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1846		ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1847		if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1848		(eval $ac_link_default) 2>&5
#	Line 2146 | Line 1885 | sed 's/^/| /' conftest.$ac_ext >&5
1885		echo "$as_me: failed program was:" >&5
1886		sed 's/^/| /' conftest.$ac_ext >&5
1887
1888	<	{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
1888	>	{ { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1889		See \`config.log' for more details." >&5
1890	<	echo "$as_me: error: C compiler cannot create executables
1890	>	echo "$as_me: error: C++ compiler cannot create executables
1891		See \`config.log' for more details." >&2;}
1892		{ (exit 77); exit 77; }; }
1893		fi
#	Line 2159 | Line 1898 | echo "${ECHO_T}$ac_file" >&6
1898
1899		# Check the compiler produces executables we can run.  If not, either
1900		# the compiler is broken, or we cross compile.
1901	<	echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1902	<	echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1901	>	echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1902	>	echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1903		# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1904		# If not cross compiling, check that we can run a simple program.
1905		if test "$cross_compiling" != yes; then
#	Line 2175 | Line 1914 | if test "$cross_compiling" != yes; then
1914		if test "$cross_compiling" = maybe; then
1915		cross_compiling=yes
1916		else
1917	<	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1917	>	{ { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1918		If you meant to cross compile, use \`--host'.
1919		See \`config.log' for more details." >&5
1920	<	echo "$as_me: error: cannot run C compiled programs.
1920	>	echo "$as_me: error: cannot run C++ compiled programs.
1921		If you meant to cross compile, use \`--host'.
1922		See \`config.log' for more details." >&2;}
1923		{ (exit 1); exit 1; }; }
#	Line 2283 | Line 2022 | ac_objext=$OBJEXT
2022		echo "${ECHO_T}$ac_cv_objext" >&6
2023		OBJEXT=$ac_cv_objext
2024		ac_objext=$OBJEXT
2025	<	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2026	<	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2027	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then
2025	>	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2026	>	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2027	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2028		echo $ECHO_N "(cached) $ECHO_C" >&6
2029		else
2030		cat >conftest.$ac_ext <<_ACEOF
#	Line 2315 | Line 2054 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2054		cat conftest.err >&5
2055		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056		(exit $ac_status); } &&
2057	<	{ ac_try='test -z "$ac_c_werror_flag"
2057	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2058		|| test ! -s conftest.err'
2059		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060		(eval $ac_try) 2>&5
#	Line 2336 | Line 2075 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2075		ac_compiler_gnu=no
2076		fi
2077		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2078	>	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2079
2080		fi
2081	<	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2082	<	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2083	<	GCC=`test $ac_compiler_gnu = yes && echo yes`
2084	<	ac_test_CFLAGS=${CFLAGS+set}
2085	<	ac_save_CFLAGS=$CFLAGS
2086	<	CFLAGS="-g"
2087	<	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2088	<	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2089	<	if test "${ac_cv_prog_cc_g+set}" = set; then
2081	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2082	>	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2083	>	GXX=`test $ac_compiler_gnu = yes && echo yes`
2084	>	ac_test_CXXFLAGS=${CXXFLAGS+set}
2085	>	ac_save_CXXFLAGS=$CXXFLAGS
2086	>	CXXFLAGS="-g"
2087	>	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2088	>	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2089	>	if test "${ac_cv_prog_cxx_g+set}" = set; then
2090		echo $ECHO_N "(cached) $ECHO_C" >&6
2091		else
2092		cat >conftest.$ac_ext <<_ACEOF
#	Line 2374 | Line 2113 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2113		cat conftest.err >&5
2114		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2115		(exit $ac_status); } &&
2116	<	{ ac_try='test -z "$ac_c_werror_flag"
2116	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2117		|| test ! -s conftest.err'
2118		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2119		(eval $ac_try) 2>&5
#	Line 2387 | Line 2126 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2126		ac_status=$?
2127		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128		(exit $ac_status); }; }; then
2129	<	ac_cv_prog_cc_g=yes
2129	>	ac_cv_prog_cxx_g=yes
2130		else
2131		echo "$as_me: failed program was:" >&5
2132		sed 's/^/| /' conftest.$ac_ext >&5
2133
2134	<	ac_cv_prog_cc_g=no
2134	>	ac_cv_prog_cxx_g=no
2135		fi
2136		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2137		fi
2138	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2139	<	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2140	<	if test "$ac_test_CFLAGS" = set; then
2141	<	CFLAGS=$ac_save_CFLAGS
2142	<	elif test $ac_cv_prog_cc_g = yes; then
2143	<	if test "$GCC" = yes; then
2144	<	CFLAGS="-g -O2"
2138	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2139	>	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2140	>	if test "$ac_test_CXXFLAGS" = set; then
2141	>	CXXFLAGS=$ac_save_CXXFLAGS
2142	>	elif test $ac_cv_prog_cxx_g = yes; then
2143	>	if test "$GXX" = yes; then
2144	>	CXXFLAGS="-g -O2"
2145		else
2146	<	CFLAGS="-g"
2146	>	CXXFLAGS="-g"
2147		fi
2148		else
2149	<	if test "$GCC" = yes; then
2150	<	CFLAGS="-O2"
2149	>	if test "$GXX" = yes; then
2150	>	CXXFLAGS="-O2"
2151		else
2152	<	CFLAGS=
2152	>	CXXFLAGS=
2153		fi
2154		fi
2155	<	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2417	<	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2418	<	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2419	<	echo $ECHO_N "(cached) $ECHO_C" >&6
2420	<	else
2421	<	ac_cv_prog_cc_stdc=no
2422	<	ac_save_CC=$CC
2423	<	cat >conftest.$ac_ext <<_ACEOF
2424	<	/* confdefs.h.  */
2425	<	_ACEOF
2426	<	cat confdefs.h >>conftest.$ac_ext
2427	<	cat >>conftest.$ac_ext <<_ACEOF
2428	<	/* end confdefs.h.  */
2429	<	#include <stdarg.h>
2430	<	#include <stdio.h>
2431	<	#include <sys/types.h>
2432	<	#include <sys/stat.h>
2433	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2434	<	struct buf { int x; };
2435	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2436	<	static char *e (p, i)
2437	<	char **p;
2438	<	int i;
2439	<	{
2440	<	return p[i];
2441	<	}
2442	<	static char *f (char * (*g) (char **, int), char **p, ...)
2443	<	{
2444	<	char *s;
2445	<	va_list v;
2446	<	va_start (v,p);
2447	<	s = g (p, va_arg (v,int));
2448	<	va_end (v);
2449	<	return s;
2450	<	}
2451	<
2452	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2453	<	function prototypes and stuff, but not '\xHH' hex character constants.
2454	<	These don't provoke an error unfortunately, instead are silently treated
2455	<	as 'x'.  The following induces an error, until -std1 is added to get
2456	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2457	<	array size at least.  It's necessary to write '\x00'==0 to get something
2458	<	that's true only with -std1.  */
2459	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2460	<
2461	<	int test (int i, double x);
2462	<	struct s1 {int (*f) (int a);};
2463	<	struct s2 {int (*f) (double a);};
2464	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2465	<	int argc;
2466	<	char **argv;
2467	<	int
2468	<	main ()
2469	<	{
2470	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2471	<	;
2472	<	return 0;
2473	<	}
2474	<	_ACEOF
2475	<	# Don't try gcc -ansi; that turns off useful extensions and
2476	<	# breaks some systems' header files.
2477	<	# AIX                   -qlanglvl=ansi
2478	<	# Ultrix and OSF/1      -std1
2479	<	# HP-UX 10.20 and later -Ae
2480	<	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2481	<	# SVR4                  -Xc -D__EXTENSIONS__
2482	<	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2483	<	do
2484	<	CC="$ac_save_CC $ac_arg"
2485	<	rm -f conftest.$ac_objext
2486	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2487	<	(eval $ac_compile) 2>conftest.er1
2488	<	ac_status=$?
2489	<	grep -v '^ *+' conftest.er1 >conftest.err
2490	<	rm -f conftest.er1
2491	<	cat conftest.err >&5
2492	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2493	<	(exit $ac_status); } &&
2494	<	{ ac_try='test -z "$ac_c_werror_flag"
2495	<	|| test ! -s conftest.err'
2496	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2497	<	(eval $ac_try) 2>&5
2498	<	ac_status=$?
2499	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2500	<	(exit $ac_status); }; } &&
2501	<	{ ac_try='test -s conftest.$ac_objext'
2502	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2503	<	(eval $ac_try) 2>&5
2504	<	ac_status=$?
2505	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2506	<	(exit $ac_status); }; }; then
2507	<	ac_cv_prog_cc_stdc=$ac_arg
2508	<	break
2509	<	else
2510	<	echo "$as_me: failed program was:" >&5
2511	<	sed 's/^/| /' conftest.$ac_ext >&5
2512	<
2513	<	fi
2514	<	rm -f conftest.err conftest.$ac_objext
2515	<	done
2516	<	rm -f conftest.$ac_ext conftest.$ac_objext
2517	<	CC=$ac_save_CC
2518	<
2519	<	fi
2520	<
2521	<	case "x$ac_cv_prog_cc_stdc" in
2522	<	x|xno)
2523	<	echo "$as_me:$LINENO: result: none needed" >&5
2524	<	echo "${ECHO_T}none needed" >&6 ;;
2525	<	*)
2526	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2527	<	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2528	<	CC="$CC $ac_cv_prog_cc_stdc" ;;
2529	<	esac
2530	<
2531	<	# Some people use a C++ compiler to compile C.  Since we use `exit',
2532	<	# in C++ we need to declare it.  In case someone uses the same compiler
2533	<	# for both compiling C and C++ we need to have the C++ compiler decide
2534	<	# the declaration of exit, since it's the most demanding environment.
2535	<	cat >conftest.$ac_ext <<_ACEOF
2536	<	#ifndef __cplusplus
2537	<	choke me
2538	<	#endif
2539	<	_ACEOF
2540	<	rm -f conftest.$ac_objext
2541	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2542	<	(eval $ac_compile) 2>conftest.er1
2543	<	ac_status=$?
2544	<	grep -v '^ *+' conftest.er1 >conftest.err
2545	<	rm -f conftest.er1
2546	<	cat conftest.err >&5
2547	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2548	<	(exit $ac_status); } &&
2549	<	{ ac_try='test -z "$ac_c_werror_flag"
2550	<	|| test ! -s conftest.err'
2551	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2552	<	(eval $ac_try) 2>&5
2553	<	ac_status=$?
2554	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2555	<	(exit $ac_status); }; } &&
2556	<	{ ac_try='test -s conftest.$ac_objext'
2557	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2558	<	(eval $ac_try) 2>&5
2559	<	ac_status=$?
2560	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2561	<	(exit $ac_status); }; }; then
2562	<	for ac_declaration in \
2155	>	for ac_declaration in \
2156		'' \
2157		'extern "C" void std::exit (int) throw (); using std::exit;' \
2158		'extern "C" void std::exit (int); using std::exit;' \
#	Line 2592 | Line 2185 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2185		cat conftest.err >&5
2186		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2187		(exit $ac_status); } &&
2188	<	{ ac_try='test -z "$ac_c_werror_flag"
2188	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2189		|| test ! -s conftest.err'
2190		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2191		(eval $ac_try) 2>&5
#	Line 2637 | Line 2230 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2230		cat conftest.err >&5
2231		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2232		(exit $ac_status); } &&
2233	<	{ ac_try='test -z "$ac_c_werror_flag"
2233	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2234		|| test ! -s conftest.err'
2235		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2236		(eval $ac_try) 2>&5
#	Line 2665 | Line 2258 | fi
2258		echo '#endif'             >>confdefs.h
2259		fi
2260
2668	–	else
2669	–	echo "$as_me: failed program was:" >&5
2670	–	sed 's/^/| /' conftest.$ac_ext >&5
2671	–
2672	–	fi
2673	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2261		ac_ext=c
2262		ac_cpp='$CPP $CPPFLAGS'
2263		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2264		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2265		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2266
2267	<
2268	<	ac_ext=cc
2269	<	ac_cpp='$CXXCPP $CPPFLAGS'
2270	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2271	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2685	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2267	>	ac_ext=c
2268	>	ac_cpp='$CPP $CPPFLAGS'
2269	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2270	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2271	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2272		if test -n "$ac_tool_prefix"; then
2273	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2273	>	for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2274		do
2275		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2276		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2277		echo "$as_me:$LINENO: checking for $ac_word" >&5
2278		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2279	<	if test "${ac_cv_prog_CXX+set}" = set; then
2279	>	if test "${ac_cv_prog_CC+set}" = set; then
2280		echo $ECHO_N "(cached) $ECHO_C" >&6
2281		else
2282	<	if test -n "$CXX"; then
2283	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
2282	>	if test -n "$CC"; then
2283	>	ac_cv_prog_CC="$CC" # Let the user override the test.
2284		else
2285		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2286		for as_dir in $PATH
#	Line 2703 | Line 2289 | do
2289		test -z "$as_dir" && as_dir=.
2290		for ac_exec_ext in '' $ac_executable_extensions; do
2291		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2292	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2292	>	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2293		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2294		break 2
2295		fi
#	Line 2712 | Line 2298 | fi
2298
2299		fi
2300		fi
2301	<	CXX=$ac_cv_prog_CXX
2302	<	if test -n "$CXX"; then
2303	<	echo "$as_me:$LINENO: result: $CXX" >&5
2304	<	echo "${ECHO_T}$CXX" >&6
2301	>	CC=$ac_cv_prog_CC
2302	>	if test -n "$CC"; then
2303	>	echo "$as_me:$LINENO: result: $CC" >&5
2304	>	echo "${ECHO_T}$CC" >&6
2305		else
2306		echo "$as_me:$LINENO: result: no" >&5
2307		echo "${ECHO_T}no" >&6
2308		fi
2309
2310	<	test -n "$CXX" && break
2310	>	test -n "$CC" && break
2311		done
2312		fi
2313	<	if test -z "$CXX"; then
2314	<	ac_ct_CXX=$CXX
2315	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2313	>	if test -z "$CC"; then
2314	>	ac_ct_CC=$CC
2315	>	for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2316		do
2317		# Extract the first word of "$ac_prog", so it can be a program name with args.
2318		set dummy $ac_prog; ac_word=$2
2319		echo "$as_me:$LINENO: checking for $ac_word" >&5
2320		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2321	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2321	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2322		echo $ECHO_N "(cached) $ECHO_C" >&6
2323		else
2324	<	if test -n "$ac_ct_CXX"; then
2325	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2324	>	if test -n "$ac_ct_CC"; then
2325	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2326		else
2327		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2328		for as_dir in $PATH
#	Line 2745 | Line 2331 | do
2331		test -z "$as_dir" && as_dir=.
2332		for ac_exec_ext in '' $ac_executable_extensions; do
2333		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2334	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
2334	>	ac_cv_prog_ac_ct_CC="$ac_prog"
2335		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2336		break 2
2337		fi
#	Line 2754 | Line 2340 | fi
2340
2341		fi
2342		fi
2343	<	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2344	<	if test -n "$ac_ct_CXX"; then
2345	<	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2346	<	echo "${ECHO_T}$ac_ct_CXX" >&6
2343	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
2344	>	if test -n "$ac_ct_CC"; then
2345	>	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2346	>	echo "${ECHO_T}$ac_ct_CC" >&6
2347		else
2348		echo "$as_me:$LINENO: result: no" >&5
2349		echo "${ECHO_T}no" >&6
2350		fi
2351
2352	<	test -n "$ac_ct_CXX" && break
2352	>	test -n "$ac_ct_CC" && break
2353		done
2768	–	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2354
2355	<	CXX=$ac_ct_CXX
2355	>	CC=$ac_ct_CC
2356		fi
2357
2358
2359	+	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2360	+	See \`config.log' for more details." >&5
2361	+	echo "$as_me: error: no acceptable C compiler found in \$PATH
2362	+	See \`config.log' for more details." >&2;}
2363	+	{ (exit 1); exit 1; }; }
2364	+
2365		# Provide some information about the compiler.
2366		echo "$as_me:$LINENO:" \
2367	<	"checking for C++ compiler version" >&5
2367	>	"checking for C compiler version" >&5
2368		ac_compiler=`set X $ac_compile; echo $2`
2369		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2370		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2791 | Line 2382 | ac_compiler=`set X $ac_compile; echo $2`
2382		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2383		(exit $ac_status); }
2384
2385	<	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2386	<	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2387	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2385	>	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2386	>	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2387	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then
2388		echo $ECHO_N "(cached) $ECHO_C" >&6
2389		else
2390		cat >conftest.$ac_ext <<_ACEOF
#	Line 2823 | Line 2414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2414		cat conftest.err >&5
2415		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2416		(exit $ac_status); } &&
2417	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2417	>	{ ac_try='test -z "$ac_c_werror_flag"
2418		|| test ! -s conftest.err'
2419		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2420		(eval $ac_try) 2>&5
#	Line 2844 | Line 2435 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2435		ac_compiler_gnu=no
2436		fi
2437		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2438	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2438	>	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2439
2440		fi
2441	<	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2442	<	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2443	<	GXX=`test $ac_compiler_gnu = yes && echo yes`
2444	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
2445	<	ac_save_CXXFLAGS=$CXXFLAGS
2446	<	CXXFLAGS="-g"
2447	<	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2448	<	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2449	<	if test "${ac_cv_prog_cxx_g+set}" = set; then
2441	>	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2442	>	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2443	>	GCC=`test $ac_compiler_gnu = yes && echo yes`
2444	>	ac_test_CFLAGS=${CFLAGS+set}
2445	>	ac_save_CFLAGS=$CFLAGS
2446	>	CFLAGS="-g"
2447	>	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2448	>	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2449	>	if test "${ac_cv_prog_cc_g+set}" = set; then
2450		echo $ECHO_N "(cached) $ECHO_C" >&6
2451		else
2452		cat >conftest.$ac_ext <<_ACEOF
#	Line 2882 | Line 2473 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2473		cat conftest.err >&5
2474		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2475		(exit $ac_status); } &&
2476	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2476	>	{ ac_try='test -z "$ac_c_werror_flag"
2477		|| test ! -s conftest.err'
2478		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2479		(eval $ac_try) 2>&5
#	Line 2895 | Line 2486 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2486		ac_status=$?
2487		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2488		(exit $ac_status); }; }; then
2489	<	ac_cv_prog_cxx_g=yes
2489	>	ac_cv_prog_cc_g=yes
2490		else
2491		echo "$as_me: failed program was:" >&5
2492		sed 's/^/| /' conftest.$ac_ext >&5
2493
2494	<	ac_cv_prog_cxx_g=no
2494	>	ac_cv_prog_cc_g=no
2495		fi
2496		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2497		fi
2498	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2499	<	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2500	<	if test "$ac_test_CXXFLAGS" = set; then
2501	<	CXXFLAGS=$ac_save_CXXFLAGS
2502	<	elif test $ac_cv_prog_cxx_g = yes; then
2503	<	if test "$GXX" = yes; then
2504	<	CXXFLAGS="-g -O2"
2498	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2499	>	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2500	>	if test "$ac_test_CFLAGS" = set; then
2501	>	CFLAGS=$ac_save_CFLAGS
2502	>	elif test $ac_cv_prog_cc_g = yes; then
2503	>	if test "$GCC" = yes; then
2504	>	CFLAGS="-g -O2"
2505		else
2506	<	CXXFLAGS="-g"
2506	>	CFLAGS="-g"
2507		fi
2508		else
2509	<	if test "$GXX" = yes; then
2510	<	CXXFLAGS="-O2"
2509	>	if test "$GCC" = yes; then
2510	>	CFLAGS="-O2"
2511		else
2512	<	CXXFLAGS=
2512	>	CFLAGS=
2513		fi
2514		fi
2515	<	for ac_declaration in \
2516	<	'' \
2517	<	'extern "C" void std::exit (int) throw (); using std::exit;' \
2518	<	'extern "C" void std::exit (int); using std::exit;' \
2519	<	'extern "C" void exit (int) throw ();' \
2520	<	'extern "C" void exit (int);' \
2521	<	'void exit (int);'
2522	<	do
2932	<	cat >conftest.$ac_ext <<_ACEOF
2515	>	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2516	>	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2517	>	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2518	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2519	>	else
2520	>	ac_cv_prog_cc_stdc=no
2521	>	ac_save_CC=$CC
2522	>	cat >conftest.$ac_ext <<_ACEOF
2523		/* confdefs.h.  */
2524		_ACEOF
2525		cat confdefs.h >>conftest.$ac_ext
2526		cat >>conftest.$ac_ext <<_ACEOF
2527		/* end confdefs.h.  */
2528	<	$ac_declaration
2529	<	#include <stdlib.h>
2530	<	int
2531	<	main ()
2532	<	{
2533	<	exit (42);
2534	<	;
2535	<	return 0;
2536	<	}
2537	<	_ACEOF
2538	<	rm -f conftest.$ac_objext
2539	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2540	<	(eval $ac_compile) 2>conftest.er1
2528	>	#include <stdarg.h>
2529	>	#include <stdio.h>
2530	>	#include <sys/types.h>
2531	>	#include <sys/stat.h>
2532	>	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2533	>	struct buf { int x; };
2534	>	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2535	>	static char *e (p, i)
2536	>	char **p;
2537	>	int i;
2538	>	{
2539	>	return p[i];
2540	>	}
2541	>	static char *f (char * (*g) (char **, int), char **p, ...)
2542	>	{
2543	>	char *s;
2544	>	va_list v;
2545	>	va_start (v,p);
2546	>	s = g (p, va_arg (v,int));
2547	>	va_end (v);
2548	>	return s;
2549	>	}
2550	>
2551	>	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2552	>	function prototypes and stuff, but not '\xHH' hex character constants.
2553	>	These don't provoke an error unfortunately, instead are silently treated
2554	>	as 'x'.  The following induces an error, until -std1 is added to get
2555	>	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2556	>	array size at least.  It's necessary to write '\x00'==0 to get something
2557	>	that's true only with -std1.  */
2558	>	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2559	>
2560	>	int test (int i, double x);
2561	>	struct s1 {int (*f) (int a);};
2562	>	struct s2 {int (*f) (double a);};
2563	>	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2564	>	int argc;
2565	>	char **argv;
2566	>	int
2567	>	main ()
2568	>	{
2569	>	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2570	>	;
2571	>	return 0;
2572	>	}
2573	>	_ACEOF
2574	>	# Don't try gcc -ansi; that turns off useful extensions and
2575	>	# breaks some systems' header files.
2576	>	# AIX                   -qlanglvl=ansi
2577	>	# Ultrix and OSF/1      -std1
2578	>	# HP-UX 10.20 and later -Ae
2579	>	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2580	>	# SVR4                  -Xc -D__EXTENSIONS__
2581	>	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2582	>	do
2583	>	CC="$ac_save_CC $ac_arg"
2584	>	rm -f conftest.$ac_objext
2585	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2586	>	(eval $ac_compile) 2>conftest.er1
2587		ac_status=$?
2588		grep -v '^ *+' conftest.er1 >conftest.err
2589		rm -f conftest.er1
2590		cat conftest.err >&5
2591		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2592		(exit $ac_status); } &&
2593	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2593	>	{ ac_try='test -z "$ac_c_werror_flag"
2594	>	|| test ! -s conftest.err'
2595	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2596	>	(eval $ac_try) 2>&5
2597	>	ac_status=$?
2598	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2599	>	(exit $ac_status); }; } &&
2600	>	{ ac_try='test -s conftest.$ac_objext'
2601	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2602	>	(eval $ac_try) 2>&5
2603	>	ac_status=$?
2604	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2605	>	(exit $ac_status); }; }; then
2606	>	ac_cv_prog_cc_stdc=$ac_arg
2607	>	break
2608	>	else
2609	>	echo "$as_me: failed program was:" >&5
2610	>	sed 's/^/| /' conftest.$ac_ext >&5
2611	>
2612	>	fi
2613	>	rm -f conftest.err conftest.$ac_objext
2614	>	done
2615	>	rm -f conftest.$ac_ext conftest.$ac_objext
2616	>	CC=$ac_save_CC
2617	>
2618	>	fi
2619	>
2620	>	case "x$ac_cv_prog_cc_stdc" in
2621	>	x|xno)
2622	>	echo "$as_me:$LINENO: result: none needed" >&5
2623	>	echo "${ECHO_T}none needed" >&6 ;;
2624	>	*)
2625	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2626	>	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2627	>	CC="$CC $ac_cv_prog_cc_stdc" ;;
2628	>	esac
2629	>
2630	>	# Some people use a C++ compiler to compile C.  Since we use `exit',
2631	>	# in C++ we need to declare it.  In case someone uses the same compiler
2632	>	# for both compiling C and C++ we need to have the C++ compiler decide
2633	>	# the declaration of exit, since it's the most demanding environment.
2634	>	cat >conftest.$ac_ext <<_ACEOF
2635	>	#ifndef __cplusplus
2636	>	choke me
2637	>	#endif
2638	>	_ACEOF
2639	>	rm -f conftest.$ac_objext
2640	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2641	>	(eval $ac_compile) 2>conftest.er1
2642	>	ac_status=$?
2643	>	grep -v '^ *+' conftest.er1 >conftest.err
2644	>	rm -f conftest.er1
2645	>	cat conftest.err >&5
2646	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2647	>	(exit $ac_status); } &&
2648	>	{ ac_try='test -z "$ac_c_werror_flag"
2649	>	|| test ! -s conftest.err'
2650	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2651	>	(eval $ac_try) 2>&5
2652	>	ac_status=$?
2653	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2654	>	(exit $ac_status); }; } &&
2655	>	{ ac_try='test -s conftest.$ac_objext'
2656	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2657	>	(eval $ac_try) 2>&5
2658	>	ac_status=$?
2659	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2660	>	(exit $ac_status); }; }; then
2661	>	for ac_declaration in \
2662	>	'' \
2663	>	'extern "C" void std::exit (int) throw (); using std::exit;' \
2664	>	'extern "C" void std::exit (int); using std::exit;' \
2665	>	'extern "C" void exit (int) throw ();' \
2666	>	'extern "C" void exit (int);' \
2667	>	'void exit (int);'
2668	>	do
2669	>	cat >conftest.$ac_ext <<_ACEOF
2670	>	/* confdefs.h.  */
2671	>	_ACEOF
2672	>	cat confdefs.h >>conftest.$ac_ext
2673	>	cat >>conftest.$ac_ext <<_ACEOF
2674	>	/* end confdefs.h.  */
2675	>	$ac_declaration
2676	>	#include <stdlib.h>
2677	>	int
2678	>	main ()
2679	>	{
2680	>	exit (42);
2681	>	;
2682	>	return 0;
2683	>	}
2684	>	_ACEOF
2685	>	rm -f conftest.$ac_objext
2686	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2687	>	(eval $ac_compile) 2>conftest.er1
2688	>	ac_status=$?
2689	>	grep -v '^ *+' conftest.er1 >conftest.err
2690	>	rm -f conftest.er1
2691	>	cat conftest.err >&5
2692	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2693	>	(exit $ac_status); } &&
2694	>	{ ac_try='test -z "$ac_c_werror_flag"
2695		|| test ! -s conftest.err'
2696		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2697		(eval $ac_try) 2>&5
#	Line 2999 | Line 2736 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2736		cat conftest.err >&5
2737		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2738		(exit $ac_status); } &&
2739	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2739	>	{ ac_try='test -z "$ac_c_werror_flag"
2740		|| test ! -s conftest.err'
2741		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2742		(eval $ac_try) 2>&5
#	Line 3027 | Line 2764 | fi
2764		echo '#endif'             >>confdefs.h
2765		fi
2766
2767	+	else
2768	+	echo "$as_me: failed program was:" >&5
2769	+	sed 's/^/| /' conftest.$ac_ext >&5
2770	+
2771	+	fi
2772	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2773		ac_ext=c
2774		ac_cpp='$CPP $CPPFLAGS'
2775		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2776		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2777		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2778
2779	<
2780	<	OOPSE_TEMPLATE_FLAGS=""
2781	<	if test $ac_cv_cxx_compiler_gnu = no; then
2782	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3040	<	echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3041	<	echo 'void f(){}' > conftest.cc
3042	<	if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3043	<	echo "$as_me:$LINENO: result: yes" >&5
3044	<	echo "${ECHO_T}yes" >&6
3045	<	OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3046	<	else
3047	<	echo "$as_me:$LINENO: result: no" >&5
3048	<	echo "${ECHO_T}no" >&6
3049	<	fi
3050	<	rm -f conftest*
3051	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3052	<	echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3053	<	echo 'void f(){}' > conftest.cc
3054	<	if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3055	<	echo "$as_me:$LINENO: result: yes" >&5
3056	<	echo "${ECHO_T}yes" >&6
3057	<	OOPSE_TEMPLATE_FLAGS="-instances=static"
3058	<	else
3059	<	echo "$as_me:$LINENO: result: no" >&5
3060	<	echo "${ECHO_T}no" >&6
3061	<	fi
3062	<	rm -f conftest*
3063	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3064	<	echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3065	<	echo 'void f(){}' > conftest.cc
3066	<	if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3067	<	echo "$as_me:$LINENO: result: yes" >&5
3068	<	echo "${ECHO_T}yes" >&6
3069	<	OOPSE_TEMPLATE_FLAGS="-pto"
3070	<	else
3071	<	echo "$as_me:$LINENO: result: no" >&5
3072	<	echo "${ECHO_T}no" >&6
3073	<	fi
3074	<	rm -f conftest*
3075	<	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
3081	<
3082	<
3083	<	EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3084	<	else
3085	<	echo "$as_me:$LINENO: result: no" >&5
3086	<	echo "${ECHO_T}no" >&6
3087	<	fi
3088	<	fi
3089	<
3090	<
3091	<
3092	<
3093	<	ac_ext=f90
3094	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3095	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3096	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2779	>	ac_ext=${FC_SRCEXT-f}
2780	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2781	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2782	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2783		if test -n "$ac_tool_prefix"; then
2784	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2784	>	for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2785		do
2786		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2787		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2788		echo "$as_me:$LINENO: checking for $ac_word" >&5
2789		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2790	<	if test "${ac_cv_prog_F90+set}" = set; then
2790	>	if test "${ac_cv_prog_FC+set}" = set; then
2791		echo $ECHO_N "(cached) $ECHO_C" >&6
2792		else
2793	<	if test -n "$F90"; then
2794	<	ac_cv_prog_F90="$F90" # Let the user override the test.
2793	>	if test -n "$FC"; then
2794	>	ac_cv_prog_FC="$FC" # Let the user override the test.
2795		else
2796		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2797		for as_dir in $PATH
#	Line 3114 | Line 2800 | do
2800		test -z "$as_dir" && as_dir=.
2801		for ac_exec_ext in '' $ac_executable_extensions; do
2802		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2803	<	ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2803	>	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2804		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2805		break 2
2806		fi
#	Line 3123 | Line 2809 | fi
2809
2810		fi
2811		fi
2812	<	F90=$ac_cv_prog_F90
2813	<	if test -n "$F90"; then
2814	<	echo "$as_me:$LINENO: result: $F90" >&5
2815	<	echo "${ECHO_T}$F90" >&6
2812	>	FC=$ac_cv_prog_FC
2813	>	if test -n "$FC"; then
2814	>	echo "$as_me:$LINENO: result: $FC" >&5
2815	>	echo "${ECHO_T}$FC" >&6
2816		else
2817		echo "$as_me:$LINENO: result: no" >&5
2818		echo "${ECHO_T}no" >&6
2819		fi
2820
2821	<	test -n "$F90" && break
2821	>	test -n "$FC" && break
2822		done
2823		fi
2824	<	if test -z "$F90"; then
2825	<	ac_ct_F90=$F90
2826	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2824	>	if test -z "$FC"; then
2825	>	ac_ct_FC=$FC
2826	>	for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2827		do
2828		# Extract the first word of "$ac_prog", so it can be a program name with args.
2829		set dummy $ac_prog; ac_word=$2
2830		echo "$as_me:$LINENO: checking for $ac_word" >&5
2831		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2832	<	if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2832	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2833		echo $ECHO_N "(cached) $ECHO_C" >&6
2834		else
2835	<	if test -n "$ac_ct_F90"; then
2836	<	ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2835	>	if test -n "$ac_ct_FC"; then
2836	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2837		else
2838		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2839		for as_dir in $PATH
#	Line 3156 | Line 2842 | do
2842		test -z "$as_dir" && as_dir=.
2843		for ac_exec_ext in '' $ac_executable_extensions; do
2844		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2845	<	ac_cv_prog_ac_ct_F90="$ac_prog"
2845	>	ac_cv_prog_ac_ct_FC="$ac_prog"
2846		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2847		break 2
2848		fi
#	Line 3165 | Line 2851 | fi
2851
2852		fi
2853		fi
2854	<	ac_ct_F90=$ac_cv_prog_ac_ct_F90
2855	<	if test -n "$ac_ct_F90"; then
2856	<	echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2857	<	echo "${ECHO_T}$ac_ct_F90" >&6
2854	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
2855	>	if test -n "$ac_ct_FC"; then
2856	>	echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2857	>	echo "${ECHO_T}$ac_ct_FC" >&6
2858		else
2859		echo "$as_me:$LINENO: result: no" >&5
2860		echo "${ECHO_T}no" >&6
2861		fi
2862
2863	<	test -n "$ac_ct_F90" && break
2863	>	test -n "$ac_ct_FC" && break
2864		done
2865
2866	<	F90=$ac_ct_F90
2866	>	FC=$ac_ct_FC
2867		fi
2868
2869
2870	<	# If we don't use `.F90' as extension, the preprocessor is not run on the
2871	<	# input file.
2870	>	# Provide some information about the compiler.
2871	>	echo "$as_me:2871:" \
2872	>	"checking for Fortran compiler version" >&5
2873	>	ac_compiler=`set X $ac_compile; echo $2`
2874	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2875	>	(eval $ac_compiler --version </dev/null >&5) 2>&5
2876	>	ac_status=$?
2877	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2878	>	(exit $ac_status); }
2879	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2880	>	(eval $ac_compiler -v </dev/null >&5) 2>&5
2881	>	ac_status=$?
2882	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883	>	(exit $ac_status); }
2884	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2885	>	(eval $ac_compiler -V </dev/null >&5) 2>&5
2886	>	ac_status=$?
2887	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888	>	(exit $ac_status); }
2889	>	rm -f a.out
2890	>
2891	>	# If we don't use `.F' as extension, the preprocessor is not run on the
2892	>	# input file.  (Note that this only needs to work for GNU compilers.)
2893		ac_save_ext=$ac_ext
2894	<	ac_ext=F90
2895	<	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2896	<	echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2897	<	if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2894	>	ac_ext=F
2895	>	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2896	>	echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2897	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2898		echo $ECHO_N "(cached) $ECHO_C" >&6
2899		else
2900		cat >conftest.$ac_ext <<_ACEOF
2901	<
3195	<	program main
3196	<
2901	>	program main
2902		#ifndef __GNUC__
2903		choke me
2904		#endif
2905
2906	<	end program main
3202	<
2906	>	end
2907		_ACEOF
2908		rm -f conftest.$ac_objext
2909		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3210 | Line 2914 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2914		cat conftest.err >&5
2915		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2916		(exit $ac_status); } &&
2917	<	{ ac_try='test -z "$ac_f90_werror_flag"
2917	>	{ ac_try='test -z "$ac_fc_werror_flag"
2918		|| test ! -s conftest.err'
2919		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2920		(eval $ac_try) 2>&5
#	Line 3231 | Line 2935 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2935		ac_compiler_gnu=no
2936		fi
2937		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2938	<	ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2938	>	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2939
2940		fi
2941	<	echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2942	<	echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2941	>	echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2942	>	echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2943		ac_ext=$ac_save_ext
2944	<	G95=`test $ac_compiler_gnu = yes && echo yes`
2945	<	ac_ext=c
2946	<	ac_cpp='$CPP $CPPFLAGS'
2947	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2948	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2949	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2944	>	ac_test_FFLAGS=${FCFLAGS+set}
2945	>	ac_save_FFLAGS=$FCFLAGS
2946	>	FCFLAGS=
2947	>	echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2948	>	echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2949	>	if test "${ac_cv_prog_fc_g+set}" = set; then
2950	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2951	>	else
2952	>	FCFLAGS=-g
2953	>	cat >conftest.$ac_ext <<_ACEOF
2954	>	program main
2955
2956	<
3248	<
3249	<
3250	<
3251	<	# Try to determine native compiler flags that allow us to use F90 suffix
3252	<	# for preprocessed f90 source.
3253	<
3254	<	if test "$ac_test_PREPFLAG" != "set"; then
3255	<	PREPFLAG=""
3256	<	case "${host_cpu}-${host_os}" in
3257	<
3258	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3259	<	PREPFLAG="-fpp1 "
3260	<	fi;;
3261	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3262	<	PREPFLAG="-qsuffix=cpp=F90 "
3263	<	fi;;
3264	<	*darwin*)
3265	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3266	<	PREPFLAG="-qsuffix=cpp=F90 "
3267	<	fi;;
3268	<	esac
3269	<
3270	<	if test -z "$PREPFLAG"; then
3271	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3272	<	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3273	<	PREPFLAG=""
3274	<	fi
3275	<
3276	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3277	<	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3278	<
3279	<
3280	<	ac_ext=f90
3281	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3282	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3283	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3284	<
3285	<	ac_save_ext=$ac_ext
3286	<	ac_ext=F90
3287	<	ac_save_F90FLAGS=$F90FLAGS
3288	<
3289	<	if test "$PREPFLAG"; then
3290	<	F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3291	<	fi
3292	<
3293	<	cat >conftest.$ac_ext <<_ACEOF
3294	<
3295	<
3296	<	program main
3297	<
3298	<	integer :: i
3299	<	i = 1
3300	<
3301	<
3302	<	end program main
3303	<
2956	>	end
2957		_ACEOF
2958		rm -f conftest.$ac_objext
2959		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3311 | Line 2964 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2964		cat conftest.err >&5
2965		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2966		(exit $ac_status); } &&
2967	<	{ ac_try='test -z "$ac_f90_werror_flag"
2967	>	{ ac_try='test -z "$ac_fc_werror_flag"
2968		|| test ! -s conftest.err'
2969		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2970		(eval $ac_try) 2>&5
#	Line 3324 | Line 2977 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2977		ac_status=$?
2978		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979		(exit $ac_status); }; }; then
2980	<	prepflagworks=1
2980	>	ac_cv_prog_fc_g=yes
2981		else
2982		echo "$as_me: failed program was:" >&5
2983		sed 's/^/| /' conftest.$ac_ext >&5
2984
2985	<	prepflagworks=0
2985	>	ac_cv_prog_fc_g=no
2986		fi
2987		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2988
2989	<	F90FLAGS=$ac_save_F90FLAGS
2990	<	ac_ext=$ac_save_ext
2991	<	ac_ext=c
2989	>	fi
2990	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2991	>	echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2992	>	if test "$ac_test_FFLAGS" = set; then
2993	>	FCFLAGS=$ac_save_FFLAGS
2994	>	elif test $ac_cv_prog_fc_g = yes; then
2995	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2996	>	FCFLAGS="-g -O2"
2997	>	else
2998	>	FCFLAGS="-g"
2999	>	fi
3000	>	else
3001	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3002	>	FCFLAGS="-O2"
3003	>	else
3004	>	FCFLAGS=
3005	>	fi
3006	>	fi
3007	>
3008	>	ac_ext=c
3009		ac_cpp='$CPP $CPPFLAGS'
3010		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3011		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3012		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3013
3014	+	ac_ext=c
3015	+	ac_cpp='$CPP $CPPFLAGS'
3016	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019	+	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
3020	+	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
3021	+	# On Suns, sometimes $CPP names a directory.
3022	+	if test -n "$CPP" && test -d "$CPP"; then
3023	+	CPP=
3024	+	fi
3025	+	if test -z "$CPP"; then
3026	+	if test "${ac_cv_prog_CPP+set}" = set; then
3027	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3028	+	else
3029	+	# Double quotes because CPP needs to be expanded
3030	+	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
3031	+	do
3032	+	ac_preproc_ok=false
3033	+	for ac_c_preproc_warn_flag in '' yes
3034	+	do
3035	+	# Use a header file that comes with gcc, so configuring glibc
3036	+	# with a fresh cross-compiler works.
3037	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3038	+	# <limits.h> exists even on freestanding compilers.
3039	+	# On the NeXT, cc -E runs the code through the compiler's parser,
3040	+	# not just through cpp. "Syntax error" is here to catch this case.
3041	+	cat >conftest.$ac_ext <<_ACEOF
3042	+	/* confdefs.h.  */
3043	+	_ACEOF
3044	+	cat confdefs.h >>conftest.$ac_ext
3045	+	cat >>conftest.$ac_ext <<_ACEOF
3046	+	/* end confdefs.h.  */
3047	+	#ifdef __STDC__
3048	+	# include <limits.h>
3049	+	#else
3050	+	# include <assert.h>
3051	+	#endif
3052	+	Syntax error
3053	+	_ACEOF
3054	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3055	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3056	+	ac_status=$?
3057	+	grep -v '^ *+' conftest.er1 >conftest.err
3058	+	rm -f conftest.er1
3059	+	cat conftest.err >&5
3060	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3061	+	(exit $ac_status); } >/dev/null; then
3062	+	if test -s conftest.err; then
3063	+	ac_cpp_err=$ac_c_preproc_warn_flag
3064	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3065	+	else
3066	+	ac_cpp_err=
3067	+	fi
3068	+	else
3069	+	ac_cpp_err=yes
3070	+	fi
3071	+	if test -z "$ac_cpp_err"; then
3072	+	:
3073	+	else
3074	+	echo "$as_me: failed program was:" >&5
3075	+	sed 's/^/| /' conftest.$ac_ext >&5
3076
3077	<	if test "$prepflagworks" = 1; then
3078	<	echo "$as_me:$LINENO: result: yes" >&5
3079	<	echo "${ECHO_T}yes" >&6
3077	>	# Broken: fails on valid input.
3078	>	continue
3079	>	fi
3080	>	rm -f conftest.err conftest.$ac_ext
3081
3082	+	# OK, works on sane cases.  Now check whether non-existent headers
3083	+	# can be detected and how.
3084	+	cat >conftest.$ac_ext <<_ACEOF
3085	+	/* confdefs.h.  */
3086	+	_ACEOF
3087	+	cat confdefs.h >>conftest.$ac_ext
3088	+	cat >>conftest.$ac_ext <<_ACEOF
3089	+	/* end confdefs.h.  */
3090	+	#include <ac_nonexistent.h>
3091	+	_ACEOF
3092	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3093	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3094	+	ac_status=$?
3095	+	grep -v '^ *+' conftest.er1 >conftest.err
3096	+	rm -f conftest.er1
3097	+	cat conftest.err >&5
3098	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3099	+	(exit $ac_status); } >/dev/null; then
3100	+	if test -s conftest.err; then
3101	+	ac_cpp_err=$ac_c_preproc_warn_flag
3102	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3103		else
3104	<	echo "$as_me:$LINENO: result: no" >&5
3351	<	echo "${ECHO_T}no" >&6
3352	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3353	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3354	<	{ (exit 1); exit 1; }; }
3104	>	ac_cpp_err=
3105		fi
3106	+	else
3107	+	ac_cpp_err=yes
3108		fi
3109	+	if test -z "$ac_cpp_err"; then
3110	+	# Broken: success on invalid input.
3111	+	continue
3112	+	else
3113	+	echo "$as_me: failed program was:" >&5
3114	+	sed 's/^/| /' conftest.$ac_ext >&5
3115
3116	+	# Passes both tests.
3117	+	ac_preproc_ok=:
3118	+	break
3119	+	fi
3120	+	rm -f conftest.err conftest.$ac_ext
3121
3122	<
3123	<
3124	<
3125	<	# Try to determine native compiler flags that allow us to use F90 suffix
3126	<	# for preprocessed f90 source with -D type defines
3364	<
3365	<	if test "$ac_test_PREPDEFFLAG" != "set"; then
3366	<	PREPDEFFLAG=""
3367	<	case "${host_cpu}-${host_os}" in
3368	<
3369	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3370	<	PREPDEFFLAG=" "
3371	<	fi;;
3372	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3373	<	PREPDEFFLAG="-WF,"
3374	<	fi;;
3375	<	*darwin*)
3376	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3377	<	PREPDEFFLAG="-WF,"
3378	<	fi;;
3379	<	esac
3380	<
3381	<	if test -z "$PREPDEFFLAG"; then
3382	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3383	<	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3384	<	PREPDEFFLAG=" "
3385	<	fi
3386	<
3387	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3388	<	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3389	<
3390	<
3391	<	ac_ext=f90
3392	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3393	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3394	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3395	<
3396	<	ac_save_ext=$ac_ext
3397	<	ac_ext=F90
3398	<	ac_save_F90FLAGS=$F90FLAGS
3399	<
3400	<	if test "$PREPDEFFLAG"; then
3401	<	F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3122	>	done
3123	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3124	>	rm -f conftest.err conftest.$ac_ext
3125	>	if $ac_preproc_ok; then
3126	>	break
3127		fi
3128
3129	<	cat >conftest.$ac_ext <<_ACEOF
3129	>	done
3130	>	ac_cv_prog_CPP=$CPP
3131
3132	<
3133	<	program main
3134	<
3135	<	integer :: i
3136	<	#ifdef TEST
3137	<	i = 1
3132	>	fi
3133	>	CPP=$ac_cv_prog_CPP
3134	>	else
3135	>	ac_cv_prog_CPP=$CPP
3136	>	fi
3137	>	echo "$as_me:$LINENO: result: $CPP" >&5
3138	>	echo "${ECHO_T}$CPP" >&6
3139	>	ac_preproc_ok=false
3140	>	for ac_c_preproc_warn_flag in '' yes
3141	>	do
3142	>	# Use a header file that comes with gcc, so configuring glibc
3143	>	# with a fresh cross-compiler works.
3144	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3145	>	# <limits.h> exists even on freestanding compilers.
3146	>	# On the NeXT, cc -E runs the code through the compiler's parser,
3147	>	# not just through cpp. "Syntax error" is here to catch this case.
3148	>	cat >conftest.$ac_ext <<_ACEOF
3149	>	/* confdefs.h.  */
3150	>	_ACEOF
3151	>	cat confdefs.h >>conftest.$ac_ext
3152	>	cat >>conftest.$ac_ext <<_ACEOF
3153	>	/* end confdefs.h.  */
3154	>	#ifdef __STDC__
3155	>	# include <limits.h>
3156		#else
3157	<	choke me
3157	>	# include <assert.h>
3158		#endif
3159	+	Syntax error
3160	+	_ACEOF
3161	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3162	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3163	+	ac_status=$?
3164	+	grep -v '^ *+' conftest.er1 >conftest.err
3165	+	rm -f conftest.er1
3166	+	cat conftest.err >&5
3167	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3168	+	(exit $ac_status); } >/dev/null; then
3169	+	if test -s conftest.err; then
3170	+	ac_cpp_err=$ac_c_preproc_warn_flag
3171	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3172	+	else
3173	+	ac_cpp_err=
3174	+	fi
3175	+	else
3176	+	ac_cpp_err=yes
3177	+	fi
3178	+	if test -z "$ac_cpp_err"; then
3179	+	:
3180	+	else
3181	+	echo "$as_me: failed program was:" >&5
3182	+	sed 's/^/| /' conftest.$ac_ext >&5
3183
3184	+	# Broken: fails on valid input.
3185	+	continue
3186	+	fi
3187	+	rm -f conftest.err conftest.$ac_ext
3188
3189	<	end program main
3190	<
3189	>	# OK, works on sane cases.  Now check whether non-existent headers
3190	>	# can be detected and how.
3191	>	cat >conftest.$ac_ext <<_ACEOF
3192	>	/* confdefs.h.  */
3193		_ACEOF
3194	<	rm -f conftest.$ac_objext
3195	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3196	<	(eval $ac_compile) 2>conftest.er1
3194	>	cat confdefs.h >>conftest.$ac_ext
3195	>	cat >>conftest.$ac_ext <<_ACEOF
3196	>	/* end confdefs.h.  */
3197	>	#include <ac_nonexistent.h>
3198	>	_ACEOF
3199	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3200	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3201		ac_status=$?
3202		grep -v '^ *+' conftest.er1 >conftest.err
3203		rm -f conftest.er1
3204		cat conftest.err >&5
3205		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3206	<	(exit $ac_status); } &&
3207	<	{ ac_try='test -z "$ac_f90_werror_flag"
3208	<	|| test ! -s conftest.err'
3209	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3210	<	(eval $ac_try) 2>&5
3211	<	ac_status=$?
3212	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3435	<	(exit $ac_status); }; } &&
3436	<	{ ac_try='test -s conftest.$ac_objext'
3437	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3438	<	(eval $ac_try) 2>&5
3439	<	ac_status=$?
3440	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3441	<	(exit $ac_status); }; }; then
3442	<	prepdefflagworks=1
3206	>	(exit $ac_status); } >/dev/null; then
3207	>	if test -s conftest.err; then
3208	>	ac_cpp_err=$ac_c_preproc_warn_flag
3209	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3210	>	else
3211	>	ac_cpp_err=
3212	>	fi
3213		else
3214	+	ac_cpp_err=yes
3215	+	fi
3216	+	if test -z "$ac_cpp_err"; then
3217	+	# Broken: success on invalid input.
3218	+	continue
3219	+	else
3220		echo "$as_me: failed program was:" >&5
3221		sed 's/^/| /' conftest.$ac_ext >&5
3222
3223	<	prepdefflagworks=0
3223	>	# Passes both tests.
3224	>	ac_preproc_ok=:
3225	>	break
3226		fi
3227	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3227	>	rm -f conftest.err conftest.$ac_ext
3228
3229	<	F90FLAGS=$ac_save_F90FLAGS
3230	<	ac_ext=$ac_save_ext
3231	<	ac_ext=c
3229	>	done
3230	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3231	>	rm -f conftest.err conftest.$ac_ext
3232	>	if $ac_preproc_ok; then
3233	>	:
3234	>	else
3235	>	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3236	>	See \`config.log' for more details." >&5
3237	>	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3238	>	See \`config.log' for more details." >&2;}
3239	>	{ (exit 1); exit 1; }; }
3240	>	fi
3241	>
3242	>	ac_ext=c
3243		ac_cpp='$CPP $CPPFLAGS'
3244		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3245		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3246		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3247
3248	+	echo "$as_me:$LINENO: checking for egrep" >&5
3249	+	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3250	+	if test "${ac_cv_prog_egrep+set}" = set; then
3251	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3252	+	else
3253	+	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3254	+	then ac_cv_prog_egrep='grep -E'
3255	+	else ac_cv_prog_egrep='egrep'
3256	+	fi
3257	+	fi
3258	+	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3259	+	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3260	+	EGREP=$ac_cv_prog_egrep
3261
3262
3263	<	if test "$prepdefflagworks" = 1; then
3264	<	echo "$as_me:$LINENO: result: yes" >&5
3263	>	echo "$as_me:$LINENO: checking whether ln -s works" >&5
3264	>	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3265	>	LN_S=$as_ln_s
3266	>	if test "$LN_S" = "ln -s"; then
3267	>	echo "$as_me:$LINENO: result: yes" >&5
3268		echo "${ECHO_T}yes" >&6
3269	+	else
3270	+	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3271	+	echo "${ECHO_T}no, using $LN_S" >&6
3272	+	fi
3273
3274	<	else
3275	<	echo "$as_me:$LINENO: result: no" >&5
3274	>	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3275	>	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3276	>	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3277	>	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3278	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3279	>	else
3280	>	cat >conftest.make <<\_ACEOF
3281	>	all:
3282	>	@echo 'ac_maketemp="$(MAKE)"'
3283	>	_ACEOF
3284	>	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3285	>	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3286	>	if test -n "$ac_maketemp"; then
3287	>	eval ac_cv_prog_make_${ac_make}_set=yes
3288	>	else
3289	>	eval ac_cv_prog_make_${ac_make}_set=no
3290	>	fi
3291	>	rm -f conftest.make
3292	>	fi
3293	>	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3294	>	echo "$as_me:$LINENO: result: yes" >&5
3295	>	echo "${ECHO_T}yes" >&6
3296	>	SET_MAKE=
3297	>	else
3298	>	echo "$as_me:$LINENO: result: no" >&5
3299		echo "${ECHO_T}no" >&6
3300	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3469	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3470	<	{ (exit 1); exit 1; }; }
3471	<	fi
3300	>	SET_MAKE="MAKE=${MAKE-make}"
3301		fi
3302
3303	<	ac_ext=f90
3304	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3305	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3306	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3303	>	if test -n "$ac_tool_prefix"; then
3304	>	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3305	>	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3306	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3307	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3308	>	if test "${ac_cv_prog_RANLIB+set}" = set; then
3309	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3310	>	else
3311	>	if test -n "$RANLIB"; then
3312	>	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3313	>	else
3314	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3315	>	for as_dir in $PATH
3316	>	do
3317	>	IFS=$as_save_IFS
3318	>	test -z "$as_dir" && as_dir=.
3319	>	for ac_exec_ext in '' $ac_executable_extensions; do
3320	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3321	>	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3322	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3323	>	break 2
3324	>	fi
3325	>	done
3326	>	done
3327
3479	–
3480	–
3481	–	ac_ext=f90
3482	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485	–	echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486	–	echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487	–	if test "${ac_cv_prog_f90_v+set}" = set; then
3488	–	echo $ECHO_N "(cached) $ECHO_C" >&6
3489	–	else
3490	–
3491	–	cat >conftest.$ac_ext <<_ACEOF
3492	–
3493	–	program main
3494	–
3495	–
3496	–	end program main
3497	–
3498	–	_ACEOF
3499	–	rm -f conftest.$ac_objext
3500	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3501	–	(eval $ac_compile) 2>conftest.er1
3502	–	ac_status=$?
3503	–	grep -v '^ *+' conftest.er1 >conftest.err
3504	–	rm -f conftest.er1
3505	–	cat conftest.err >&5
3506	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3507	–	(exit $ac_status); } &&
3508	–	{ ac_try='test -z "$ac_f90_werror_flag"
3509	–	|| test ! -s conftest.err'
3510	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3511	–	(eval $ac_try) 2>&5
3512	–	ac_status=$?
3513	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514	–	(exit $ac_status); }; } &&
3515	–	{ ac_try='test -s conftest.$ac_objext'
3516	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3517	–	(eval $ac_try) 2>&5
3518	–	ac_status=$?
3519	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520	–	(exit $ac_status); }; }; then
3521	–	ac_cv_prog_f90_v=
3522	–	# Try some options frequently used verbose output
3523	–	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3524	–	ac_ext=f90
3525	–	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
3528	–
3529	–	cat >conftest.$ac_ext <<_ACEOF
3530	–
3531	–	program main
3532	–
3533	–
3534	–	end program main
3535	–
3536	–	_ACEOF
3537	–
3538	–	# Compile and link our simple test program by passing a flag (argument
3539	–	# 1 to this macro) to the Fortran 90 compiler in order to get
3540	–	# "verbose" output that we can then parse for the Fortran 90 linker
3541	–	# flags.
3542	–	ac_save_F90FLAGS=$F90FLAGS
3543	–	F90FLAGS="$F90FLAGS $ac_verb"
3544	–
3545	–	(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
3549	–
3550	–	rm -f conftest.*
3551	–	ac_ext=f90
3552	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3553	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3554	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3555	–
3556	–	# If we are using xlf then replace all the commas with spaces.
3557	–	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3558	–	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3328		fi
3560	–
3561	–	# If we are using Cray Fortran then delete quotes.
3562	–	# Use "\"" instead of '"' for font-lock-mode.
3563	–	# FIXME: a more general fix for quoted arguments with spaces?
3564	–	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3565	–	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3329		fi
3330	<	# look for -l* and *.a constructs in the output
3331	<	for ac_arg in $ac_f90_v_output; do
3332	<	case $ac_arg in
3333	<	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3571	<	ac_cv_prog_f90_v=$ac_verb
3572	<	break 2 ;;
3573	<	esac
3574	<	done
3575	<	done
3576	<	if test -z "$ac_cv_prog_f90_v"; then
3577	<	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3578	<	echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3579	<	fi
3330	>	RANLIB=$ac_cv_prog_RANLIB
3331	>	if test -n "$RANLIB"; then
3332	>	echo "$as_me:$LINENO: result: $RANLIB" >&5
3333	>	echo "${ECHO_T}$RANLIB" >&6
3334		else
3335	<	echo "$as_me: failed program was:" >&5
3336	<	sed 's/^/| /' conftest.$ac_ext >&5
3583	<
3584	<	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3585	<	echo "$as_me: WARNING: compilation failed" >&2;}
3335	>	echo "$as_me:$LINENO: result: no" >&5
3336	>	echo "${ECHO_T}no" >&6
3337		fi
3587	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3338
3339		fi
3340	<	echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3341	<	echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3342	<	echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3343	<	echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3344	<	if test "${ac_cv_flibs+set}" = set; then
3340	>	if test -z "$ac_cv_prog_RANLIB"; then
3341	>	ac_ct_RANLIB=$RANLIB
3342	>	# Extract the first word of "ranlib", so it can be a program name with args.
3343	>	set dummy ranlib; ac_word=$2
3344	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3345	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3346	>	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3347		echo $ECHO_N "(cached) $ECHO_C" >&6
3348		else
3349	<	if test "x$F90LIBS" != "x"; then
3350	<	ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3349	>	if test -n "$ac_ct_RANLIB"; then
3350	>	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3351		else
3352	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3353	+	for as_dir in $PATH
3354	+	do
3355	+	IFS=$as_save_IFS
3356	+	test -z "$as_dir" && as_dir=.
3357	+	for ac_exec_ext in '' $ac_executable_extensions; do
3358	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3359	+	ac_cv_prog_ac_ct_RANLIB="ranlib"
3360	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3361	+	break 2
3362	+	fi
3363	+	done
3364	+	done
3365
3366	<	ac_ext=f90
3367	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3368	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3369	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3366	>	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3367	>	fi
3368	>	fi
3369	>	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3370	>	if test -n "$ac_ct_RANLIB"; then
3371	>	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3372	>	echo "${ECHO_T}$ac_ct_RANLIB" >&6
3373	>	else
3374	>	echo "$as_me:$LINENO: result: no" >&5
3375	>	echo "${ECHO_T}no" >&6
3376	>	fi
3377
3378	<	cat >conftest.$ac_ext <<_ACEOF
3378	>	RANLIB=$ac_ct_RANLIB
3379	>	else
3380	>	RANLIB="$ac_cv_prog_RANLIB"
3381	>	fi
3382
3608	–	program main
3383
3384	+	# Extract the first word of "perl", so it can be a program name with args.
3385	+	set dummy perl; ac_word=$2
3386	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3387	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3388	+	if test "${ac_cv_path_PERLINTERP+set}" = set; then
3389	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3390	+	else
3391	+	case $PERLINTERP in
3392	+	[\\/]* | ?:[\\/]*)
3393	+	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3394	+	;;
3395	+	*)
3396	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3397	+	for as_dir in $PATH
3398	+	do
3399	+	IFS=$as_save_IFS
3400	+	test -z "$as_dir" && as_dir=.
3401	+	for ac_exec_ext in '' $ac_executable_extensions; do
3402	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3403	+	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3404	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3405	+	break 2
3406	+	fi
3407	+	done
3408	+	done
3409
3410	<	end program main
3411	<
3412	<	_ACEOF
3614	<
3615	<	# Compile and link our simple test program by passing a flag (argument
3616	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3617	<	# "verbose" output that we can then parse for the Fortran 90 linker
3618	<	# flags.
3619	<	ac_save_F90FLAGS=$F90FLAGS
3620	<	F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3621	<
3622	<	(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
3626	<
3627	<	rm -f conftest.*
3628	<	ac_ext=f90
3629	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3630	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3631	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3632	<
3633	<	# If we are using xlf then replace all the commas with spaces.
3634	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3635	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3410	>	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3411	>	;;
3412	>	esac
3413		fi
3414	+	PERLINTERP=$ac_cv_path_PERLINTERP
3415
3416	<	# If we are using Cray Fortran then delete quotes.
3417	<	# Use "\"" instead of '"' for font-lock-mode.
3418	<	# FIXME: a more general fix for quoted arguments with spaces?
3419	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3420	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3416	>	if test -n "$PERLINTERP"; then
3417	>	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3418	>	echo "${ECHO_T}$PERLINTERP" >&6
3419	>	else
3420	>	echo "$as_me:$LINENO: result: no" >&5
3421	>	echo "${ECHO_T}no" >&6
3422		fi
3423
3424	<	ac_cv_f90libs=
3424	>	ac_cv_path_perlinterp="$PERLINTERP"
3425	>	_sHpB='#!'
3426
3427	+
3428	+	# Check whether --with-perl-shebang or --without-perl-shebang was given.
3429	+	if test "${with_perl_shebang+set}" = set; then
3430	+	withval="$with_perl_shebang"
3431	+	opt_perl_shebang="$withval"
3432	+	else
3433	+	opt_perl_shebang="not_set"
3434	+	fi;
3435	+	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3436	+	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3437	+	if test "${ax_cv_opt_perl_shebang+set}" = set; then
3438	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3439	+	else
3440	+	case "$opt_perl_shebang" in
3441	+	not_set  ) ax_cv_opt_perl_shebang=''
3442	+	;;
3443	+	*     )
3444	+	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3445	+	esac
3446	+
3447	+	fi
3448	+	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3449	+	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3450	+	if test "A$ax_cv_opt_perl_shebang" != "A"
3451	+	then
3452	+	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3453	+	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3454	+	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3455	+	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3456	+
3457	+	# Automatic detection of sharpbang formula starts here
3458	+	else
3459	+	_somian_shbangperl=`$PERLINTERP -V:startperl`
3460	+	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3461	+	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3462	+	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3463	+	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3464	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3465	+	else
3466	+	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3467	+	if test "x$_somian_kspb_perl" == x
3468	+	then _somian_ksbp_warn_empty='durnit'
3469	+	else
3470	+	case "A$_somian_kspb_perl" in
3471	+	A#!*perl* )
3472	+	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3473	+	;;
3474	+	A*    )  _somian_ksbp_warn_defau='trouble'
3475	+	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3476	+	esac
3477	+	fi
3478	+
3479	+	fi
3480	+	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3481	+	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3482	+	# The above prints Checking ... result message to user.
3483	+	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3484	+
3485	+	if test A${_somian_ksbp_warn_empty+set} == Aset
3486	+	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3487	+	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3488	+	fi
3489	+	# Inform user after printing result value
3490	+	if test A${_somian_ksbp_warn_defau+set} == Aset
3491	+	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3492	+	echo "$as_me: Maybe Not good -" >&6;}
3493	+	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3494	+	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3495	+	else { echo "$as_me:$LINENO: OK Good result - " >&5
3496	+	echo "$as_me: OK Good result - " >&6;}
3497	+	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3498	+	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3499	+	fi
3500	+	fi
3501	+
3502	+	# Find a good install program.  We prefer a C program (faster),
3503	+	# so one script is as good as another.  But avoid the broken or
3504	+	# incompatible versions:
3505	+	# SysV /etc/install, /usr/sbin/install
3506	+	# SunOS /usr/etc/install
3507	+	# IRIX /sbin/install
3508	+	# AIX /bin/install
3509	+	# AmigaOS /C/install, which installs bootblocks on floppy discs
3510	+	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3511	+	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3512	+	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3513	+	# OS/2's system install, which has a completely different semantic
3514	+	# ./install, which can be erroneously created by make from ./install.sh.
3515	+	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3516	+	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3517	+	if test -z "$INSTALL"; then
3518	+	if test "${ac_cv_path_install+set}" = set; then
3519	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3520	+	else
3521	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3522	+	for as_dir in $PATH
3523	+	do
3524	+	IFS=$as_save_IFS
3525	+	test -z "$as_dir" && as_dir=.
3526	+	# Account for people who put trailing slashes in PATH elements.
3527	+	case $as_dir/ in
3528	+	./ | .// | /cC/* | \
3529	+	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3530	+	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3531	+	/usr/ucb/* ) ;;
3532	+	*)
3533	+	# OSF1 and SCO ODT 3.0 have their own names for install.
3534	+	# Don't use installbsd from OSF since it installs stuff as root
3535	+	# by default.
3536	+	for ac_prog in ginstall scoinst install; do
3537	+	for ac_exec_ext in '' $ac_executable_extensions; do
3538	+	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3539	+	if test $ac_prog = install &&
3540	+	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3541	+	# AIX install.  It has an incompatible calling convention.
3542	+	:
3543	+	elif test $ac_prog = install &&
3544	+	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3545	+	# program-specific install script used by HP pwplus--don't use.
3546	+	:
3547	+	else
3548	+	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3549	+	break 3
3550	+	fi
3551	+	fi
3552	+	done
3553	+	done
3554	+	;;
3555	+	esac
3556	+	done
3557	+
3558	+
3559	+	fi
3560	+	if test "${ac_cv_path_install+set}" = set; then
3561	+	INSTALL=$ac_cv_path_install
3562	+	else
3563	+	# As a last resort, use the slow shell script.  We don't cache a
3564	+	# path for INSTALL within a source directory, because that will
3565	+	# break other packages using the cache if that directory is
3566	+	# removed, or if the path is relative.
3567	+	INSTALL=$ac_install_sh
3568	+	fi
3569	+	fi
3570	+	echo "$as_me:$LINENO: result: $INSTALL" >&5
3571	+	echo "${ECHO_T}$INSTALL" >&6
3572	+
3573	+	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3574	+	# It thinks the first close brace ends the variable substitution.
3575	+	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3576	+
3577	+	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3578	+
3579	+	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3580	+
3581	+	case "x$INSTALL" in
3582	+	x/*) ;;
3583	+	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3584	+	esac
3585	+	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3586	+	# Extract the first word of "ar", so it can be a program name with args.
3587	+	set dummy ar; ac_word=$2
3588	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3589	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3590	+	if test "${ac_cv_prog_AR+set}" = set; then
3591	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3592	+	else
3593	+	if test -n "$AR"; then
3594	+	ac_cv_prog_AR="$AR" # Let the user override the test.
3595	+	else
3596	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3597	+	for as_dir in $PATH
3598	+	do
3599	+	IFS=$as_save_IFS
3600	+	test -z "$as_dir" && as_dir=.
3601	+	for ac_exec_ext in '' $ac_executable_extensions; do
3602	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3603	+	ac_cv_prog_AR="ar"
3604	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3605	+	break 2
3606	+	fi
3607	+	done
3608	+	done
3609	+
3610	+	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3611	+	fi
3612	+	fi
3613	+	AR=$ac_cv_prog_AR
3614	+	if test -n "$AR"; then
3615	+	echo "$as_me:$LINENO: result: $AR" >&5
3616	+	echo "${ECHO_T}$AR" >&6
3617	+	else
3618	+	echo "$as_me:$LINENO: result: no" >&5
3619	+	echo "${ECHO_T}no" >&6
3620	+	fi
3621	+
3622	+	if test "$AR" = "NONE"; then
3623	+	cat >confcache <<\_ACEOF
3624	+	# This file is a shell script that caches the results of configure
3625	+	# tests run on this system so they can be shared between configure
3626	+	# scripts and configure runs, see configure's option --config-cache.
3627	+	# It is not useful on other systems.  If it contains results you don't
3628	+	# want to keep, you may remove or edit it.
3629	+	#
3630	+	# config.status only pays attention to the cache file if you give it
3631	+	# the --recheck option to rerun configure.
3632	+	#
3633	+	# `ac_cv_env_foo' variables (set or unset) will be overridden when
3634	+	# loading this file, other *unset* `ac_cv_foo' will be assigned the
3635	+	# following values.
3636	+
3637	+	_ACEOF
3638	+
3639	+	# The following way of writing the cache mishandles newlines in values,
3640	+	# but we know of no workaround that is simple, portable, and efficient.
3641	+	# So, don't put newlines in cache variables' values.
3642	+	# Ultrix sh set writes to stderr and can't be redirected directly,
3643	+	# and sets the high bit in the cache file unless we assign to the vars.
3644	+	{
3645	+	(set) 2>&1 |
3646	+	case `(ac_space=' '; set | grep ac_space) 2>&1` in
3647	+	*ac_space=\ *)
3648	+	# `set' does not quote correctly, so add quotes (double-quote
3649	+	# substitution turns \\\\ into \\, and sed turns \\ into \).
3650	+	sed -n \
3651	+	"s/'/'\\\\''/g;
3652	+	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3653	+	;;
3654	+	*)
3655	+	# `set' quotes correctly as required by POSIX, so do not add quotes.
3656	+	sed -n \
3657	+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3658	+	;;
3659	+	esac;
3660	+	} |
3661	+	sed '
3662	+	t clear
3663	+	: clear
3664	+	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3665	+	t end
3666	+	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3667	+	: end' >>confcache
3668	+	if diff $cache_file confcache >/dev/null 2>&1; then :; else
3669	+	if test -w $cache_file; then
3670	+	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3671	+	cat confcache >$cache_file
3672	+	else
3673	+	echo "not updating unwritable cache $cache_file"
3674	+	fi
3675	+	fi
3676	+	rm -f confcache
3677	+	exit 1
3678	+	fi
3679	+	# Extract the first word of "ps", so it can be a program name with args.
3680	+	set dummy ps; ac_word=$2
3681	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3682	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3683	+	if test "${ac_cv_path_PS+set}" = set; then
3684	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3685	+	else
3686	+	case $PS in
3687	+	[\\/]* | ?:[\\/]*)
3688	+	ac_cv_path_PS="$PS" # Let the user override the test with a path.
3689	+	;;
3690	+	*)
3691	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3692	+	for as_dir in $PATH
3693	+	do
3694	+	IFS=$as_save_IFS
3695	+	test -z "$as_dir" && as_dir=.
3696	+	for ac_exec_ext in '' $ac_executable_extensions; do
3697	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3698	+	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3699	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3700	+	break 2
3701	+	fi
3702	+	done
3703	+	done
3704	+
3705	+	;;
3706	+	esac
3707	+	fi
3708	+	PS=$ac_cv_path_PS
3709	+
3710	+	if test -n "$PS"; then
3711	+	echo "$as_me:$LINENO: result: $PS" >&5
3712	+	echo "${ECHO_T}$PS" >&6
3713	+	else
3714	+	echo "$as_me:$LINENO: result: no" >&5
3715	+	echo "${ECHO_T}no" >&6
3716	+	fi
3717	+
3718	+	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3719	+	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3720	+	if test "${ac_cv_prog_ps_syntax+set}" = set; then
3721	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3722	+	else
3723	+
3724	+	if $PS ax -o rss > /dev/null 2>&1; then
3725	+	ac_cv_prog_ps_ax=yes
3726	+	else
3727	+	ac_cv_prog_ps_ax=no
3728	+	fi
3729	+	if $PS -ef -o rss > /dev/null 2>&1; then
3730	+	ac_cv_prog_ps_ef=yes
3731	+	else
3732	+	ac_cv_prog_ps_ef=no
3733	+	fi
3734	+	if test "$ac_cv_prog_ps_ax" = yes; then
3735	+	ac_cv_prog_ps_syntax=BSD
3736	+	else
3737	+	if test "$ac_cv_prog_ps_ef" = yes; then
3738	+	ac_cv_prog_ps_syntax=POSIX
3739	+	else
3740	+	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3741	+	echo "$as_me: error: Could not determine ps syntax" >&2;}
3742	+	{ (exit 1); exit 1; }; }
3743	+	fi
3744	+	fi
3745	+
3746	+	fi
3747	+	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3748	+	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3749	+
3750	+	cat >>confdefs.h <<_ACEOF
3751	+	#define PSCOMMAND $PS
3752	+	_ACEOF
3753	+
3754	+	if test "$ac_cv_prog_ps_syntax" = BSD; then
3755	+
3756	+	cat >>confdefs.h <<\_ACEOF
3757	+	#define PSTYPE_IS_BSD 1
3758	+	_ACEOF
3759	+
3760	+	else
3761	+	if test "$ac_cv_prog_ps_syntax" = POSIX; then
3762	+
3763	+	cat >>confdefs.h <<\_ACEOF
3764	+	#define PSTYPE_IS_POSIX 1
3765	+	_ACEOF
3766	+
3767	+	else
3768	+	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3769	+	echo "$as_me: error: Unknown ps syntax type!" >&2;}
3770	+	{ (exit 1); exit 1; }; }
3771	+	fi
3772	+	fi
3773	+
3774	+	ac_ext=${FC_SRCEXT-f}
3775	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3776	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3777	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3778	+
3779	+
3780	+	echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3781	+	echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3782	+	if test "${ac_cv_fc_srcext_F90+set}" = set; then
3783	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3784	+	else
3785	+	ac_ext=F90
3786	+	ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3787	+	FCFLAGS_SRCEXT=""
3788	+	ac_cv_fc_srcext_F90=unknown
3789	+	for ac_flag in none -qsuffix=f=F90 -Tf; do
3790	+	test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3791	+	cat >conftest.$ac_ext <<_ACEOF
3792	+	program main
3793	+
3794	+	end
3795	+	_ACEOF
3796	+	rm -f conftest.$ac_objext
3797	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3798	+	(eval $ac_compile) 2>conftest.er1
3799	+	ac_status=$?
3800	+	grep -v '^ *+' conftest.er1 >conftest.err
3801	+	rm -f conftest.er1
3802	+	cat conftest.err >&5
3803	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804	+	(exit $ac_status); } &&
3805	+	{ ac_try='test -z "$ac_fc_werror_flag"
3806	+	|| test ! -s conftest.err'
3807	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808	+	(eval $ac_try) 2>&5
3809	+	ac_status=$?
3810	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3811	+	(exit $ac_status); }; } &&
3812	+	{ ac_try='test -s conftest.$ac_objext'
3813	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814	+	(eval $ac_try) 2>&5
3815	+	ac_status=$?
3816	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817	+	(exit $ac_status); }; }; then
3818	+	ac_cv_fc_srcext_F90=$ac_flag; break
3819	+	else
3820	+	echo "$as_me: failed program was:" >&5
3821	+	sed 's/^/| /' conftest.$ac_ext >&5
3822	+
3823	+	fi
3824	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3825	+	done
3826	+	rm -f conftest.$ac_objext conftest.F90
3827	+	FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3828	+
3829	+	fi
3830	+	echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3831	+	echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3832	+	if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3833	+	{ { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3834	+	echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3835	+	{ (exit 1); exit 1; }; }
3836	+	else
3837	+	FC_SRCEXT=F90
3838	+	if test "x$ac_cv_fc_srcext_F90" = xnone; then
3839	+	FCFLAGS_SRCEXT=""
3840	+	FCFLAGS_F90=""
3841	+	else
3842	+	FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3843	+	FCFLAGS_F90=$ac_cv_fc_srcext_F90
3844	+	fi
3845	+
3846	+
3847	+	fi
3848	+
3849	+
3850	+
3851	+
3852	+
3853	+	# Try to determine native compiler flags that allow us to use F90 suffix
3854	+	# for preprocessed f90 source.
3855	+
3856	+	if test "$ac_test_PREPFLAG" != "set"; then
3857	+	PREPFLAG=""
3858	+	case "${host_cpu}-${host_os}" in
3859	+
3860	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3861	+	PREPFLAG="-fpp1 "
3862	+	fi;;
3863	+	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3864	+	PREPFLAG="-qsuffix=cpp=F90 "
3865	+	fi;;
3866	+	*darwin*)
3867	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3868	+	PREPFLAG="-qsuffix=cpp=F90 "
3869	+	fi;;
3870	+	esac
3871	+
3872	+	if test -z "$PREPFLAG"; then
3873	+	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3874	+	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3875	+	PREPFLAG=""
3876	+	fi
3877	+
3878	+	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3879	+	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3880	+
3881	+
3882	+	ac_ext=${FC_SRCEXT-f}
3883	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3884	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3885	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3886	+
3887	+	ac_save_ext=$ac_ext
3888	+	ac_ext=F90
3889	+	ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3890	+
3891	+	if test "$PREPFLAG"; then
3892	+	FCFLAGS_SRCEXT="${PREPFLAG}"
3893	+	fi
3894	+
3895	+	cat >conftest.$ac_ext <<_ACEOF
3896	+
3897	+
3898	+	program conftest
3899	+	integer :: i
3900	+	i = 1
3901	+	end program conftest
3902	+
3903	+	_ACEOF
3904	+	rm -f conftest.$ac_objext
3905	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3906	+	(eval $ac_compile) 2>conftest.er1
3907	+	ac_status=$?
3908	+	grep -v '^ *+' conftest.er1 >conftest.err
3909	+	rm -f conftest.er1
3910	+	cat conftest.err >&5
3911	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912	+	(exit $ac_status); } &&
3913	+	{ ac_try='test -z "$ac_fc_werror_flag"
3914	+	|| test ! -s conftest.err'
3915	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3916	+	(eval $ac_try) 2>&5
3917	+	ac_status=$?
3918	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3919	+	(exit $ac_status); }; } &&
3920	+	{ ac_try='test -s conftest.$ac_objext'
3921	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3922	+	(eval $ac_try) 2>&5
3923	+	ac_status=$?
3924	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3925	+	(exit $ac_status); }; }; then
3926	+	prepflagworks=1
3927	+	else
3928	+	echo "$as_me: failed program was:" >&5
3929	+	sed 's/^/| /' conftest.$ac_ext >&5
3930	+
3931	+	prepflagworks=0
3932	+	fi
3933	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3934	+
3935	+	FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3936	+	ac_ext=$ac_save_ext
3937	+	ac_ext=${FC_SRCEXT-f}
3938	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3939	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3940	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3941	+
3942	+
3943	+	if test "$prepflagworks" = 1; then
3944	+	echo "$as_me:$LINENO: result: yes" >&5
3945	+	echo "${ECHO_T}yes" >&6
3946	+	FCFLAGS_SRCEXT="${PREPFLAG}"
3947	+
3948	+	else
3949	+	echo "$as_me:$LINENO: result: no" >&5
3950	+	echo "${ECHO_T}no" >&6
3951	+	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3952	+	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3953	+	{ (exit 1); exit 1; }; }
3954	+	fi
3955	+	fi
3956	+
3957	+
3958	+
3959	+
3960	+
3961	+	# Try to determine native compiler flags that allow us to use F90 suffix
3962	+	# for preprocessed f90 source with -D type defines
3963	+
3964	+	if test "$ac_test_PREPDEFFLAG" != "set"; then
3965	+	PREPDEFFLAG=""
3966	+	case "${host_cpu}-${host_os}" in
3967	+
3968	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3969	+	PREPDEFFLAG=" "
3970	+	fi;;
3971	+	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3972	+	PREPDEFFLAG="-WF,"
3973	+	fi;;
3974	+	*darwin*)
3975	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3976	+	PREPDEFFLAG="-WF,"
3977	+	fi;;
3978	+	esac
3979	+
3980	+	if test -z "$PREPDEFFLAG"; then
3981	+	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3982	+	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3983	+	PREPDEFFLAG=" "
3984	+	fi
3985	+
3986	+	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3987	+	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3988	+
3989	+
3990	+	ac_ext=${FC_SRCEXT-f}
3991	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3992	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3993	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3994	+
3995	+	ac_save_ext=$ac_ext
3996	+	ac_ext=F90
3997	+	ac_save_FCFLAGS=$FCFLAGS
3998	+
3999	+	if test "$PREPDEFFLAG"; then
4000	+	FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
4001	+	fi
4002	+
4003	+	cat >conftest.$ac_ext <<_ACEOF
4004	+
4005	+
4006	+	program conftest
4007	+	integer :: i
4008	+	#ifdef TEST
4009	+	i = 1
4010	+	#else
4011	+	choke me
4012	+	#endif
4013	+	end program conftest
4014	+
4015	+	_ACEOF
4016	+	rm -f conftest.$ac_objext
4017	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018	+	(eval $ac_compile) 2>conftest.er1
4019	+	ac_status=$?
4020	+	grep -v '^ *+' conftest.er1 >conftest.err
4021	+	rm -f conftest.er1
4022	+	cat conftest.err >&5
4023	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024	+	(exit $ac_status); } &&
4025	+	{ ac_try='test -z "$ac_fc_werror_flag"
4026	+	|| test ! -s conftest.err'
4027	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4028	+	(eval $ac_try) 2>&5
4029	+	ac_status=$?
4030	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031	+	(exit $ac_status); }; } &&
4032	+	{ ac_try='test -s conftest.$ac_objext'
4033	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4034	+	(eval $ac_try) 2>&5
4035	+	ac_status=$?
4036	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4037	+	(exit $ac_status); }; }; then
4038	+	prepdefflagworks=1
4039	+	else
4040	+	echo "$as_me: failed program was:" >&5
4041	+	sed 's/^/| /' conftest.$ac_ext >&5
4042	+
4043	+	prepdefflagworks=0
4044	+	fi
4045	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4046	+
4047	+	FCFLAGS=$ac_save_FCFLAGS
4048	+	ac_ext=$ac_save_ext
4049	+	ac_ext=${FC_SRCEXT-f}
4050	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4051	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4052	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4053	+
4054	+
4055	+	if test "$prepdefflagworks" = 1; then
4056	+	echo "$as_me:$LINENO: result: yes" >&5
4057	+	echo "${ECHO_T}yes" >&6
4058	+
4059	+	else
4060	+	echo "$as_me:$LINENO: result: no" >&5
4061	+	echo "${ECHO_T}no" >&6
4062	+	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4063	+	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4064	+	{ (exit 1); exit 1; }; }
4065	+	fi
4066	+	fi
4067	+
4068	+	ac_ext=${FC_SRCEXT-f}
4069	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4070	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4071	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4072	+	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4073	+	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4074	+	if test "${ac_cv_prog_fc_v+set}" = set; then
4075	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4076	+	else
4077	+	cat >conftest.$ac_ext <<_ACEOF
4078	+	program main
4079	+
4080	+	end
4081	+	_ACEOF
4082	+	rm -f conftest.$ac_objext
4083	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084	+	(eval $ac_compile) 2>conftest.er1
4085	+	ac_status=$?
4086	+	grep -v '^ *+' conftest.er1 >conftest.err
4087	+	rm -f conftest.er1
4088	+	cat conftest.err >&5
4089	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090	+	(exit $ac_status); } &&
4091	+	{ ac_try='test -z "$ac_fc_werror_flag"
4092	+	|| test ! -s conftest.err'
4093	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094	+	(eval $ac_try) 2>&5
4095	+	ac_status=$?
4096	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097	+	(exit $ac_status); }; } &&
4098	+	{ ac_try='test -s conftest.$ac_objext'
4099	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100	+	(eval $ac_try) 2>&5
4101	+	ac_status=$?
4102	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103	+	(exit $ac_status); }; }; then
4104	+	ac_cv_prog_fc_v=
4105	+	# Try some options frequently used verbose output
4106	+	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4107	+	cat >conftest.$ac_ext <<_ACEOF
4108	+	program main
4109	+
4110	+	end
4111	+	_ACEOF
4112	+
4113	+	# Compile and link our simple test program by passing a flag (argument
4114	+	# 1 to this macro) to the Fortran compiler in order to get
4115	+	# "verbose" output that we can then parse for the Fortran linker
4116	+	# flags.
4117	+	ac_save_FFLAGS=$FCFLAGS
4118	+	FCFLAGS="$FCFLAGS $ac_verb"
4119	+	(eval echo $as_me:4119: \"$ac_link\") >&5
4120	+	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4121	+	echo "$ac_fc_v_output" >&5
4122	+	FCFLAGS=$ac_save_FFLAGS
4123	+
4124	+	rm -f conftest*
4125	+
4126	+	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4127	+	# /foo, /bar, and /baz are search directories for the Fortran linker.
4128	+	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4129	+	ac_fc_v_output="`echo $ac_fc_v_output |
4130	+	grep 'LPATH is:' |
4131	+	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4132	+
4133	+	case $ac_fc_v_output in
4134	+	# If we are using xlf then replace all the commas with spaces.
4135	+	*xlfentry*)
4136	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4137	+
4138	+	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4139	+	# $LIBS confuse us, and the libraries appear later in the output anyway).
4140	+	*mGLOB_options_string*)
4141	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4142	+
4143	+	# If we are using Cray Fortran then delete quotes.
4144	+	# Use "\"" instead of '"' for font-lock-mode.
4145	+	# FIXME: a more general fix for quoted arguments with spaces?
4146	+	*cft90*)
4147	+	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4148	+	esac
4149	+
4150	+
4151	+	# look for -l* and *.a constructs in the output
4152	+	for ac_arg in $ac_fc_v_output; do
4153	+	case $ac_arg in
4154	+	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4155	+	ac_cv_prog_fc_v=$ac_verb
4156	+	break 2 ;;
4157	+	esac
4158	+	done
4159	+	done
4160	+	if test -z "$ac_cv_prog_fc_v"; then
4161	+	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4162	+	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4163	+	fi
4164	+	else
4165	+	echo "$as_me: failed program was:" >&5
4166	+	sed 's/^/| /' conftest.$ac_ext >&5
4167	+
4168	+	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4169	+	echo "$as_me: WARNING: compilation failed" >&2;}
4170	+	fi
4171	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4172	+
4173	+	fi
4174	+	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4175	+	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4176	+	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4177	+	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4178	+	if test "${ac_cv_fc_libs+set}" = set; then
4179	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4180	+	else
4181	+	if test "x$FCLIBS" != "x"; then
4182	+	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4183	+	else
4184	+
4185	+	cat >conftest.$ac_ext <<_ACEOF
4186	+	program main
4187	+
4188	+	end
4189	+	_ACEOF
4190	+
4191	+	# Compile and link our simple test program by passing a flag (argument
4192	+	# 1 to this macro) to the Fortran compiler in order to get
4193	+	# "verbose" output that we can then parse for the Fortran linker
4194	+	# flags.
4195	+	ac_save_FFLAGS=$FCFLAGS
4196	+	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4197	+	(eval echo $as_me:4197: \"$ac_link\") >&5
4198	+	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4199	+	echo "$ac_fc_v_output" >&5
4200	+	FCFLAGS=$ac_save_FFLAGS
4201	+
4202	+	rm -f conftest*
4203	+
4204	+	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4205	+	# /foo, /bar, and /baz are search directories for the Fortran linker.
4206	+	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4207	+	ac_fc_v_output="`echo $ac_fc_v_output |
4208	+	grep 'LPATH is:' |
4209	+	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4210	+
4211	+	case $ac_fc_v_output in
4212	+	# If we are using xlf then replace all the commas with spaces.
4213	+	*xlfentry*)
4214	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4215	+
4216	+	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4217	+	# $LIBS confuse us, and the libraries appear later in the output anyway).
4218	+	*mGLOB_options_string*)
4219	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4220	+
4221	+	# If we are using Cray Fortran then delete quotes.
4222	+	# Use "\"" instead of '"' for font-lock-mode.
4223	+	# FIXME: a more general fix for quoted arguments with spaces?
4224	+	*cft90*)
4225	+	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4226	+	esac
4227	+
4228	+
4229	+
4230	+	ac_cv_fc_libs=
4231	+
4232		# Save positional arguments (if any)
4233		ac_save_positional="$@"
4234
4235	<	set X $ac_f90_v_output
4235	>	set X $ac_fc_v_output
4236		while test $# != 1; do
4237		shift
4238		ac_arg=$1
4239		case $ac_arg in
4240		[\\/]*.a | ?:[\\/]*.a)
4241		ac_exists=false
4242	<	for ac_i in $ac_cv_f90libs; do
4242	>	for ac_i in $ac_cv_fc_libs; do
4243		if test x"$ac_arg" = x"$ac_i"; then
4244		ac_exists=true
4245		break
#	Line 3664 | Line 4249 | else
4249		if test x"$ac_exists" = xtrue; then
4250		:
4251		else
4252	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4252	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4253		fi
4254
4255		;;
4256		-bI:*)
4257		ac_exists=false
4258	<	for ac_i in $ac_cv_f90libs; do
4258	>	for ac_i in $ac_cv_fc_libs; do
4259		if test x"$ac_arg" = x"$ac_i"; then
4260		ac_exists=true
4261		break
#	Line 3682 | Line 4267 | else
4267		else
4268		if test "$ac_compiler_gnu" = yes; then
4269		for ac_link_opt in $ac_arg; do
4270	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4270	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4271		done
4272		else
4273	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4273	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4274		fi
4275		fi
4276
4277		;;
4278		# Ignore these flags.
4279	<	-lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4279	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4280		;;
4281		-lkernel32)
4282	<	test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4282	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4283		;;
4284		-[LRuY])
4285		# These flags, when seen by themselves, take an argument.
4286		# We remove the space between option and argument and re-iterate
4287		# unless we find an empty arg or a new option (starting with -)
4288		case $2 in
4289	<	"" | -*);;
4290	<	*)
4289	>	"" | -*);;
4290	>	*)
4291		ac_arg="$ac_arg$2"
3707	–
4292		shift; shift
4293		set X $ac_arg "$@"
4294		;;
#	Line 3713 | Line 4297 | fi
4297		-YP,*)
4298		for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4299		ac_exists=false
4300	<	for ac_i in $ac_cv_f90libs; do
4300	>	for ac_i in $ac_cv_fc_libs; do
4301		if test x"$ac_j" = x"$ac_i"; then
4302		ac_exists=true
4303		break
#	Line 3724 | Line 4308 | else
4308		:
4309		else
4310		ac_arg="$ac_arg $ac_j"
4311	<	ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4311	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4312		fi
4313
4314		done
4315		;;
4316		-[lLR]*)
4317		ac_exists=false
4318	<	for ac_i in $ac_cv_f90libs; do
4318	>	for ac_i in $ac_cv_fc_libs; do
4319		if test x"$ac_arg" = x"$ac_i"; then
4320		ac_exists=true
4321		break
#	Line 3741 | Line 4325 | else
4325		if test x"$ac_exists" = xtrue; then
4326		:
4327		else
4328	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4328	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4329		fi
4330
4331		;;
#	Line 3756 | Line 4340 | case `(uname -sr) 2>/dev/null` in
4340		# must begin with a "/").
4341		case `(uname -sr) 2>/dev/null` in
4342		"SunOS 5"*)
4343	<	ac_ld_run_path=`echo $ac_f90_v_output |
4343	>	ac_ld_run_path=`echo $ac_fc_v_output |
4344		sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4345		test "x$ac_ld_run_path" != x &&
3762	–
4346		if test "$ac_compiler_gnu" = yes; then
4347		for ac_link_opt in $ac_ld_run_path; do
4348	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4348	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4349		done
4350		else
4351	<	ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4351	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4352		fi
4353		;;
4354		esac
4355	<	fi # test "x$F90LIBS" = "x"
4355	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4356
4357		fi
4358	<	echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4359	<	echo "${ECHO_T}$ac_cv_flibs" >&6
4360	<	F90LIBS="$ac_cv_f90libs"
4358	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4359	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
4360	>	FCLIBS="$ac_cv_fc_libs"
4361
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
4362
4363	+	ac_ext=${FC_SRCEXT-f}
4364	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4365	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4366	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4367
4368	<	echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4369	<	echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4370	<	if test "${ac_cv_f90_mangling+set}" = set; then
4368	>
4369	>	ac_ext=${FC_SRCEXT-f}
4370	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4371	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4372	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4373	>
4374	>	echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4375	>	echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4376	>	if test "${ac_cv_fc_dummy_main+set}" = set; then
4377		echo $ECHO_N "(cached) $ECHO_C" >&6
4378		else
4379	<	ac_ext=f90
4380	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4381	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3794	<	cat >conftest.$ac_ext <<_ACEOF
3795	<	subroutine foobar()
3796	<	return
3797	<	end
3798	<	subroutine foo_bar()
3799	<	return
3800	<	end
3801	<	_ACEOF
3802	<	rm -f conftest.$ac_objext
3803	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3804	<	(eval $ac_compile) 2>conftest.er1
3805	<	ac_status=$?
3806	<	grep -v '^ *+' conftest.er1 >conftest.err
3807	<	rm -f conftest.er1
3808	<	cat conftest.err >&5
3809	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810	<	(exit $ac_status); } &&
3811	<	{ ac_try='test -z "$ac_f90_werror_flag"
3812	<	|| test ! -s conftest.err'
3813	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814	<	(eval $ac_try) 2>&5
3815	<	ac_status=$?
3816	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817	<	(exit $ac_status); }; } &&
3818	<	{ ac_try='test -s conftest.$ac_objext'
3819	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3820	<	(eval $ac_try) 2>&5
3821	<	ac_status=$?
3822	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3823	<	(exit $ac_status); }; }; then
3824	<	mv conftest.$ac_objext cf90_test.$ac_objext
3825	<
3826	<	ac_ext=c
4379	>	ac_fc_dm_save_LIBS=$LIBS
4380	>	LIBS="$LIBS $FCLIBS"
4381	>	ac_fortran_dm_var=FC_DUMMY_MAIN
4382	>	ac_ext=c
4383		ac_cpp='$CPP $CPPFLAGS'
4384		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4385		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4386		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4387
4388	<	ac_save_LIBS=$LIBS
4389	<	LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3834	<
3835	<	ac_success=no
3836	<	for ac_foobar in foobar FOOBAR; do
3837	<	for ac_underscore in "" "_"; do
3838	<	ac_func="$ac_foobar$ac_underscore"
3839	<	cat >conftest.$ac_ext <<_ACEOF
4388	>	# First, try linking without a dummy main:
4389	>	cat >conftest.$ac_ext <<_ACEOF
4390		/* confdefs.h.  */
4391		_ACEOF
4392		cat confdefs.h >>conftest.$ac_ext
4393		cat >>conftest.$ac_ext <<_ACEOF
4394		/* end confdefs.h.  */
4395
4396	<	/* Override any gcc2 internal prototype to avoid an error.  */
4397	<	#ifdef __cplusplus
4398	<	extern "C"
4396	>	#ifdef FC_DUMMY_MAIN
4397	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4398	>	#  ifdef __cplusplus
4399	>	extern "C"
4400	>	#  endif
4401	>	int FC_DUMMY_MAIN() { return 1; }
4402		#endif
4403	<	/* We use char because int might match the return type of a gcc2
3851	<	builtin and then its argument prototype would still apply.  */
3852	<	char $ac_func ();
4403	>	#endif
4404		int
4405		main ()
4406		{
4407	<	$ac_func ();
4407	>
4408		;
4409		return 0;
4410		}
#	Line 3880 | Line 4431 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4431		ac_status=$?
4432		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4433		(exit $ac_status); }; }; then
4434	<	ac_success=yes; break 2
4434	>	ac_cv_fortran_dummy_main=none
4435		else
4436		echo "$as_me: failed program was:" >&5
4437		sed 's/^/| /' conftest.$ac_ext >&5
4438
4439	+	ac_cv_fortran_dummy_main=unknown
4440		fi
4441		rm -f conftest.err conftest.$ac_objext \
4442		conftest$ac_exeext conftest.$ac_ext
3891	–	done
3892	–	done
4443
4444	<	if test "$ac_success" = "yes"; then
4445	<	case $ac_foobar in
4446	<	foobar)
3897	<	ac_case=lower
3898	<	ac_foo_bar=foo_bar
3899	<	;;
3900	<	FOOBAR)
3901	<	ac_case=upper
3902	<	ac_foo_bar=FOO_BAR
3903	<	;;
3904	<	esac
3905	<
3906	<	ac_success_extra=no
3907	<	for ac_extra in "" "_"; do
3908	<	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3909	<
3910	<	cat >conftest.$ac_ext <<_ACEOF
4444	>	if test $ac_cv_fortran_dummy_main = unknown; then
4445	>	for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4446	>	cat >conftest.$ac_ext <<_ACEOF
4447		/* confdefs.h.  */
4448		_ACEOF
4449		cat confdefs.h >>conftest.$ac_ext
4450		cat >>conftest.$ac_ext <<_ACEOF
4451		/* end confdefs.h.  */
4452	<
4453	<	/* Override any gcc2 internal prototype to avoid an error.  */
4454	<	#ifdef __cplusplus
4455	<	extern "C"
4452	>	#define $ac_fortran_dm_var $ac_func
4453	>	#ifdef FC_DUMMY_MAIN
4454	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4455	>	#  ifdef __cplusplus
4456	>	extern "C"
4457	>	#  endif
4458	>	int FC_DUMMY_MAIN() { return 1; }
4459		#endif
4460	<	/* We use char because int might match the return type of a gcc2
3922	<	builtin and then its argument prototype would still apply.  */
3923	<	char $ac_func ();
4460	>	#endif
4461		int
4462		main ()
4463		{
4464	<	$ac_func ();
4464	>
4465		;
4466		return 0;
4467		}
#	Line 3951 | Line 4488 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4488		ac_status=$?
4489		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4490		(exit $ac_status); }; }; then
4491	<	ac_success_extra=yes; break
4491	>	ac_cv_fortran_dummy_main=$ac_func; break
4492		else
4493		echo "$as_me: failed program was:" >&5
4494		sed 's/^/| /' conftest.$ac_ext >&5
#	Line 3959 | Line 4496 | rm -f conftest.err conftest.$ac_objext \
4496		fi
4497		rm -f conftest.err conftest.$ac_objext \
4498		conftest$ac_exeext conftest.$ac_ext
4499	<	done
4499	>	done
4500	>	fi
4501	>	ac_ext=${FC_SRCEXT-f}
4502	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4503	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4504	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4505	>	ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4506	>	rm -f conftest*
4507	>	LIBS=$ac_fc_dm_save_LIBS
4508
4509	<	if test "$ac_success_extra" = "yes"; then
4510	<	ac_cv_f90_mangling="$ac_case case"
4511	<	if test -z "$ac_underscore"; then
4512	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4513	<	else
4514	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4509	>	fi
4510	>	echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4511	>	echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4512	>	FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4513	>	if test "$FC_DUMMY_MAIN" != unknown; then
4514	>	if test $FC_DUMMY_MAIN != none; then
4515
4516	<	fi
4517	<	if test -z "$ac_extra"; then
4518	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3974	<	else
3975	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3976	<	fi
3977	<	else
3978	<	ac_cv_f90_mangling="unknown"
3979	<	fi
3980	<	else
3981	<	ac_cv_f90_mangling="unknown"
4516	>	cat >>confdefs.h <<_ACEOF
4517	>	#define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4518	>	_ACEOF
4519
4520	<	fi
4520	>	if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4521
4522	<	LIBS=$ac_save_LIBS
4523	<	ac_ext=f90
4524	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4525	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4526	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4527	<	rm -f cf90_test* conftest*
4528	<	else
4529	<	echo "$as_me: failed program was:" >&5
4530	<	sed 's/^/| /' conftest.$ac_ext >&5
4531	<
4532	<	fi
4533	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4534	<	ac_ext=f90
4535	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4536	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4537	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4538	<
4539	<	fi
4540	<	echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4541	<	echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4542	<
4543	<
4544	<
4545	<	case $ac_cv_f90_mangling in
4546	<	"lower case, no underscore, no extra underscore")
4547	<	cat >>confdefs.h <<\_ACEOF
4548	<	#define F90_FUNC(name,NAME) name
4549	<	_ACEOF
4550	<
4551	<	cat >>confdefs.h <<\_ACEOF
4552	<	#define F90_FUNC_(name,NAME) name
4553	<	_ACEOF
4554	<	;;
4555	<	"lower case, no underscore, extra underscore")
4556	<	cat >>confdefs.h <<\_ACEOF
4557	<	#define F90_FUNC(name,NAME) name
4558	<	_ACEOF
4559	<
4560	<	cat >>confdefs.h <<\_ACEOF
4561	<	#define F90_FUNC_(name,NAME) name ## _
4562	<	_ACEOF
4563	<	;;
4564	<	"lower case, underscore, no extra underscore")
4565	<	cat >>confdefs.h <<\_ACEOF
4566	<	#define F90_FUNC(name,NAME) name ## _
4567	<	_ACEOF
4568	<
4569	<	cat >>confdefs.h <<\_ACEOF
4570	<	#define F90_FUNC_(name,NAME) name ## _
4571	<	_ACEOF
4572	<	;;
4573	<	"lower case, underscore, extra underscore")
4574	<	cat >>confdefs.h <<\_ACEOF
4575	<	#define F90_FUNC(name,NAME) name ## _
4576	<	_ACEOF
4577	<
4578	<	cat >>confdefs.h <<\_ACEOF
4579	<	#define F90_FUNC_(name,NAME) name ## __
4580	<	_ACEOF
4581	<	;;
4582	<	"upper case, no underscore, no extra underscore")
4583	<	cat >>confdefs.h <<\_ACEOF
4584	<	#define F90_FUNC(name,NAME) NAME
4585	<	_ACEOF
4586	<
4587	<	cat >>confdefs.h <<\_ACEOF
4588	<	#define F90_FUNC_(name,NAME) NAME
4589	<	_ACEOF
4590	<	;;
4591	<	"upper case, no underscore, extra underscore")
4592	<	cat >>confdefs.h <<\_ACEOF
4593	<	#define F90_FUNC(name,NAME) NAME
4594	<	_ACEOF
4595	<
4596	<	cat >>confdefs.h <<\_ACEOF
4597	<	#define F90_FUNC_(name,NAME) NAME ## _
4598	<	_ACEOF
4599	<	;;
4600	<	"upper case, underscore, no extra underscore")
4601	<	cat >>confdefs.h <<\_ACEOF
4602	<	#define F90_FUNC(name,NAME) NAME ## _
4603	<	_ACEOF
4604	<
4605	<	cat >>confdefs.h <<\_ACEOF
4606	<	#define F90_FUNC_(name,NAME) NAME ## _
4607	<	_ACEOF
4608	<	;;
4609	<	"upper case, underscore, extra underscore")
4610	<	cat >>confdefs.h <<\_ACEOF
4611	<	#define F90_FUNC(name,NAME) NAME ## _
4612	<	_ACEOF
4613	<
4614	<	cat >>confdefs.h <<\_ACEOF
4615	<	#define F90_FUNC_(name,NAME) NAME ## __
4616	<	_ACEOF
4617	<	;;
4618	<	*)
4619	<	{ echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4620	<	echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4621	<	;;
4622	<	esac
4623	<
4624	<
4625	<
4626	<
4627	<
4628	<	echo "$as_me:$LINENO: checking for module suffix" >&5
4629	<	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4630	<	rm -f conftest*
4631	<	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4632	<	rm -f work*
4633	<	cat >conftest.f90 <<EOF
4634	<	module conftest
4635	<	integer n
4636	<	parameter (n=1)
4637	<	end module conftest
4638	<	EOF
4639	<	# SGI and absoft compilers generates module name in upper case!
4640	<	testname="conftest"
4641	<	modcase="lower"
4642	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4643	<	MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4644	<	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4645	<	if test -z "$MOD" ; then
4646	<	MOD=`ls CONFTEST* 2>/dev/null \
4647	<	| grep -v CONFTEST.f | grep -v CONFTEST.o`
4648	<	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4649	<	if test -n "$MOD" ; then
4650	<	testname="CONFTEST"
4651	<	modcase="upper"
4652	<	fi
4653	<	fi
4654	<	if test -z "$MOD" ; then
4655	<	echo "$as_me:$LINENO: result: unknown" >&5
4656	<	echo "${ECHO_T}unknown" >&6
4657	<	# Use mod if we can't figure it out
4658	<	MOD="mod"
4659	<	else
4660	<	echo "$as_me:$LINENO: result: $MOD" >&5
4661	<	echo "${ECHO_T}$MOD" >&6
4662	<	fi
4663	<	if test -s work.pcl ; then
4664	<	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4665	<	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4666	<	fi
4667	<	else
4668	<	echo "$as_me:$LINENO: result: unknown" >&5
4669	<	echo "${ECHO_T}unknown" >&6
4670	<	fi
4671	<
4672	<
4673	<
4674	<
4675	<
4676	<	# Check for module include path (some use -I, some (Solaris) use -M, some
4677	<	# (absoft) use -p).
4678	<	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4679	<	# specified, work.pcl and work.pc are created.  However, if you specify
4680	<	# a file, it must contain a the name of a file ending in .pc .  Ugh!
4681	<	# Use the module made above
4682	<	echo "$as_me:$LINENO: checking for module directory path flag" >&5
4683	<	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4684	<	rm -f conftest*
4685	<	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4686	<	rm -f work*
4687	<	cat >conftest.f90 <<EOF
4688	<	module conftest
4689	<	integer n
4690	<	parameter (n=1)
4691	<	end module conftest
4692	<	EOF
4693	<	# SGI and absoft compilers generates module name in upper case!
4694	<	testname="conftest"
4695	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4696	<	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4697	<	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4698	<	if test -n "$mod" ; then
4699	<	testname="CONFTEST"
4700	<	fi
4701	<	madedir=0
4702	<	if test ! -d conf ; then mkdir conf ; madedir=1; fi
4703	<	cp $testname.$MOD conf
4704	<	rm -f conftest* CONFTEST*
4705	<	cat >conftest1.f90 <<EOF
4706	<	program main
4707	<	use conftest
4708	<	print *, n
4709	<	end
4710	<	EOF
4711	<	F90_WORK_FILES_ARG=""
4712	<	F90MODINCSPEC=""
4713	<	if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4714	<	MODDIRFLAG="-I"
4715	<	F90MODINCSPEC="-I<dir>"
4716	<	echo "$as_me:$LINENO: result: -I" >&5
4717	<	echo "${ECHO_T}-I" >&6
4718	<	elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4719	<	MODDIRFLAG="-M"
4720	<	F90MODINCSPEC="-M<dir>"
4721	<	echo "$as_me:$LINENO: result: -M" >&5
4722	<	echo "${ECHO_T}-M" >&6
4723	<	elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4724	<	MODDIRFLAG="-p"
4725	<	F90MODINCSPEC="-p<dir>"
4726	<	echo "$as_me:$LINENO: result: -p" >&5
4727	<	echo "${ECHO_T}-p" >&6
4728	<	elif test -s work.pc ; then
4729	<	cp work.pc conf/mpimod.pc
4730	<	echo "mpimod.pc" > conf/mpimod.pcl
4731	<	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4732	<	if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4733	<	MODDIRFLAG='-cl,mpimod.pcl'
4734	<	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4735	<	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4736	<	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4737	<	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4738	<
4739	<	else
4740	<	# The version of the Intel compiler that I have refuses to let
4741	<	# you put the "work catalog" list anywhere but the current
4742	<	# directory. For example, you cannot in
4743	<	:
4744	<	fi
4745	<	fi
4746	<	if test -z "MODDIRFLAG" ; then
4747	<	echo "$as_me:$LINENO: result: unknown" >&5
4748	<	echo "${ECHO_T}unknown" >&6
4749	<	fi
4750	<
4751	<
4752	<	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4753	<	if test $madedir = 1 ; then rmdir conf ; fi
4754	<	fi
4755	<
4756	<
4757	<	echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4758	<	echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4759	<	if test "${ac_cv_f90_module_names+set}" = set; then
4760	<	echo $ECHO_N "(cached) $ECHO_C" >&6
4761	<	else
4762	<	ac_ext=f90
4763	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4764	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4765	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4766	<
4767	<	# carry out the test in a new directory, so that we don't miss anything
4768	<	mkdir conftest
4769	<	cd conftest
4770	<	cat >conftest.$ac_ext <<_ACEOF
4771	<	MODULE Bar
4772	<	END MODULE Bar
4773	<	_ACEOF
4774	<	rm -f conftest.$ac_objext
4775	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4776	<	(eval $ac_compile) 2>conftest.er1
4777	<	ac_status=$?
4778	<	grep -v '^ *+' conftest.er1 >conftest.err
4779	<	rm -f conftest.er1
4780	<	cat conftest.err >&5
4781	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4782	<	(exit $ac_status); } &&
4783	<	{ ac_try='test -z "$ac_f90_werror_flag"
4784	<	|| test ! -s conftest.err'
4785	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4786	<	(eval $ac_try) 2>&5
4787	<	ac_status=$?
4788	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4789	<	(exit $ac_status); }; } &&
4790	<	{ ac_try='test -s conftest.$ac_objext'
4791	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4792	<	(eval $ac_try) 2>&5
4793	<	ac_status=$?
4794	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4795	<	(exit $ac_status); }; }; then
4796	<	ac_cv_f90_module_names=
4797	<	ac_file_list=*
4798	<	for ac_file in $ac_file_list; do
4799	<	case $ac_file in
4800	<	# don't care for original source and object files
4801	<	conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4802	<	:
4803	<	;;
4804	<	# look for new files derived from the file name
4805	<	*conftest*)
4806	<	ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4807	<	ac_exists=false
4808	<	for ac_i in $ac_cv_f90_module_names; do
4809	<	if test x"$ac_pat" = x"$ac_i"; then
4810	<	ac_exists=true
4811	<	break
4812	<	fi
4813	<	done
4814	<
4815	<	if test x"$ac_exists" = xtrue; then
4816	<	:
4817	<	else
4818	<	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4819	<	fi
4820	<
4821	<	;;
4822	<	# look for new files derived from the module name,
4823	<	# with different case translation schemes
4824	<	*Bar*)
4825	<	ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4826	<	ac_exists=false
4827	<	for ac_i in $ac_cv_f90_module_names; do
4828	<	if test x"$ac_pat" = x"$ac_i"; then
4829	<	ac_exists=true
4830	<	break
4831	<	fi
4832	<	done
4833	<
4834	<	if test x"$ac_exists" = xtrue; then
4835	<	:
4836	<	else
4837	<	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4838	<	fi
4839	<
4840	<	;;
4841	<	*bar*)
4842	<	ac_pat=`echo $ac_file | sed s/bar/%module%/`
4843	<	ac_exists=false
4844	<	for ac_i in $ac_cv_f90_module_names; do
4845	<	if test x"$ac_pat" = x"$ac_i"; then
4846	<	ac_exists=true
4847	<	break
4848	<	fi
4849	<	done
4850	<
4851	<	if test x"$ac_exists" = xtrue; then
4852	<	:
4853	<	else
4854	<	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4855	<	fi
4856	<
4857	<	;;
4858	<	*BAR*)
4859	<	ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4860	<	ac_exists=false
4861	<	for ac_i in $ac_cv_f90_module_names; do
4862	<	if test x"$ac_pat" = x"$ac_i"; then
4863	<	ac_exists=true
4864	<	break
4865	<	fi
4866	<	done
4867	<
4868	<	if test x"$ac_exists" = xtrue; then
4869	<	:
4870	<	else
4871	<	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4872	<	fi
4873	<
4874	<	;;
4875	<	# Other files - we have no idea how they are generated
4876	<	*)
4877	<	{ echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4878	<	echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4879	<	;;
4880	<	esac
4881	<	done
4882	<	if test "x$ac_cv_f90_module_names" = "x"; then
4883	<	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4884	<	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4885	<	fi
4886	<
4887	<	else
4888	<	echo "$as_me: failed program was:" >&5
4889	<	sed 's/^/| /' conftest.$ac_ext >&5
4890	<
4891	<	ac_cv_f90_module_names=
4892	<	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4893	<	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4894	<	fi
4895	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4896	<	cd ..
4897	<	# cleanup
4898	<	rm -rf conftest
4899	<	ac_ext=f90
4900	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4901	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4902	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4903	<
4904	<	fi
4905	<	echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4906	<	echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4907	<
4908	<	# We now generate a shell script that will help us to figure out the correct
4909	<	# module file names, using the value of ac_cv_f90_module_names
4910	<
4911	<	echo "Generating shell script modnam"
4912	<
4913	<	cat > scripts/modnam << EOF
4914	<	#! /bin/sh
4915	<	# This script is auto-generated by configure
4916	<	#
4917	<	usage="\\
4918	<	Usage: \$0 [FILES]
4919	<
4920	<	[FILES] are Fortran 90 source files.
4921	<	The output is a list of module file names that the Fortran 90 compiler
4922	<	generates when compiling [FILES]."
4923	<
4924	<	list=
4925	<	empty=
4926	<
4927	<	if test \$# -eq 0; then
4928	<	echo "\$usage"; exit 0
4929	<	fi
4930	<
4931	<	while test \$# != 0; do
4932	<
4933	<	file=\$1
4934	<	shift
4935	<
4936	<	# strip suffix
4937	<	base=\`echo \$file | sed 's/[.][^.]*$//'\`
4938	<
4939	<	test ! -f \$file && continue
4940	<
4941	<	# Look for module definitions and transform them to upper / lower case
4942	<	mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4943	<	upper=\`echo \$mods | tr a-z A-Z\`
4944	<	lower=\`echo \$mods | tr A-Z a-z\`
4945	<
4946	<	# Here, the patterns for generating module file names were inserted by configure
4947	<	for trans in $ac_cv_f90_module_names; do
4948	<
4949	<	pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4950	<	var=empty
4951	<	case \$pat in
4952	<	%MODULE%)
4953	<	var=upper ;;
4954	<	%Module%)
4955	<	var=mods ;;
4956	<	%module%)
4957	<	var=lower ;;
4958	<	%FILE%)
4959	<	test -n "\$mods" && var=base ;;
4960	<	esac
4961	<	new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4962	<	list="\$list \$new"
4963	<	done
4964	<	done
4965	<
4966	<	echo \$list
4967	<	# end of configure-generated script
4968	<	EOF
4969	<	chmod 755 scripts/modnam
4970	<
4971	<	pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4972	<	F90_MODULE_NAMES=empty
4973	<	case $pat in
4974	<	%MODULE%)
4975	<	F90_MODULE_NAMES=UPPER ;;
4976	<	%Module%)
4977	<	F90_MODULE_NAMES=Mixed ;;
4978	<	%module%)
4979	<	F90_MODULE_NAMES=lower ;;
4980	<	*)
4981	<	F90_MODULE_NAMES=unknown ;;
4982	<	esac
4983	<
4984	<	ac_ext=c
4985	<	ac_cpp='$CPP $CPPFLAGS'
4986	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4987	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4988	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4989	<
4990	<
4991	<	ac_ext=c
4992	<	ac_cpp='$CPP $CPPFLAGS'
4993	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4994	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4995	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4522	>	cat >>confdefs.h <<\_ACEOF
4523	>	#define FC_DUMMY_MAIN_EQ_F77 1
4524	>	_ACEOF
4525	>
4526	>	fi
4527	>	fi
4528	>	else
4529	>	{ { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4530	>	See \`config.log' for more details." >&5
4531	>	echo "$as_me: error: linking to Fortran libraries from C fails
4532	>	See \`config.log' for more details." >&2;}
4533	>	{ (exit 1); exit 1; }; }
4534	>	fi
4535	>
4536	>
4537	>	ac_ext=${FC_SRCEXT-f}
4538	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4539	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4540	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4541	>
4542	>	ac_ext=${FC_SRCEXT-f}
4543	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4544	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4545	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4546	>	echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4547	>	echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4548	>	if test "${ac_cv_fc_mangling+set}" = set; then
4549	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4550	>	else
4551	>	cat >conftest.$ac_ext <<_ACEOF
4552	>	subroutine foobar()
4553	>	return
4554	>	end
4555	>	subroutine foo_bar()
4556	>	return
4557	>	end
4558	>	_ACEOF
4559	>	rm -f conftest.$ac_objext
4560	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4561	>	(eval $ac_compile) 2>conftest.er1
4562	>	ac_status=$?
4563	>	grep -v '^ *+' conftest.er1 >conftest.err
4564	>	rm -f conftest.er1
4565	>	cat conftest.err >&5
4566	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4567	>	(exit $ac_status); } &&
4568	>	{ ac_try='test -z "$ac_fc_werror_flag"
4569	>	|| test ! -s conftest.err'
4570	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4571	>	(eval $ac_try) 2>&5
4572	>	ac_status=$?
4573	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574	>	(exit $ac_status); }; } &&
4575	>	{ ac_try='test -s conftest.$ac_objext'
4576	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4577	>	(eval $ac_try) 2>&5
4578	>	ac_status=$?
4579	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580	>	(exit $ac_status); }; }; then
4581	>	mv conftest.$ac_objext cfortran_test.$ac_objext
4582	>
4583	>	ac_save_LIBS=$LIBS
4584	>	LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4585	>
4586	>	ac_ext=c
4587	>	ac_cpp='$CPP $CPPFLAGS'
4588	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4589	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4590	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4591	>	ac_success=no
4592	>	for ac_foobar in foobar FOOBAR; do
4593	>	for ac_underscore in "" "_"; do
4594	>	ac_func="$ac_foobar$ac_underscore"
4595	>	cat >conftest.$ac_ext <<_ACEOF
4596	>	/* confdefs.h.  */
4597	>	_ACEOF
4598	>	cat confdefs.h >>conftest.$ac_ext
4599	>	cat >>conftest.$ac_ext <<_ACEOF
4600	>	/* end confdefs.h.  */
4601	>
4602	>	/* Override any gcc2 internal prototype to avoid an error.  */
4603	>	#ifdef __cplusplus
4604	>	extern "C"
4605	>	#endif
4606	>	/* We use char because int might match the return type of a gcc2
4607	>	builtin and then its argument prototype would still apply.  */
4608	>	char $ac_func ();
4609	>	#ifdef FC_DUMMY_MAIN
4610	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4611	>	#  ifdef __cplusplus
4612	>	extern "C"
4613	>	#  endif
4614	>	int FC_DUMMY_MAIN() { return 1; }
4615	>	#endif
4616	>	#endif
4617	>	int
4618	>	main ()
4619	>	{
4620	>	$ac_func ();
4621	>	;
4622	>	return 0;
4623	>	}
4624	>	_ACEOF
4625	>	rm -f conftest.$ac_objext conftest$ac_exeext
4626	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4627	>	(eval $ac_link) 2>conftest.er1
4628	>	ac_status=$?
4629	>	grep -v '^ *+' conftest.er1 >conftest.err
4630	>	rm -f conftest.er1
4631	>	cat conftest.err >&5
4632	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4633	>	(exit $ac_status); } &&
4634	>	{ ac_try='test -z "$ac_c_werror_flag"
4635	>	|| test ! -s conftest.err'
4636	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4637	>	(eval $ac_try) 2>&5
4638	>	ac_status=$?
4639	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4640	>	(exit $ac_status); }; } &&
4641	>	{ ac_try='test -s conftest$ac_exeext'
4642	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4643	>	(eval $ac_try) 2>&5
4644	>	ac_status=$?
4645	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4646	>	(exit $ac_status); }; }; then
4647	>	ac_success=yes; break 2
4648	>	else
4649	>	echo "$as_me: failed program was:" >&5
4650	>	sed 's/^/| /' conftest.$ac_ext >&5
4651	>
4652	>	fi
4653	>	rm -f conftest.err conftest.$ac_objext \
4654	>	conftest$ac_exeext conftest.$ac_ext
4655	>	done
4656	>	done
4657	>	ac_ext=${FC_SRCEXT-f}
4658	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4659	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4660	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4661	>
4662	>	if test "$ac_success" = "yes"; then
4663	>	case $ac_foobar in
4664	>	foobar)
4665	>	ac_case=lower
4666	>	ac_foo_bar=foo_bar
4667	>	;;
4668	>	FOOBAR)
4669	>	ac_case=upper
4670	>	ac_foo_bar=FOO_BAR
4671	>	;;
4672	>	esac
4673	>
4674	>	ac_ext=c
4675	>	ac_cpp='$CPP $CPPFLAGS'
4676	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4677	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4678	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4679	>	ac_success_extra=no
4680	>	for ac_extra in "" "_"; do
4681	>	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4682	>	cat >conftest.$ac_ext <<_ACEOF
4683	>	/* confdefs.h.  */
4684	>	_ACEOF
4685	>	cat confdefs.h >>conftest.$ac_ext
4686	>	cat >>conftest.$ac_ext <<_ACEOF
4687	>	/* end confdefs.h.  */
4688	>
4689	>	/* Override any gcc2 internal prototype to avoid an error.  */
4690	>	#ifdef __cplusplus
4691	>	extern "C"
4692	>	#endif
4693	>	/* We use char because int might match the return type of a gcc2
4694	>	builtin and then its argument prototype would still apply.  */
4695	>	char $ac_func ();
4696	>	#ifdef FC_DUMMY_MAIN
4697	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4698	>	#  ifdef __cplusplus
4699	>	extern "C"
4700	>	#  endif
4701	>	int FC_DUMMY_MAIN() { return 1; }
4702	>	#endif
4703	>	#endif
4704	>	int
4705	>	main ()
4706	>	{
4707	>	$ac_func ();
4708	>	;
4709	>	return 0;
4710	>	}
4711	>	_ACEOF
4712	>	rm -f conftest.$ac_objext conftest$ac_exeext
4713	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4714	>	(eval $ac_link) 2>conftest.er1
4715	>	ac_status=$?
4716	>	grep -v '^ *+' conftest.er1 >conftest.err
4717	>	rm -f conftest.er1
4718	>	cat conftest.err >&5
4719	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720	>	(exit $ac_status); } &&
4721	>	{ ac_try='test -z "$ac_c_werror_flag"
4722	>	|| test ! -s conftest.err'
4723	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4724	>	(eval $ac_try) 2>&5
4725	>	ac_status=$?
4726	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4727	>	(exit $ac_status); }; } &&
4728	>	{ ac_try='test -s conftest$ac_exeext'
4729	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4730	>	(eval $ac_try) 2>&5
4731	>	ac_status=$?
4732	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4733	>	(exit $ac_status); }; }; then
4734	>	ac_success_extra=yes; break
4735	>	else
4736	>	echo "$as_me: failed program was:" >&5
4737	>	sed 's/^/| /' conftest.$ac_ext >&5
4738	>
4739	>	fi
4740	>	rm -f conftest.err conftest.$ac_objext \
4741	>	conftest$ac_exeext conftest.$ac_ext
4742	>	done
4743	>	ac_ext=${FC_SRCEXT-f}
4744	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4745	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4746	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4747	>
4748	>	if test "$ac_success_extra" = "yes"; then
4749	>	ac_cv_fc_mangling="$ac_case case"
4750	>	if test -z "$ac_underscore"; then
4751	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4752	>	else
4753	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4754	>	fi
4755	>	if test -z "$ac_extra"; then
4756	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4757	>	else
4758	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4759	>	fi
4760	>	else
4761	>	ac_cv_fc_mangling="unknown"
4762	>	fi
4763	>	else
4764	>	ac_cv_fc_mangling="unknown"
4765	>	fi
4766	>
4767	>	LIBS=$ac_save_LIBS
4768	>	rm -f cfortran_test* conftest*
4769	>	else
4770	>	echo "$as_me: failed program was:" >&5
4771	>	sed 's/^/| /' conftest.$ac_ext >&5
4772	>
4773	>	{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4774	>	See \`config.log' for more details." >&5
4775	>	echo "$as_me: error: cannot compile a simple Fortran program
4776	>	See \`config.log' for more details." >&2;}
4777	>	{ (exit 1); exit 1; }; }
4778	>	fi
4779	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4780	>
4781	>	fi
4782	>	echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4783	>	echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4784	>
4785	>	ac_ext=${FC_SRCEXT-f}
4786	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4787	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4788	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4789	>
4790	>	ac_ext=${FC_SRCEXT-f}
4791	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4792	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4793	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4794	>
4795	>
4796	>	case $ac_cv_fc_mangling in
4797	>	"lower case, no underscore, no extra underscore")
4798	>	cat >>confdefs.h <<\_ACEOF
4799	>	#define FC_FUNC(name,NAME) name
4800	>	_ACEOF
4801	>
4802	>	cat >>confdefs.h <<\_ACEOF
4803	>	#define FC_FUNC_(name,NAME) name
4804	>	_ACEOF
4805	>	;;
4806	>	"lower case, no underscore, extra underscore")
4807	>	cat >>confdefs.h <<\_ACEOF
4808	>	#define FC_FUNC(name,NAME) name
4809	>	_ACEOF
4810	>
4811	>	cat >>confdefs.h <<\_ACEOF
4812	>	#define FC_FUNC_(name,NAME) name ## _
4813	>	_ACEOF
4814	>	;;
4815	>	"lower case, underscore, no extra underscore")
4816	>	cat >>confdefs.h <<\_ACEOF
4817	>	#define FC_FUNC(name,NAME) name ## _
4818	>	_ACEOF
4819	>
4820	>	cat >>confdefs.h <<\_ACEOF
4821	>	#define FC_FUNC_(name,NAME) name ## _
4822	>	_ACEOF
4823	>	;;
4824	>	"lower case, underscore, extra underscore")
4825	>	cat >>confdefs.h <<\_ACEOF
4826	>	#define FC_FUNC(name,NAME) name ## _
4827	>	_ACEOF
4828	>
4829	>	cat >>confdefs.h <<\_ACEOF
4830	>	#define FC_FUNC_(name,NAME) name ## __
4831	>	_ACEOF
4832	>	;;
4833	>	"upper case, no underscore, no extra underscore")
4834	>	cat >>confdefs.h <<\_ACEOF
4835	>	#define FC_FUNC(name,NAME) NAME
4836	>	_ACEOF
4837	>
4838	>	cat >>confdefs.h <<\_ACEOF
4839	>	#define FC_FUNC_(name,NAME) NAME
4840	>	_ACEOF
4841	>	;;
4842	>	"upper case, no underscore, extra underscore")
4843	>	cat >>confdefs.h <<\_ACEOF
4844	>	#define FC_FUNC(name,NAME) NAME
4845	>	_ACEOF
4846	>
4847	>	cat >>confdefs.h <<\_ACEOF
4848	>	#define FC_FUNC_(name,NAME) NAME ## _
4849	>	_ACEOF
4850	>	;;
4851	>	"upper case, underscore, no extra underscore")
4852	>	cat >>confdefs.h <<\_ACEOF
4853	>	#define FC_FUNC(name,NAME) NAME ## _
4854	>	_ACEOF
4855	>
4856	>	cat >>confdefs.h <<\_ACEOF
4857	>	#define FC_FUNC_(name,NAME) NAME ## _
4858	>	_ACEOF
4859	>	;;
4860	>	"upper case, underscore, extra underscore")
4861	>	cat >>confdefs.h <<\_ACEOF
4862	>	#define FC_FUNC(name,NAME) NAME ## _
4863	>	_ACEOF
4864	>
4865	>	cat >>confdefs.h <<\_ACEOF
4866	>	#define FC_FUNC_(name,NAME) NAME ## __
4867	>	_ACEOF
4868	>	;;
4869	>	*)
4870	>	{ echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4871	>	echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4872	>	;;
4873	>	esac
4874	>
4875	>	ac_ext=${FC_SRCEXT-f}
4876	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4877	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4878	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4879	>
4880	>
4881	>
4882	>	ac_ext=${FC_SRCEXT-f}
4883	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4884	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4885	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4886	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4887	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4888	>	if test "${ac_cv_prog_fc_v+set}" = set; then
4889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4890	>	else
4891	>	cat >conftest.$ac_ext <<_ACEOF
4892	>	program main
4893	>
4894	>	end
4895	>	_ACEOF
4896	>	rm -f conftest.$ac_objext
4897	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4898	>	(eval $ac_compile) 2>conftest.er1
4899	>	ac_status=$?
4900	>	grep -v '^ *+' conftest.er1 >conftest.err
4901	>	rm -f conftest.er1
4902	>	cat conftest.err >&5
4903	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4904	>	(exit $ac_status); } &&
4905	>	{ ac_try='test -z "$ac_fc_werror_flag"
4906	>	|| test ! -s conftest.err'
4907	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4908	>	(eval $ac_try) 2>&5
4909	>	ac_status=$?
4910	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4911	>	(exit $ac_status); }; } &&
4912	>	{ ac_try='test -s conftest.$ac_objext'
4913	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4914	>	(eval $ac_try) 2>&5
4915	>	ac_status=$?
4916	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4917	>	(exit $ac_status); }; }; then
4918	>	ac_cv_prog_fc_v=
4919	>	# Try some options frequently used verbose output
4920	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4921	>	cat >conftest.$ac_ext <<_ACEOF
4922	>	program main
4923	>
4924	>	end
4925	>	_ACEOF
4926	>
4927	>	# Compile and link our simple test program by passing a flag (argument
4928	>	# 1 to this macro) to the Fortran compiler in order to get
4929	>	# "verbose" output that we can then parse for the Fortran linker
4930	>	# flags.
4931	>	ac_save_FFLAGS=$FCFLAGS
4932	>	FCFLAGS="$FCFLAGS $ac_verb"
4933	>	(eval echo $as_me:4933: \"$ac_link\") >&5
4934	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4935	>	echo "$ac_fc_v_output" >&5
4936	>	FCFLAGS=$ac_save_FFLAGS
4937	>
4938	>	rm -f conftest*
4939	>
4940	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4941	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4942	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4943	>	ac_fc_v_output="`echo $ac_fc_v_output |
4944	>	grep 'LPATH is:' |
4945	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4946	>
4947	>	case $ac_fc_v_output in
4948	>	# If we are using xlf then replace all the commas with spaces.
4949	>	*xlfentry*)
4950	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4951	>
4952	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4953	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4954	>	*mGLOB_options_string*)
4955	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4956	>
4957	>	# If we are using Cray Fortran then delete quotes.
4958	>	# Use "\"" instead of '"' for font-lock-mode.
4959	>	# FIXME: a more general fix for quoted arguments with spaces?
4960	>	*cft90*)
4961	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4962	>	esac
4963	>
4964	>
4965	>	# look for -l* and *.a constructs in the output
4966	>	for ac_arg in $ac_fc_v_output; do
4967	>	case $ac_arg in
4968	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4969	>	ac_cv_prog_fc_v=$ac_verb
4970	>	break 2 ;;
4971	>	esac
4972	>	done
4973	>	done
4974	>	if test -z "$ac_cv_prog_fc_v"; then
4975	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4976	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4977	>	fi
4978	>	else
4979	>	echo "$as_me: failed program was:" >&5
4980	>	sed 's/^/| /' conftest.$ac_ext >&5
4981	>
4982	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4983	>	echo "$as_me: WARNING: compilation failed" >&2;}
4984	>	fi
4985	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4986	>
4987	>	fi
4988	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4989	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4990	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4991	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4992	>	if test "${ac_cv_fc_libs+set}" = set; then
4993	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4994	>	else
4995	>	if test "x$FCLIBS" != "x"; then
4996	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4997	>	else
4998	>
4999	>	cat >conftest.$ac_ext <<_ACEOF
5000	>	program main
5001	>
5002	>	end
5003	>	_ACEOF
5004	>
5005	>	# Compile and link our simple test program by passing a flag (argument
5006	>	# 1 to this macro) to the Fortran compiler in order to get
5007	>	# "verbose" output that we can then parse for the Fortran linker
5008	>	# flags.
5009	>	ac_save_FFLAGS=$FCFLAGS
5010	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5011	>	(eval echo $as_me:5011: \"$ac_link\") >&5
5012	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5013	>	echo "$ac_fc_v_output" >&5
5014	>	FCFLAGS=$ac_save_FFLAGS
5015	>
5016	>	rm -f conftest*
5017	>
5018	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5019	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
5020	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5021	>	ac_fc_v_output="`echo $ac_fc_v_output |
5022	>	grep 'LPATH is:' |
5023	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5024	>
5025	>	case $ac_fc_v_output in
5026	>	# If we are using xlf then replace all the commas with spaces.
5027	>	*xlfentry*)
5028	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5029	>
5030	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5031	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
5032	>	*mGLOB_options_string*)
5033	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
5034	>
5035	>	# If we are using Cray Fortran then delete quotes.
5036	>	# Use "\"" instead of '"' for font-lock-mode.
5037	>	# FIXME: a more general fix for quoted arguments with spaces?
5038	>	*cft90*)
5039	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
5040	>	esac
5041	>
5042	>
5043	>
5044	>	ac_cv_fc_libs=
5045	>
5046	>	# Save positional arguments (if any)
5047	>	ac_save_positional="$@"
5048	>
5049	>	set X $ac_fc_v_output
5050	>	while test $# != 1; do
5051	>	shift
5052	>	ac_arg=$1
5053	>	case $ac_arg in
5054	>	[\\/]*.a | ?:[\\/]*.a)
5055	>	ac_exists=false
5056	>	for ac_i in $ac_cv_fc_libs; do
5057	>	if test x"$ac_arg" = x"$ac_i"; then
5058	>	ac_exists=true
5059	>	break
5060	>	fi
5061	>	done
5062	>
5063	>	if test x"$ac_exists" = xtrue; then
5064	>	:
5065	>	else
5066	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5067	>	fi
5068	>
5069	>	;;
5070	>	-bI:*)
5071	>	ac_exists=false
5072	>	for ac_i in $ac_cv_fc_libs; do
5073	>	if test x"$ac_arg" = x"$ac_i"; then
5074	>	ac_exists=true
5075	>	break
5076	>	fi
5077	>	done
5078	>
5079	>	if test x"$ac_exists" = xtrue; then
5080	>	:
5081	>	else
5082	>	if test "$ac_compiler_gnu" = yes; then
5083	>	for ac_link_opt in $ac_arg; do
5084	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5085	>	done
5086	>	else
5087	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5088	>	fi
5089	>	fi
5090	>
5091	>	;;
5092	>	# Ignore these flags.
5093	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5094	>	;;
5095	>	-lkernel32)
5096	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5097	>	;;
5098	>	-[LRuY])
5099	>	# These flags, when seen by themselves, take an argument.
5100	>	# We remove the space between option and argument and re-iterate
5101	>	# unless we find an empty arg or a new option (starting with -)
5102	>	case $2 in
5103	>	"" | -*);;
5104	>	*)
5105	>	ac_arg="$ac_arg$2"
5106	>	shift; shift
5107	>	set X $ac_arg "$@"
5108	>	;;
5109	>	esac
5110	>	;;
5111	>	-YP,*)
5112	>	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5113	>	ac_exists=false
5114	>	for ac_i in $ac_cv_fc_libs; do
5115	>	if test x"$ac_j" = x"$ac_i"; then
5116	>	ac_exists=true
5117	>	break
5118	>	fi
5119	>	done
5120	>
5121	>	if test x"$ac_exists" = xtrue; then
5122	>	:
5123	>	else
5124	>	ac_arg="$ac_arg $ac_j"
5125	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5126	>	fi
5127	>
5128	>	done
5129	>	;;
5130	>	-[lLR]*)
5131	>	ac_exists=false
5132	>	for ac_i in $ac_cv_fc_libs; do
5133	>	if test x"$ac_arg" = x"$ac_i"; then
5134	>	ac_exists=true
5135	>	break
5136	>	fi
5137	>	done
5138	>
5139	>	if test x"$ac_exists" = xtrue; then
5140	>	:
5141	>	else
5142	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5143	>	fi
5144	>
5145	>	;;
5146	>	# Ignore everything else.
5147	>	esac
5148	>	done
5149	>	# restore positional arguments
5150	>	set X $ac_save_positional; shift
5151	>
5152	>	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5153	>	# then we insist that the "run path" must be an absolute path (i.e. it
5154	>	# must begin with a "/").
5155	>	case `(uname -sr) 2>/dev/null` in
5156	>	"SunOS 5"*)
5157	>	ac_ld_run_path=`echo $ac_fc_v_output |
5158	>	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5159	>	test "x$ac_ld_run_path" != x &&
5160	>	if test "$ac_compiler_gnu" = yes; then
5161	>	for ac_link_opt in $ac_ld_run_path; do
5162	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5163	>	done
5164	>	else
5165	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5166	>	fi
5167	>	;;
5168	>	esac
5169	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5170	>
5171	>	fi
5172	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5173	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
5174	>	FCLIBS="$ac_cv_fc_libs"
5175	>
5176	>
5177	>	ac_ext=${FC_SRCEXT-f}
5178	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5179	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5180	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5181	>
5182	>
5183	>
5184	>	echo "$as_me:$LINENO: checking for module suffix" >&5
5185	>	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5186	>	rm -f conftest*
5187	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5188	>	rm -f work*
5189	>	cat >conftest.$ac_ext <<EOF
5190	>	module conftest
5191	>	integer n
5192	>	parameter (n=1)
5193	>	end module conftest
5194	>	EOF
5195	>	# SGI and absoft compilers generates module name in upper case!
5196	>	testname="conftest"
5197	>	modcase="lower"
5198	>	if (eval $ac_compile) 2>/dev/null ; then
5199	>	MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5200	>	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5201	>	if test -z "$MOD" ; then
5202	>	MOD=`ls CONFTEST* 2>/dev/null \
5203	>	| grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5204	>	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5205	>	if test -n "$MOD" ; then
5206	>	testname="CONFTEST"
5207	>	modcase="upper"
5208	>	fi
5209	>	fi
5210	>	if test -z "$MOD" ; then
5211	>	echo "$as_me:$LINENO: result: unknown" >&5
5212	>	echo "${ECHO_T}unknown" >&6
5213	>	# Use mod if we can't figure it out
5214	>	MOD="mod"
5215	>	else
5216	>	echo "$as_me:$LINENO: result: $MOD" >&5
5217	>	echo "${ECHO_T}$MOD" >&6
5218	>	fi
5219	>	if test -s work.pcl ; then
5220	>	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5221	>	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5222	>	fi
5223	>	else
5224	>	echo "$as_me:$LINENO: result: unknown" >&5
5225	>	echo "${ECHO_T}unknown" >&6
5226	>	fi
5227	>
5228	>
5229	>
5230	>
5231	>
5232	>	# Check for module include path (some use -I, some (Solaris) use -M, some
5233	>	# (absoft) use -p).
5234	>	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5235	>	# specified, work.pcl and work.pc are created.  However, if you specify
5236	>	# a file, it must contain a the name of a file ending in .pc .  Ugh!
5237	>	# Use the module made above
5238	>	echo "$as_me:$LINENO: checking for module directory path flag" >&5
5239	>	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5240	>	rm -f conftest*
5241	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5242	>	rm -f work*
5243	>	cat >conftest.$ac_ext <<EOF
5244	>	module conftest
5245	>	integer n
5246	>	parameter (n=1)
5247	>	end module conftest
5248	>	EOF
5249	>	# SGI and absoft compilers generates module name in upper case!
5250	>	testname="conftest"
5251	>	if (eval $ac_compile) 2>/dev/null ; then
5252	>	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5253	>	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5254	>	if test -n "$mod" ; then
5255	>	testname="CONFTEST"
5256	>	fi
5257	>	madedir=0
5258	>	if test ! -d conf ; then mkdir conf ; madedir=1; fi
5259	>	cp $testname.$MOD conf
5260	>	rm -f conftest* CONFTEST*
5261	>	cat >conftest1.$ac_ext <<EOF
5262	>	program main
5263	>	use conftest
5264	>	print *, n
5265	>	end
5266	>	EOF
5267	>	F90_WORK_FILES_ARG=""
5268	>	F90MODINCSPEC=""
5269	>	if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5270	>	MODDIRFLAG="-I"
5271	>	F90MODINCSPEC="-I<dir>"
5272	>	echo "$as_me:$LINENO: result: -I" >&5
5273	>	echo "${ECHO_T}-I" >&6
5274	>	elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5275	>	MODDIRFLAG="-M"
5276	>	F90MODINCSPEC="-M<dir>"
5277	>	echo "$as_me:$LINENO: result: -M" >&5
5278	>	echo "${ECHO_T}-M" >&6
5279	>	elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5280	>	MODDIRFLAG="-p"
5281	>	F90MODINCSPEC="-p<dir>"
5282	>	echo "$as_me:$LINENO: result: -p" >&5
5283	>	echo "${ECHO_T}-p" >&6
5284	>	elif test -s work.pc ; then
5285	>	cp work.pc conf/mpimod.pc
5286	>	echo "mpimod.pc" > conf/mpimod.pcl
5287	>	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5288	>	if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5289	>	MODDIRFLAG='-cl,mpimod.pcl'
5290	>	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5291	>	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5292	>	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5293	>	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5294	>
5295	>	else
5296	>	# The version of the Intel compiler that I have refuses to let
5297	>	# you put the "work catalog" list anywhere but the current
5298	>	# directory. For example, you cannot in
5299	>	:
5300	>	fi
5301	>	fi
5302	>	if test -z "MODDIRFLAG" ; then
5303	>	echo "$as_me:$LINENO: result: unknown" >&5
5304	>	echo "${ECHO_T}unknown" >&6
5305	>	fi
5306	>
5307	>
5308	>	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5309	>	if test $madedir = 1 ; then rmdir conf ; fi
5310	>	fi
5311	>
5312	>
5313	>	echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5314	>	echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5315	>	if test "${ac_cv_f90_module_names+set}" = set; then
5316	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5317	>	else
5318	>	ac_ext=${FC_SRCEXT-f}
5319	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5320	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5321	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5322	>
5323	>	# carry out the test in a new directory, so that we don't miss anything
5324	>	mkdir conftest
5325	>	cd conftest
5326	>	cat >conftest.$ac_ext <<_ACEOF
5327	>	MODULE Bar
5328	>	END MODULE Bar
5329	>	_ACEOF
5330	>	rm -f conftest.$ac_objext
5331	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5332	>	(eval $ac_compile) 2>conftest.er1
5333	>	ac_status=$?
5334	>	grep -v '^ *+' conftest.er1 >conftest.err
5335	>	rm -f conftest.er1
5336	>	cat conftest.err >&5
5337	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5338	>	(exit $ac_status); } &&
5339	>	{ ac_try='test -z "$ac_fc_werror_flag"
5340	>	|| test ! -s conftest.err'
5341	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5342	>	(eval $ac_try) 2>&5
5343	>	ac_status=$?
5344	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5345	>	(exit $ac_status); }; } &&
5346	>	{ ac_try='test -s conftest.$ac_objext'
5347	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5348	>	(eval $ac_try) 2>&5
5349	>	ac_status=$?
5350	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5351	>	(exit $ac_status); }; }; then
5352	>	ac_cv_f90_module_names=
5353	>	ac_file_list=*
5354	>	for ac_file in $ac_file_list; do
5355	>	case $ac_file in
5356	>	# don't care for original source and object files
5357	>	conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5358	>	:
5359	>	;;
5360	>	# look for new files derived from the file name
5361	>	*conftest*)
5362	>	ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5363	>	ac_exists=false
5364	>	for ac_i in $ac_cv_f90_module_names; do
5365	>	if test x"$ac_pat" = x"$ac_i"; then
5366	>	ac_exists=true
5367	>	break
5368	>	fi
5369	>	done
5370	>
5371	>	if test x"$ac_exists" = xtrue; then
5372	>	:
5373	>	else
5374	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5375	>	fi
5376	>
5377	>	;;
5378	>	# look for new files derived from the module name,
5379	>	# with different case translation schemes
5380	>	*Bar*)
5381	>	ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5382	>	ac_exists=false
5383	>	for ac_i in $ac_cv_f90_module_names; do
5384	>	if test x"$ac_pat" = x"$ac_i"; then
5385	>	ac_exists=true
5386	>	break
5387	>	fi
5388	>	done
5389	>
5390	>	if test x"$ac_exists" = xtrue; then
5391	>	:
5392	>	else
5393	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5394	>	fi
5395	>
5396	>	;;
5397	>	*bar*)
5398	>	ac_pat=`echo $ac_file | sed s/bar/%module%/`
5399	>	ac_exists=false
5400	>	for ac_i in $ac_cv_f90_module_names; do
5401	>	if test x"$ac_pat" = x"$ac_i"; then
5402	>	ac_exists=true
5403	>	break
5404	>	fi
5405	>	done
5406	>
5407	>	if test x"$ac_exists" = xtrue; then
5408	>	:
5409	>	else
5410	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5411	>	fi
5412	>
5413	>	;;
5414	>	*BAR*)
5415	>	ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5416	>	ac_exists=false
5417	>	for ac_i in $ac_cv_f90_module_names; do
5418	>	if test x"$ac_pat" = x"$ac_i"; then
5419	>	ac_exists=true
5420	>	break
5421	>	fi
5422	>	done
5423	>
5424	>	if test x"$ac_exists" = xtrue; then
5425	>	:
5426	>	else
5427	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5428	>	fi
5429	>
5430	>	;;
5431	>	# Other files - we have no idea how they are generated
5432	>	*)
5433	>	{ echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5434	>	echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5435	>	;;
5436	>	esac
5437	>	done
5438	>	if test "x$ac_cv_f90_module_names" = "x"; then
5439	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5440	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5441	>	fi
5442	>
5443	>	else
5444	>	echo "$as_me: failed program was:" >&5
5445	>	sed 's/^/| /' conftest.$ac_ext >&5
5446	>
5447	>	ac_cv_f90_module_names=
5448	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5449	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5450	>	fi
5451	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5452	>	cd ..
5453	>	# cleanup
5454	>	rm -rf conftest
5455	>	ac_ext=${FC_SRCEXT-f}
5456	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5457	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5458	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5459	>
5460	>	fi
5461	>	echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5462	>	echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5463	>
5464	>	# We now generate a shell script that will help us to figure out the correct
5465	>	# module file names, using the value of ac_cv_f90_module_names
5466	>
5467	>	echo "Generating shell script modnam"
5468	>
5469	>	cat > scripts/modnam << EOF
5470	>	#! /bin/sh
5471	>	# This script is auto-generated by configure
5472	>	#
5473	>	usage="\\
5474	>	Usage: \$0 [FILES]
5475	>
5476	>	[FILES] are Fortran 90 source files.
5477	>	The output is a list of module file names that the Fortran 90 compiler
5478	>	generates when compiling [FILES]."
5479	>
5480	>	list=
5481	>	empty=
5482	>
5483	>	if test \$# -eq 0; then
5484	>	echo "\$usage"; exit 0
5485	>	fi
5486	>
5487	>	while test \$# != 0; do
5488	>
5489	>	file=\$1
5490	>	shift
5491	>
5492	>	# strip suffix
5493	>	base=\`echo \$file | sed 's/[.][^.]*$//'\`
5494	>
5495	>	test ! -f \$file && continue
5496	>
5497	>	# Look for module definitions and transform them to upper / lower case
5498	>	mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5499	>	upper=\`echo \$mods | tr a-z A-Z\`
5500	>	lower=\`echo \$mods | tr A-Z a-z\`
5501	>
5502	>	# Here, the patterns for generating module file names were inserted by configure
5503	>	for trans in $ac_cv_f90_module_names; do
5504	>
5505	>	pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5506	>	var=empty
5507	>	case \$pat in
5508	>	%MODULE%)
5509	>	var=upper ;;
5510	>	%Module%)
5511	>	var=mods ;;
5512	>	%module%)
5513	>	var=lower ;;
5514	>	%FILE%)
5515	>	test -n "\$mods" && var=base ;;
5516	>	esac
5517	>	new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5518	>	list="\$list \$new"
5519	>	done
5520	>	done
5521	>
5522	>	echo \$list
5523	>	# end of configure-generated script
5524	>	EOF
5525	>	chmod 755 scripts/modnam
5526	>
5527	>	pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5528	>	F90_MODULE_NAMES=empty
5529	>	case $pat in
5530	>	%MODULE%)
5531	>	F90_MODULE_NAMES=UPPER ;;
5532	>	%Module%)
5533	>	F90_MODULE_NAMES=Mixed ;;
5534	>	%module%)
5535	>	F90_MODULE_NAMES=lower ;;
5536	>	*)
5537	>	F90_MODULE_NAMES=unknown ;;
5538	>	esac
5539	>
5540	>	ac_ext=c
5541	>	ac_cpp='$CPP $CPPFLAGS'
5542	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5543	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5544	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5545	>
5546	>
5547	>	ac_ext=c
5548	>	ac_cpp='$CPP $CPPFLAGS'
5549	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5550	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5551	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5552	>
5553	>
5554	>
5555	>	echo "$as_me:$LINENO: checking for asin in -lm" >&5
5556	>	echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5557	>	if test "${ac_cv_lib_m_asin+set}" = set; then
5558	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5559	>	else
5560	>	ac_check_lib_save_LIBS=$LIBS
5561	>	LIBS="-lm  $LIBS"
5562	>	cat >conftest.$ac_ext <<_ACEOF
5563	>	/* confdefs.h.  */
5564	>	_ACEOF
5565	>	cat confdefs.h >>conftest.$ac_ext
5566	>	cat >>conftest.$ac_ext <<_ACEOF
5567	>	/* end confdefs.h.  */
5568	>
5569	>	/* Override any gcc2 internal prototype to avoid an error.  */
5570	>	#ifdef __cplusplus
5571	>	extern "C"
5572	>	#endif
5573	>	/* We use char because int might match the return type of a gcc2
5574	>	builtin and then its argument prototype would still apply.  */
5575	>	char asin ();
5576	>	#ifdef FC_DUMMY_MAIN
5577	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5578	>	#  ifdef __cplusplus
5579	>	extern "C"
5580	>	#  endif
5581	>	int FC_DUMMY_MAIN() { return 1; }
5582	>	#endif
5583	>	#endif
5584	>	int
5585	>	main ()
5586	>	{
5587	>	asin ();
5588	>	;
5589	>	return 0;
5590	>	}
5591	>	_ACEOF
5592	>	rm -f conftest.$ac_objext conftest$ac_exeext
5593	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5594	>	(eval $ac_link) 2>conftest.er1
5595	>	ac_status=$?
5596	>	grep -v '^ *+' conftest.er1 >conftest.err
5597	>	rm -f conftest.er1
5598	>	cat conftest.err >&5
5599	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600	>	(exit $ac_status); } &&
5601	>	{ ac_try='test -z "$ac_c_werror_flag"
5602	>	|| test ! -s conftest.err'
5603	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5604	>	(eval $ac_try) 2>&5
5605	>	ac_status=$?
5606	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5607	>	(exit $ac_status); }; } &&
5608	>	{ ac_try='test -s conftest$ac_exeext'
5609	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610	>	(eval $ac_try) 2>&5
5611	>	ac_status=$?
5612	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613	>	(exit $ac_status); }; }; then
5614	>	ac_cv_lib_m_asin=yes
5615	>	else
5616	>	echo "$as_me: failed program was:" >&5
5617	>	sed 's/^/| /' conftest.$ac_ext >&5
5618	>
5619	>	ac_cv_lib_m_asin=no
5620	>	fi
5621	>	rm -f conftest.err conftest.$ac_objext \
5622	>	conftest$ac_exeext conftest.$ac_ext
5623	>	LIBS=$ac_check_lib_save_LIBS
5624	>	fi
5625	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5626	>	echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5627	>	if test $ac_cv_lib_m_asin = yes; then
5628	>	cat >>confdefs.h <<_ACEOF
5629	>	#define HAVE_LIBM 1
5630	>	_ACEOF
5631	>
5632	>	LIBS="-lm $LIBS"
5633	>
5634	>	else
5635	>	exit
5636	>	fi
5637	>
5638	>
5639	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5640	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5641	>	if test "${ac_cv_header_stdc+set}" = set; then
5642	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5643	>	else
5644	>	cat >conftest.$ac_ext <<_ACEOF
5645	>	/* confdefs.h.  */
5646	>	_ACEOF
5647	>	cat confdefs.h >>conftest.$ac_ext
5648	>	cat >>conftest.$ac_ext <<_ACEOF
5649	>	/* end confdefs.h.  */
5650	>	#include <stdlib.h>
5651	>	#include <stdarg.h>
5652	>	#include <string.h>
5653	>	#include <float.h>
5654	>
5655	>	#ifdef FC_DUMMY_MAIN
5656	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5657	>	#  ifdef __cplusplus
5658	>	extern "C"
5659	>	#  endif
5660	>	int FC_DUMMY_MAIN() { return 1; }
5661	>	#endif
5662	>	#endif
5663	>	int
5664	>	main ()
5665	>	{
5666	>
5667	>	;
5668	>	return 0;
5669	>	}
5670	>	_ACEOF
5671	>	rm -f conftest.$ac_objext
5672	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5673	>	(eval $ac_compile) 2>conftest.er1
5674	>	ac_status=$?
5675	>	grep -v '^ *+' conftest.er1 >conftest.err
5676	>	rm -f conftest.er1
5677	>	cat conftest.err >&5
5678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5679	>	(exit $ac_status); } &&
5680	>	{ ac_try='test -z "$ac_c_werror_flag"
5681	>	|| test ! -s conftest.err'
5682	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5683	>	(eval $ac_try) 2>&5
5684	>	ac_status=$?
5685	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5686	>	(exit $ac_status); }; } &&
5687	>	{ ac_try='test -s conftest.$ac_objext'
5688	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5689	>	(eval $ac_try) 2>&5
5690	>	ac_status=$?
5691	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5692	>	(exit $ac_status); }; }; then
5693	>	ac_cv_header_stdc=yes
5694	>	else
5695	>	echo "$as_me: failed program was:" >&5
5696	>	sed 's/^/| /' conftest.$ac_ext >&5
5697	>
5698	>	ac_cv_header_stdc=no
5699	>	fi
5700	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5701	>
5702	>	if test $ac_cv_header_stdc = yes; then
5703	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5704	>	cat >conftest.$ac_ext <<_ACEOF
5705	>	/* confdefs.h.  */
5706	>	_ACEOF
5707	>	cat confdefs.h >>conftest.$ac_ext
5708	>	cat >>conftest.$ac_ext <<_ACEOF
5709	>	/* end confdefs.h.  */
5710	>	#include <string.h>
5711	>
5712	>	_ACEOF
5713	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5714	>	$EGREP "memchr" >/dev/null 2>&1; then
5715	>	:
5716	>	else
5717	>	ac_cv_header_stdc=no
5718	>	fi
5719	>	rm -f conftest*
5720	>
5721	>	fi
5722	>
5723	>	if test $ac_cv_header_stdc = yes; then
5724	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5725	>	cat >conftest.$ac_ext <<_ACEOF
5726	>	/* confdefs.h.  */
5727	>	_ACEOF
5728	>	cat confdefs.h >>conftest.$ac_ext
5729	>	cat >>conftest.$ac_ext <<_ACEOF
5730	>	/* end confdefs.h.  */
5731	>	#include <stdlib.h>
5732	>
5733	>	_ACEOF
5734	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5735	>	$EGREP "free" >/dev/null 2>&1; then
5736	>	:
5737	>	else
5738	>	ac_cv_header_stdc=no
5739	>	fi
5740	>	rm -f conftest*
5741	>
5742	>	fi
5743	>
5744	>	if test $ac_cv_header_stdc = yes; then
5745	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5746	>	if test "$cross_compiling" = yes; then
5747	>	:
5748	>	else
5749	>	cat >conftest.$ac_ext <<_ACEOF
5750	>	/* confdefs.h.  */
5751	>	_ACEOF
5752	>	cat confdefs.h >>conftest.$ac_ext
5753	>	cat >>conftest.$ac_ext <<_ACEOF
5754	>	/* end confdefs.h.  */
5755	>	#include <ctype.h>
5756	>	#if ((' ' & 0x0FF) == 0x020)
5757	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5758	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5759	>	#else
5760	>	# define ISLOWER(c) \
5761	>	(('a' <= (c) && (c) <= 'i') \
5762	>	|| ('j' <= (c) && (c) <= 'r') \
5763	>	|| ('s' <= (c) && (c) <= 'z'))
5764	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5765	>	#endif
5766	>
5767	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5768	>	int
5769	>	main ()
5770	>	{
5771	>	int i;
5772	>	for (i = 0; i < 256; i++)
5773	>	if (XOR (islower (i), ISLOWER (i))
5774	>	|| toupper (i) != TOUPPER (i))
5775	>	exit(2);
5776	>	exit (0);
5777	>	}
5778	>	_ACEOF
5779	>	rm -f conftest$ac_exeext
5780	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5781	>	(eval $ac_link) 2>&5
5782	>	ac_status=$?
5783	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5784	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5785	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5786	>	(eval $ac_try) 2>&5
5787	>	ac_status=$?
5788	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5789	>	(exit $ac_status); }; }; then
5790	>	:
5791	>	else
5792	>	echo "$as_me: program exited with status $ac_status" >&5
5793	>	echo "$as_me: failed program was:" >&5
5794	>	sed 's/^/| /' conftest.$ac_ext >&5
5795	>
5796	>	( exit $ac_status )
5797	>	ac_cv_header_stdc=no
5798	>	fi
5799	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5800	>	fi
5801	>	fi
5802	>	fi
5803	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5804	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
5805	>	if test $ac_cv_header_stdc = yes; then
5806	>
5807	>	cat >>confdefs.h <<\_ACEOF
5808	>	#define STDC_HEADERS 1
5809	>	_ACEOF
5810	>
5811	>	fi
5812	>
5813	>	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
5814	>
5815	>
5816	>
5817	>
5818	>
5819	>
5820	>
5821	>
5822	>
5823	>	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5824	>	inttypes.h stdint.h unistd.h
5825	>	do
5826	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5827	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
5828	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5829	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5830	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5831	>	else
5832	>	cat >conftest.$ac_ext <<_ACEOF
5833	>	/* confdefs.h.  */
5834	>	_ACEOF
5835	>	cat confdefs.h >>conftest.$ac_ext
5836	>	cat >>conftest.$ac_ext <<_ACEOF
5837	>	/* end confdefs.h.  */
5838	>	$ac_includes_default
5839	>
5840	>	#include <$ac_header>
5841	>	_ACEOF
5842	>	rm -f conftest.$ac_objext
5843	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5844	>	(eval $ac_compile) 2>conftest.er1
5845	>	ac_status=$?
5846	>	grep -v '^ *+' conftest.er1 >conftest.err
5847	>	rm -f conftest.er1
5848	>	cat conftest.err >&5
5849	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850	>	(exit $ac_status); } &&
5851	>	{ ac_try='test -z "$ac_c_werror_flag"
5852	>	|| test ! -s conftest.err'
5853	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5854	>	(eval $ac_try) 2>&5
5855	>	ac_status=$?
5856	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5857	>	(exit $ac_status); }; } &&
5858	>	{ ac_try='test -s conftest.$ac_objext'
5859	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5860	>	(eval $ac_try) 2>&5
5861	>	ac_status=$?
5862	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5863	>	(exit $ac_status); }; }; then
5864	>	eval "$as_ac_Header=yes"
5865	>	else
5866	>	echo "$as_me: failed program was:" >&5
5867	>	sed 's/^/| /' conftest.$ac_ext >&5
5868	>
5869	>	eval "$as_ac_Header=no"
5870	>	fi
5871	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5872	>	fi
5873	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5874	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5875	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5876	>	cat >>confdefs.h <<_ACEOF
5877	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5878	>	_ACEOF
5879	>
5880	>	fi
5881	>
5882	>	done
5883	>
5884	>
5885	>	#
5886	>	# Handle user hints
5887	>	#
5888	>
5889	>	# Check whether --with-zlib or --without-zlib was given.
5890	>	if test "${with_zlib+set}" = set; then
5891	>	withval="$with_zlib"
5892	>	zlib_dir="$withval"
5893	>	else
5894	>	zlib_dir="not_set"
5895	>	fi;
5896	>	if test "$zlib_dir" != "no"; then
5897	>
5898	>	if test "$zlib_dir" != "not_set" ; then
5899	>	if test -d "$zlib_dir"
5900	>	then
5901	>	ZLIB_HOME="$zlib_dir"
5902	>	else
5903	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5904	>	echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5905	>	fi
5906	>	fi
5907	>
5908	>	ZLIB_HOME=/usr/local
5909	>	if test ! -f "${ZLIB_HOME}/include/zlib.h"
5910	>	then
5911	>	ZLIB_HOME=/usr
5912	>	fi
5913	>
5914	>	#
5915	>	# Locate zlib, if wanted
5916	>	#
5917	>	if test -n "${ZLIB_HOME}"
5918	>	then
5919	>	ZLIB_OLD_LDFLAGS=$LDFLAGS
5920	>	ZLIB_OLD_CPPFLAGS=$LDFLAGS
5921	>	LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5922	>	CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5923	>
5924	>
5925	>	ac_ext=c
5926	>	ac_cpp='$CPP $CPPFLAGS'
5927	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5928	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5929	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5930	>
5931	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5932	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5933	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5934	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5935	>	else
5936	>	ac_check_lib_save_LIBS=$LIBS
5937	>	LIBS="-lz  $LIBS"
5938	>	cat >conftest.$ac_ext <<_ACEOF
5939	>	/* confdefs.h.  */
5940	>	_ACEOF
5941	>	cat confdefs.h >>conftest.$ac_ext
5942	>	cat >>conftest.$ac_ext <<_ACEOF
5943	>	/* end confdefs.h.  */
5944	>
5945	>	/* Override any gcc2 internal prototype to avoid an error.  */
5946	>	#ifdef __cplusplus
5947	>	extern "C"
5948	>	#endif
5949	>	/* We use char because int might match the return type of a gcc2
5950	>	builtin and then its argument prototype would still apply.  */
5951	>	char inflateEnd ();
5952	>	#ifdef FC_DUMMY_MAIN
5953	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5954	>	#  ifdef __cplusplus
5955	>	extern "C"
5956	>	#  endif
5957	>	int FC_DUMMY_MAIN() { return 1; }
5958	>	#endif
5959	>	#endif
5960	>	int
5961	>	main ()
5962	>	{
5963	>	inflateEnd ();
5964	>	;
5965	>	return 0;
5966	>	}
5967	>	_ACEOF
5968	>	rm -f conftest.$ac_objext conftest$ac_exeext
5969	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5970	>	(eval $ac_link) 2>conftest.er1
5971	>	ac_status=$?
5972	>	grep -v '^ *+' conftest.er1 >conftest.err
5973	>	rm -f conftest.er1
5974	>	cat conftest.err >&5
5975	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5976	>	(exit $ac_status); } &&
5977	>	{ ac_try='test -z "$ac_c_werror_flag"
5978	>	|| test ! -s conftest.err'
5979	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5980	>	(eval $ac_try) 2>&5
5981	>	ac_status=$?
5982	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5983	>	(exit $ac_status); }; } &&
5984	>	{ ac_try='test -s conftest$ac_exeext'
5985	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5986	>	(eval $ac_try) 2>&5
5987	>	ac_status=$?
5988	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5989	>	(exit $ac_status); }; }; then
5990	>	ac_cv_lib_z_inflateEnd=yes
5991	>	else
5992	>	echo "$as_me: failed program was:" >&5
5993	>	sed 's/^/| /' conftest.$ac_ext >&5
5994	>
5995	>	ac_cv_lib_z_inflateEnd=no
5996	>	fi
5997	>	rm -f conftest.err conftest.$ac_objext \
5998	>	conftest$ac_exeext conftest.$ac_ext
5999	>	LIBS=$ac_check_lib_save_LIBS
6000	>	fi
6001	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6002	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6003	>	if test $ac_cv_lib_z_inflateEnd = yes; then
6004	>	zlib_cv_libz=yes
6005	>	else
6006	>	zlib_cv_libz=no
6007	>	fi
6008	>
6009	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6010	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6011	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6012	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6013	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6014	>	fi
6015	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6016	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6017	>	else
6018	>	# Is the header compilable?
6019	>	echo "$as_me:$LINENO: checking zlib.h usability" >&5
6020	>	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
6021	>	cat >conftest.$ac_ext <<_ACEOF
6022	>	/* confdefs.h.  */
6023	>	_ACEOF
6024	>	cat confdefs.h >>conftest.$ac_ext
6025	>	cat >>conftest.$ac_ext <<_ACEOF
6026	>	/* end confdefs.h.  */
6027	>	$ac_includes_default
6028	>	#include <zlib.h>
6029	>	_ACEOF
6030	>	rm -f conftest.$ac_objext
6031	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6032	>	(eval $ac_compile) 2>conftest.er1
6033	>	ac_status=$?
6034	>	grep -v '^ *+' conftest.er1 >conftest.err
6035	>	rm -f conftest.er1
6036	>	cat conftest.err >&5
6037	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6038	>	(exit $ac_status); } &&
6039	>	{ ac_try='test -z "$ac_c_werror_flag"
6040	>	|| test ! -s conftest.err'
6041	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6042	>	(eval $ac_try) 2>&5
6043	>	ac_status=$?
6044	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6045	>	(exit $ac_status); }; } &&
6046	>	{ ac_try='test -s conftest.$ac_objext'
6047	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6048	>	(eval $ac_try) 2>&5
6049	>	ac_status=$?
6050	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6051	>	(exit $ac_status); }; }; then
6052	>	ac_header_compiler=yes
6053	>	else
6054	>	echo "$as_me: failed program was:" >&5
6055	>	sed 's/^/| /' conftest.$ac_ext >&5
6056	>
6057	>	ac_header_compiler=no
6058	>	fi
6059	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6060	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6061	>	echo "${ECHO_T}$ac_header_compiler" >&6
6062	>
6063	>	# Is the header present?
6064	>	echo "$as_me:$LINENO: checking zlib.h presence" >&5
6065	>	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6066	>	cat >conftest.$ac_ext <<_ACEOF
6067	>	/* confdefs.h.  */
6068	>	_ACEOF
6069	>	cat confdefs.h >>conftest.$ac_ext
6070	>	cat >>conftest.$ac_ext <<_ACEOF
6071	>	/* end confdefs.h.  */
6072	>	#include <zlib.h>
6073	>	_ACEOF
6074	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6075	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6076	>	ac_status=$?
6077	>	grep -v '^ *+' conftest.er1 >conftest.err
6078	>	rm -f conftest.er1
6079	>	cat conftest.err >&5
6080	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6081	>	(exit $ac_status); } >/dev/null; then
6082	>	if test -s conftest.err; then
6083	>	ac_cpp_err=$ac_c_preproc_warn_flag
6084	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6085	>	else
6086	>	ac_cpp_err=
6087	>	fi
6088	>	else
6089	>	ac_cpp_err=yes
6090	>	fi
6091	>	if test -z "$ac_cpp_err"; then
6092	>	ac_header_preproc=yes
6093	>	else
6094	>	echo "$as_me: failed program was:" >&5
6095	>	sed 's/^/| /' conftest.$ac_ext >&5
6096	>
6097	>	ac_header_preproc=no
6098	>	fi
6099	>	rm -f conftest.err conftest.$ac_ext
6100	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6101	>	echo "${ECHO_T}$ac_header_preproc" >&6
6102	>
6103	>	# So?  What about this header?
6104	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6105	>	yes:no: )
6106	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6107	>	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6108	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6109	>	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6110	>	ac_header_preproc=yes
6111	>	;;
6112	>	no:yes:* )
6113	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6114	>	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6115	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6116	>	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6117	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6118	>	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6119	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6120	>	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6121	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6122	>	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6123	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6124	>	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6125	>	(
6126	>	cat <<\_ASBOX
6127	>	## ------------------------------ ##
6128	>	## Report this to gezelter@nd.edu ##
6129	>	## ------------------------------ ##
6130	>	_ASBOX
6131	>	) |
6132	>	sed "s/^/$as_me: WARNING:     /" >&2
6133	>	;;
6134	>	esac
6135	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6136	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6137	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6138	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6139	>	else
6140	>	ac_cv_header_zlib_h=$ac_header_preproc
6141	>	fi
6142	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6143	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6144	>
6145	>	fi
6146	>	if test $ac_cv_header_zlib_h = yes; then
6147	>	zlib_cv_zlib_h=yes
6148	>	else
6149	>	zlib_cv_zlib_h=no
6150	>	fi
6151	>
6152	>
6153	>	ac_ext=c
6154	>	ac_cpp='$CPP $CPPFLAGS'
6155	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6156	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6157	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6158	>
6159	>
6160	>	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6161	>
6162	>	cat >>confdefs.h <<\_ACEOF
6163	>	#define HAVE_ZLIB_H 1
6164	>	_ACEOF
6165	>
6166	>
6167	>	cat >>confdefs.h <<\_ACEOF
6168	>	#define HAVE_LIBZ 1
6169	>	_ACEOF
6170	>
6171	>	ZLIB_INC_DIR="${ZLIB_HOME}/include"
6172	>	ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6173	>	ZLIB="-lz"
6174	>	else
6175	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6176	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6177	>	ZLIB_INC_DIR=
6178	>	ZLIB_LIB_DIR=
6179	>	ZLIB=
6180	>	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6181	>	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6182	>	echo "$as_me:$LINENO: result: failed" >&5
6183	>	echo "${ECHO_T}failed" >&6
6184	>	echo ""
6185	>	echo "*********************************************************"
6186	>	echo "* WARNING: Could not find a working zlib installation   *"
6187	>	echo "* If you need OOPSE to be able to deal with compressed  *"
6188	>	echo "* trajectory dump files be sure to specify a valid zlib *"
6189	>	echo "* installation with --with-zlib=DIR                     *"
6190	>	echo "*                                                       *"
6191	>	echo "* OOPSE will still work without zlib installed.         *"
6192	>	echo "*********************************************************"
6193	>	echo ""
6194	>	fi
6195	>
6196	>
6197	>
6198	>	fi
6199	>	fi
6200	>
6201	>	#
6202	>	# Handle user hints
6203	>	#
6204	>
6205	>	# Check whether --with-fftw or --without-fftw was given.
6206	>	if test "${with_fftw+set}" = set; then
6207	>	withval="$with_fftw"
6208	>	fftw_dir="$withval"
6209	>	else
6210	>	fftw_dir="not_set"
6211	>	fi;
6212	>	if test "$fftw_dir" != "no"; then
6213	>	if test "$fftw_dir" != "not_set" ; then
6214	>	if test -d "$fftw_dir"; then
6215	>	FFTW_HOME="$fftw_dir"
6216	>	else
6217	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6218	>	echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6219	>	FFTW_HOME=/usr/local
6220	>	if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6221	>	FFTW_HOME=/usr
6222	>	fi
6223	>	fi
6224	>	#
6225	>	# Locate fftw, if wanted
6226	>	#
6227	>	if test -n "${FFTW_HOME}"; then
6228	>	FFTW_OLD_LDFLAGS=$LDFLAGS
6229	>	FFTW_OLD_CPPFLAGS=$LDFLAGS
6230	>	LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6231	>	CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6232	>
6233	>
6234	>	ac_ext=c
6235	>	ac_cpp='$CPP $CPPFLAGS'
6236	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6237	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6238	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6239	>
6240	>	echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6241	>	echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6242	>	if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6243	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6244	>	else
6245	>	ac_check_lib_save_LIBS=$LIBS
6246	>	LIBS="-lfftw3  $LIBS"
6247	>	cat >conftest.$ac_ext <<_ACEOF
6248	>	/* confdefs.h.  */
6249	>	_ACEOF
6250	>	cat confdefs.h >>conftest.$ac_ext
6251	>	cat >>conftest.$ac_ext <<_ACEOF
6252	>	/* end confdefs.h.  */
6253	>
6254	>	/* Override any gcc2 internal prototype to avoid an error.  */
6255	>	#ifdef __cplusplus
6256	>	extern "C"
6257	>	#endif
6258	>	/* We use char because int might match the return type of a gcc2
6259	>	builtin and then its argument prototype would still apply.  */
6260	>	char fftw_execute ();
6261	>	#ifdef FC_DUMMY_MAIN
6262	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6263	>	#  ifdef __cplusplus
6264	>	extern "C"
6265	>	#  endif
6266	>	int FC_DUMMY_MAIN() { return 1; }
6267	>	#endif
6268	>	#endif
6269	>	int
6270	>	main ()
6271	>	{
6272	>	fftw_execute ();
6273	>	;
6274	>	return 0;
6275	>	}
6276	>	_ACEOF
6277	>	rm -f conftest.$ac_objext conftest$ac_exeext
6278	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6279	>	(eval $ac_link) 2>conftest.er1
6280	>	ac_status=$?
6281	>	grep -v '^ *+' conftest.er1 >conftest.err
6282	>	rm -f conftest.er1
6283	>	cat conftest.err >&5
6284	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6285	>	(exit $ac_status); } &&
6286	>	{ ac_try='test -z "$ac_c_werror_flag"
6287	>	|| test ! -s conftest.err'
6288	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6289	>	(eval $ac_try) 2>&5
6290	>	ac_status=$?
6291	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6292	>	(exit $ac_status); }; } &&
6293	>	{ ac_try='test -s conftest$ac_exeext'
6294	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6295	>	(eval $ac_try) 2>&5
6296	>	ac_status=$?
6297	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6298	>	(exit $ac_status); }; }; then
6299	>	ac_cv_lib_fftw3_fftw_execute=yes
6300	>	else
6301	>	echo "$as_me: failed program was:" >&5
6302	>	sed 's/^/| /' conftest.$ac_ext >&5
6303	>
6304	>	ac_cv_lib_fftw3_fftw_execute=no
6305	>	fi
6306	>	rm -f conftest.err conftest.$ac_objext \
6307	>	conftest$ac_exeext conftest.$ac_ext
6308	>	LIBS=$ac_check_lib_save_LIBS
6309	>	fi
6310	>	echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6311	>	echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6312	>	if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6313	>	fftw_cv_libfftw3=yes
6314	>	else
6315	>	fftw_cv_libfftw3=no
6316	>	fi
6317	>
6318	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6319	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6320	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6321	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6322	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6323	>	fi
6324	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6325	>	echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6326	>	else
6327	>	# Is the header compilable?
6328	>	echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6329	>	echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6330	>	cat >conftest.$ac_ext <<_ACEOF
6331	>	/* confdefs.h.  */
6332	>	_ACEOF
6333	>	cat confdefs.h >>conftest.$ac_ext
6334	>	cat >>conftest.$ac_ext <<_ACEOF
6335	>	/* end confdefs.h.  */
6336	>	$ac_includes_default
6337	>	#include <fftw3.h>
6338	>	_ACEOF
6339	>	rm -f conftest.$ac_objext
6340	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6341	>	(eval $ac_compile) 2>conftest.er1
6342	>	ac_status=$?
6343	>	grep -v '^ *+' conftest.er1 >conftest.err
6344	>	rm -f conftest.er1
6345	>	cat conftest.err >&5
6346	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6347	>	(exit $ac_status); } &&
6348	>	{ ac_try='test -z "$ac_c_werror_flag"
6349	>	|| test ! -s conftest.err'
6350	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6351	>	(eval $ac_try) 2>&5
6352	>	ac_status=$?
6353	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6354	>	(exit $ac_status); }; } &&
6355	>	{ ac_try='test -s conftest.$ac_objext'
6356	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6357	>	(eval $ac_try) 2>&5
6358	>	ac_status=$?
6359	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6360	>	(exit $ac_status); }; }; then
6361	>	ac_header_compiler=yes
6362	>	else
6363	>	echo "$as_me: failed program was:" >&5
6364	>	sed 's/^/| /' conftest.$ac_ext >&5
6365	>
6366	>	ac_header_compiler=no
6367	>	fi
6368	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6369	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6370	>	echo "${ECHO_T}$ac_header_compiler" >&6
6371	>
6372	>	# Is the header present?
6373	>	echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6374	>	echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6375	>	cat >conftest.$ac_ext <<_ACEOF
6376	>	/* confdefs.h.  */
6377	>	_ACEOF
6378	>	cat confdefs.h >>conftest.$ac_ext
6379	>	cat >>conftest.$ac_ext <<_ACEOF
6380	>	/* end confdefs.h.  */
6381	>	#include <fftw3.h>
6382	>	_ACEOF
6383	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6384	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6385	>	ac_status=$?
6386	>	grep -v '^ *+' conftest.er1 >conftest.err
6387	>	rm -f conftest.er1
6388	>	cat conftest.err >&5
6389	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6390	>	(exit $ac_status); } >/dev/null; then
6391	>	if test -s conftest.err; then
6392	>	ac_cpp_err=$ac_c_preproc_warn_flag
6393	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6394	>	else
6395	>	ac_cpp_err=
6396	>	fi
6397	>	else
6398	>	ac_cpp_err=yes
6399	>	fi
6400	>	if test -z "$ac_cpp_err"; then
6401	>	ac_header_preproc=yes
6402	>	else
6403	>	echo "$as_me: failed program was:" >&5
6404	>	sed 's/^/| /' conftest.$ac_ext >&5
6405	>
6406	>	ac_header_preproc=no
6407	>	fi
6408	>	rm -f conftest.err conftest.$ac_ext
6409	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6410	>	echo "${ECHO_T}$ac_header_preproc" >&6
6411	>
6412	>	# So?  What about this header?
6413	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6414	>	yes:no: )
6415	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6416	>	echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6417	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6418	>	echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6419	>	ac_header_preproc=yes
6420	>	;;
6421	>	no:yes:* )
6422	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6423	>	echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6424	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6425	>	echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6426	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6427	>	echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6428	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6429	>	echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6430	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6431	>	echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6432	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6433	>	echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6434	>	(
6435	>	cat <<\_ASBOX
6436	>	## ------------------------------ ##
6437	>	## Report this to gezelter@nd.edu ##
6438	>	## ------------------------------ ##
6439	>	_ASBOX
6440	>	) |
6441	>	sed "s/^/$as_me: WARNING:     /" >&2
6442	>	;;
6443	>	esac
6444	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6445	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6446	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6447	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6448	>	else
6449	>	ac_cv_header_fftw3_h=$ac_header_preproc
6450	>	fi
6451	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6452	>	echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6453	>
6454	>	fi
6455	>	if test $ac_cv_header_fftw3_h = yes; then
6456	>	fftw_cv_fftw3_h=yes
6457	>	else
6458	>	fftw_cv_fftw3_h=no
6459	>	fi
6460	>
6461	>
6462	>	if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6463	>	echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6464	>	echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6465	>	if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6466	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6467	>	else
6468	>	ac_check_lib_save_LIBS=$LIBS
6469	>	LIBS="-lfftw  $LIBS"
6470	>	cat >conftest.$ac_ext <<_ACEOF
6471	>	/* confdefs.h.  */
6472	>	_ACEOF
6473	>	cat confdefs.h >>conftest.$ac_ext
6474	>	cat >>conftest.$ac_ext <<_ACEOF
6475	>	/* end confdefs.h.  */
6476	>
6477	>	/* Override any gcc2 internal prototype to avoid an error.  */
6478	>	#ifdef __cplusplus
6479	>	extern "C"
6480	>	#endif
6481	>	/* We use char because int might match the return type of a gcc2
6482	>	builtin and then its argument prototype would still apply.  */
6483	>	char fftwnd_one ();
6484	>	#ifdef FC_DUMMY_MAIN
6485	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6486	>	#  ifdef __cplusplus
6487	>	extern "C"
6488	>	#  endif
6489	>	int FC_DUMMY_MAIN() { return 1; }
6490	>	#endif
6491	>	#endif
6492	>	int
6493	>	main ()
6494	>	{
6495	>	fftwnd_one ();
6496	>	;
6497	>	return 0;
6498	>	}
6499	>	_ACEOF
6500	>	rm -f conftest.$ac_objext conftest$ac_exeext
6501	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6502	>	(eval $ac_link) 2>conftest.er1
6503	>	ac_status=$?
6504	>	grep -v '^ *+' conftest.er1 >conftest.err
6505	>	rm -f conftest.er1
6506	>	cat conftest.err >&5
6507	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508	>	(exit $ac_status); } &&
6509	>	{ ac_try='test -z "$ac_c_werror_flag"
6510	>	|| test ! -s conftest.err'
6511	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6512	>	(eval $ac_try) 2>&5
6513	>	ac_status=$?
6514	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6515	>	(exit $ac_status); }; } &&
6516	>	{ ac_try='test -s conftest$ac_exeext'
6517	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6518	>	(eval $ac_try) 2>&5
6519	>	ac_status=$?
6520	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6521	>	(exit $ac_status); }; }; then
6522	>	ac_cv_lib_fftw_fftwnd_one=yes
6523	>	else
6524	>	echo "$as_me: failed program was:" >&5
6525	>	sed 's/^/| /' conftest.$ac_ext >&5
6526	>
6527	>	ac_cv_lib_fftw_fftwnd_one=no
6528	>	fi
6529	>	rm -f conftest.err conftest.$ac_objext \
6530	>	conftest$ac_exeext conftest.$ac_ext
6531	>	LIBS=$ac_check_lib_save_LIBS
6532	>	fi
6533	>	echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6534	>	echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6535	>	if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6536	>	fftw_cv_libfftw=yes
6537	>	else
6538	>	fftw_cv_libfftw=no
6539	>	fi
6540	>
6541	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6542	>	echo "$as_me:$LINENO: checking for fftw.h" >&5
6543	>	echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6544	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6545	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6546	>	fi
6547	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6548	>	echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6549	>	else
6550	>	# Is the header compilable?
6551	>	echo "$as_me:$LINENO: checking fftw.h usability" >&5
6552	>	echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6553	>	cat >conftest.$ac_ext <<_ACEOF
6554	>	/* confdefs.h.  */
6555	>	_ACEOF
6556	>	cat confdefs.h >>conftest.$ac_ext
6557	>	cat >>conftest.$ac_ext <<_ACEOF
6558	>	/* end confdefs.h.  */
6559	>	$ac_includes_default
6560	>	#include <fftw.h>
6561	>	_ACEOF
6562	>	rm -f conftest.$ac_objext
6563	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6564	>	(eval $ac_compile) 2>conftest.er1
6565	>	ac_status=$?
6566	>	grep -v '^ *+' conftest.er1 >conftest.err
6567	>	rm -f conftest.er1
6568	>	cat conftest.err >&5
6569	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570	>	(exit $ac_status); } &&
6571	>	{ ac_try='test -z "$ac_c_werror_flag"
6572	>	|| test ! -s conftest.err'
6573	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6574	>	(eval $ac_try) 2>&5
6575	>	ac_status=$?
6576	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6577	>	(exit $ac_status); }; } &&
6578	>	{ ac_try='test -s conftest.$ac_objext'
6579	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6580	>	(eval $ac_try) 2>&5
6581	>	ac_status=$?
6582	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6583	>	(exit $ac_status); }; }; then
6584	>	ac_header_compiler=yes
6585	>	else
6586	>	echo "$as_me: failed program was:" >&5
6587	>	sed 's/^/| /' conftest.$ac_ext >&5
6588	>
6589	>	ac_header_compiler=no
6590	>	fi
6591	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6592	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6593	>	echo "${ECHO_T}$ac_header_compiler" >&6
6594	>
6595	>	# Is the header present?
6596	>	echo "$as_me:$LINENO: checking fftw.h presence" >&5
6597	>	echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6598	>	cat >conftest.$ac_ext <<_ACEOF
6599	>	/* confdefs.h.  */
6600	>	_ACEOF
6601	>	cat confdefs.h >>conftest.$ac_ext
6602	>	cat >>conftest.$ac_ext <<_ACEOF
6603	>	/* end confdefs.h.  */
6604	>	#include <fftw.h>
6605	>	_ACEOF
6606	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6607	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6608	>	ac_status=$?
6609	>	grep -v '^ *+' conftest.er1 >conftest.err
6610	>	rm -f conftest.er1
6611	>	cat conftest.err >&5
6612	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6613	>	(exit $ac_status); } >/dev/null; then
6614	>	if test -s conftest.err; then
6615	>	ac_cpp_err=$ac_c_preproc_warn_flag
6616	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6617	>	else
6618	>	ac_cpp_err=
6619	>	fi
6620	>	else
6621	>	ac_cpp_err=yes
6622	>	fi
6623	>	if test -z "$ac_cpp_err"; then
6624	>	ac_header_preproc=yes
6625	>	else
6626	>	echo "$as_me: failed program was:" >&5
6627	>	sed 's/^/| /' conftest.$ac_ext >&5
6628	>
6629	>	ac_header_preproc=no
6630	>	fi
6631	>	rm -f conftest.err conftest.$ac_ext
6632	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6633	>	echo "${ECHO_T}$ac_header_preproc" >&6
6634	>
6635	>	# So?  What about this header?
6636	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6637	>	yes:no: )
6638	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6639	>	echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6641	>	echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6642	>	ac_header_preproc=yes
6643	>	;;
6644	>	no:yes:* )
6645	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6646	>	echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6647	>	{ echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6648	>	echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6649	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6650	>	echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6651	>	{ echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6652	>	echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6653	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6654	>	echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6655	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6656	>	echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6657	>	(
6658	>	cat <<\_ASBOX
6659	>	## ------------------------------ ##
6660	>	## Report this to gezelter@nd.edu ##
6661	>	## ------------------------------ ##
6662	>	_ASBOX
6663	>	) |
6664	>	sed "s/^/$as_me: WARNING:     /" >&2
6665	>	;;
6666	>	esac
6667	>	echo "$as_me:$LINENO: checking for fftw.h" >&5
6668	>	echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6669	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6670	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6671	>	else
6672	>	ac_cv_header_fftw_h=$ac_header_preproc
6673	>	fi
6674	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6675	>	echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6676	>
6677	>	fi
6678	>	if test $ac_cv_header_fftw_h = yes; then
6679	>	fftw_cv_fftw_h=yes
6680	>	else
6681	>	fftw_cv_fftw_h=no
6682	>	fi
6683	>
6684	>
6685	>	if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6686	>	echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6687	>	echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6688	>	if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6689	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6690	>	else
6691	>	ac_check_lib_save_LIBS=$LIBS
6692	>	LIBS="-ldfftw  $LIBS"
6693	>	cat >conftest.$ac_ext <<_ACEOF
6694	>	/* confdefs.h.  */
6695	>	_ACEOF
6696	>	cat confdefs.h >>conftest.$ac_ext
6697	>	cat >>conftest.$ac_ext <<_ACEOF
6698	>	/* end confdefs.h.  */
6699	>
6700	>	/* Override any gcc2 internal prototype to avoid an error.  */
6701	>	#ifdef __cplusplus
6702	>	extern "C"
6703	>	#endif
6704	>	/* We use char because int might match the return type of a gcc2
6705	>	builtin and then its argument prototype would still apply.  */
6706	>	char fftwnd_one ();
6707	>	#ifdef FC_DUMMY_MAIN
6708	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6709	>	#  ifdef __cplusplus
6710	>	extern "C"
6711	>	#  endif
6712	>	int FC_DUMMY_MAIN() { return 1; }
6713	>	#endif
6714	>	#endif
6715	>	int
6716	>	main ()
6717	>	{
6718	>	fftwnd_one ();
6719	>	;
6720	>	return 0;
6721	>	}
6722	>	_ACEOF
6723	>	rm -f conftest.$ac_objext conftest$ac_exeext
6724	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6725	>	(eval $ac_link) 2>conftest.er1
6726	>	ac_status=$?
6727	>	grep -v '^ *+' conftest.er1 >conftest.err
6728	>	rm -f conftest.er1
6729	>	cat conftest.err >&5
6730	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6731	>	(exit $ac_status); } &&
6732	>	{ ac_try='test -z "$ac_c_werror_flag"
6733	>	|| test ! -s conftest.err'
6734	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6735	>	(eval $ac_try) 2>&5
6736	>	ac_status=$?
6737	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738	>	(exit $ac_status); }; } &&
6739	>	{ ac_try='test -s conftest$ac_exeext'
6740	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6741	>	(eval $ac_try) 2>&5
6742	>	ac_status=$?
6743	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6744	>	(exit $ac_status); }; }; then
6745	>	ac_cv_lib_dfftw_fftwnd_one=yes
6746	>	else
6747	>	echo "$as_me: failed program was:" >&5
6748	>	sed 's/^/| /' conftest.$ac_ext >&5
6749	>
6750	>	ac_cv_lib_dfftw_fftwnd_one=no
6751	>	fi
6752	>	rm -f conftest.err conftest.$ac_objext \
6753	>	conftest$ac_exeext conftest.$ac_ext
6754	>	LIBS=$ac_check_lib_save_LIBS
6755	>	fi
6756	>	echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6757	>	echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6758	>	if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6759	>	fftw_cv_libdfftw=yes
6760	>	else
6761	>	fftw_cv_libdfftw=no
6762	>	fi
6763	>
6764	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6765	>	echo "$as_me:$LINENO: checking for dfftw.h" >&5
6766	>	echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6767	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6768	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6769	>	fi
6770	>	echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6771	>	echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6772	>	else
6773	>	# Is the header compilable?
6774	>	echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6775	>	echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6776	>	cat >conftest.$ac_ext <<_ACEOF
6777	>	/* confdefs.h.  */
6778	>	_ACEOF
6779	>	cat confdefs.h >>conftest.$ac_ext
6780	>	cat >>conftest.$ac_ext <<_ACEOF
6781	>	/* end confdefs.h.  */
6782	>	$ac_includes_default
6783	>	#include <dfftw.h>
6784	>	_ACEOF
6785	>	rm -f conftest.$ac_objext
6786	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6787	>	(eval $ac_compile) 2>conftest.er1
6788	>	ac_status=$?
6789	>	grep -v '^ *+' conftest.er1 >conftest.err
6790	>	rm -f conftest.er1
6791	>	cat conftest.err >&5
6792	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6793	>	(exit $ac_status); } &&
6794	>	{ ac_try='test -z "$ac_c_werror_flag"
6795	>	|| test ! -s conftest.err'
6796	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797	>	(eval $ac_try) 2>&5
6798	>	ac_status=$?
6799	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800	>	(exit $ac_status); }; } &&
6801	>	{ ac_try='test -s conftest.$ac_objext'
6802	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6803	>	(eval $ac_try) 2>&5
6804	>	ac_status=$?
6805	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6806	>	(exit $ac_status); }; }; then
6807	>	ac_header_compiler=yes
6808	>	else
6809	>	echo "$as_me: failed program was:" >&5
6810	>	sed 's/^/| /' conftest.$ac_ext >&5
6811	>
6812	>	ac_header_compiler=no
6813	>	fi
6814	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6815	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6816	>	echo "${ECHO_T}$ac_header_compiler" >&6
6817	>
6818	>	# Is the header present?
6819	>	echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6820	>	echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6821	>	cat >conftest.$ac_ext <<_ACEOF
6822	>	/* confdefs.h.  */
6823	>	_ACEOF
6824	>	cat confdefs.h >>conftest.$ac_ext
6825	>	cat >>conftest.$ac_ext <<_ACEOF
6826	>	/* end confdefs.h.  */
6827	>	#include <dfftw.h>
6828	>	_ACEOF
6829	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6830	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6831	>	ac_status=$?
6832	>	grep -v '^ *+' conftest.er1 >conftest.err
6833	>	rm -f conftest.er1
6834	>	cat conftest.err >&5
6835	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6836	>	(exit $ac_status); } >/dev/null; then
6837	>	if test -s conftest.err; then
6838	>	ac_cpp_err=$ac_c_preproc_warn_flag
6839	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6840	>	else
6841	>	ac_cpp_err=
6842	>	fi
6843	>	else
6844	>	ac_cpp_err=yes
6845	>	fi
6846	>	if test -z "$ac_cpp_err"; then
6847	>	ac_header_preproc=yes
6848	>	else
6849	>	echo "$as_me: failed program was:" >&5
6850	>	sed 's/^/| /' conftest.$ac_ext >&5
6851	>
6852	>	ac_header_preproc=no
6853	>	fi
6854	>	rm -f conftest.err conftest.$ac_ext
6855	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6856	>	echo "${ECHO_T}$ac_header_preproc" >&6
6857	>
6858	>	# So?  What about this header?
6859	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6860	>	yes:no: )
6861	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6862	>	echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6863	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6864	>	echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6865	>	ac_header_preproc=yes
6866	>	;;
6867	>	no:yes:* )
6868	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6869	>	echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6870	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6871	>	echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6872	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6873	>	echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6874	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6875	>	echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6876	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6877	>	echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6878	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6879	>	echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6880	>	(
6881	>	cat <<\_ASBOX
6882	>	## ------------------------------ ##
6883	>	## Report this to gezelter@nd.edu ##
6884	>	## ------------------------------ ##
6885	>	_ASBOX
6886	>	) |
6887	>	sed "s/^/$as_me: WARNING:     /" >&2
6888	>	;;
6889	>	esac
6890	>	echo "$as_me:$LINENO: checking for dfftw.h" >&5
6891	>	echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6892	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6893	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6894	>	else
6895	>	ac_cv_header_dfftw_h=$ac_header_preproc
6896	>	fi
6897	>	echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6898	>	echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6899	>
6900	>	fi
6901	>	if test $ac_cv_header_dfftw_h = yes; then
6902	>	fftw_cv_dfftw_h=yes
6903	>	else
6904	>	fftw_cv_dfftw_h=no
6905	>	fi
6906	>
6907	>
6908	>	fi
6909	>	fi
6910	>	ac_ext=c
6911	>	ac_cpp='$CPP $CPPFLAGS'
6912	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6913	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6914	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6915	>
6916	>	if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6917	>
6918	>	cat >>confdefs.h <<\_ACEOF
6919	>	#define HAVE_FFTW3_H 1
6920	>	_ACEOF
6921	>
6922	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6923	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6924	>	FFTW_LIBS="-lfftw3"
6925	>	else
6926	>	if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6927	>
6928	>	cat >>confdefs.h <<\_ACEOF
6929	>	#define HAVE_FFTW_H 1
6930	>	_ACEOF
6931	>
6932	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6933	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6934	>	FFTW_LIBS="-lfftw"
6935	>	else
6936	>	if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6937	>
6938	>	cat >>confdefs.h <<\_ACEOF
6939	>	#define HAVE_DFFTW_H 1
6940	>	_ACEOF
6941	>
6942	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6943	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6944	>	FFTW_LIBS="-ldfftw"
6945	>	else
6946	>	echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6947	>	echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6948	>	FFTW_INC_DIR=
6949	>	FFTW_LIB_DIR=
6950	>	FFTW_LIBS=
6951	>	LDFLAGS="$FFTW_OLD_LDFLAGS"
6952	>	CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6953	>	echo "$as_me:$LINENO: result: failed" >&5
6954	>	echo "${ECHO_T}failed" >&6
6955	>	echo ""
6956	>	echo "*********************************************************"
6957	>	echo "* WARNING: Could not find a working FFTW installation   *"
6958	>	echo "* If you need the staticProps program to be able to     *"
6959	>	echo "* compute undulation spectra, be sure to specify a      *"
6960	>	echo "* valid fftw installation with --with-fftw=DIR          *"
6961	>	echo "*                                                       *"
6962	>	echo "* OOPSE will still work without fftw installed.         *"
6963	>	echo "*********************************************************"
6964	>	echo ""
6965	>	fi
6966	>	fi
6967	>	fi
6968	>
6969	>
6970	>
6971	>	fi
6972	>	fi
6973	>	fi
6974	>
6975	>
6976	>
6977	>	# Checks for header files.
6978	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6979	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6980	>	if test "${ac_cv_header_stdc+set}" = set; then
6981	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6982	>	else
6983	>	cat >conftest.$ac_ext <<_ACEOF
6984	>	/* confdefs.h.  */
6985	>	_ACEOF
6986	>	cat confdefs.h >>conftest.$ac_ext
6987	>	cat >>conftest.$ac_ext <<_ACEOF
6988	>	/* end confdefs.h.  */
6989	>	#include <stdlib.h>
6990	>	#include <stdarg.h>
6991	>	#include <string.h>
6992	>	#include <float.h>
6993	>
6994	>	#ifdef FC_DUMMY_MAIN
6995	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6996	>	#  ifdef __cplusplus
6997	>	extern "C"
6998	>	#  endif
6999	>	int FC_DUMMY_MAIN() { return 1; }
7000	>	#endif
7001	>	#endif
7002	>	int
7003	>	main ()
7004	>	{
7005	>
7006	>	;
7007	>	return 0;
7008	>	}
7009	>	_ACEOF
7010	>	rm -f conftest.$ac_objext
7011	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7012	>	(eval $ac_compile) 2>conftest.er1
7013	>	ac_status=$?
7014	>	grep -v '^ *+' conftest.er1 >conftest.err
7015	>	rm -f conftest.er1
7016	>	cat conftest.err >&5
7017	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7018	>	(exit $ac_status); } &&
7019	>	{ ac_try='test -z "$ac_c_werror_flag"
7020	>	|| test ! -s conftest.err'
7021	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7022	>	(eval $ac_try) 2>&5
7023	>	ac_status=$?
7024	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7025	>	(exit $ac_status); }; } &&
7026	>	{ ac_try='test -s conftest.$ac_objext'
7027	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7028	>	(eval $ac_try) 2>&5
7029	>	ac_status=$?
7030	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031	>	(exit $ac_status); }; }; then
7032	>	ac_cv_header_stdc=yes
7033	>	else
7034	>	echo "$as_me: failed program was:" >&5
7035	>	sed 's/^/| /' conftest.$ac_ext >&5
7036	>
7037	>	ac_cv_header_stdc=no
7038	>	fi
7039	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7040	>
7041	>	if test $ac_cv_header_stdc = yes; then
7042	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7043	>	cat >conftest.$ac_ext <<_ACEOF
7044	>	/* confdefs.h.  */
7045	>	_ACEOF
7046	>	cat confdefs.h >>conftest.$ac_ext
7047	>	cat >>conftest.$ac_ext <<_ACEOF
7048	>	/* end confdefs.h.  */
7049	>	#include <string.h>
7050	>
7051	>	_ACEOF
7052	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7053	>	$EGREP "memchr" >/dev/null 2>&1; then
7054	>	:
7055	>	else
7056	>	ac_cv_header_stdc=no
7057	>	fi
7058	>	rm -f conftest*
7059	>
7060	>	fi
7061	>
7062	>	if test $ac_cv_header_stdc = yes; then
7063	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7064	>	cat >conftest.$ac_ext <<_ACEOF
7065	>	/* confdefs.h.  */
7066	>	_ACEOF
7067	>	cat confdefs.h >>conftest.$ac_ext
7068	>	cat >>conftest.$ac_ext <<_ACEOF
7069	>	/* end confdefs.h.  */
7070	>	#include <stdlib.h>
7071	>
7072	>	_ACEOF
7073	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7074	>	$EGREP "free" >/dev/null 2>&1; then
7075	>	:
7076	>	else
7077	>	ac_cv_header_stdc=no
7078	>	fi
7079	>	rm -f conftest*
7080	>
7081	>	fi
7082	>
7083	>	if test $ac_cv_header_stdc = yes; then
7084	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7085	>	if test "$cross_compiling" = yes; then
7086	>	:
7087	>	else
7088	>	cat >conftest.$ac_ext <<_ACEOF
7089	>	/* confdefs.h.  */
7090	>	_ACEOF
7091	>	cat confdefs.h >>conftest.$ac_ext
7092	>	cat >>conftest.$ac_ext <<_ACEOF
7093	>	/* end confdefs.h.  */
7094	>	#include <ctype.h>
7095	>	#if ((' ' & 0x0FF) == 0x020)
7096	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7097	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7098	>	#else
7099	>	# define ISLOWER(c) \
7100	>	(('a' <= (c) && (c) <= 'i') \
7101	>	|| ('j' <= (c) && (c) <= 'r') \
7102	>	|| ('s' <= (c) && (c) <= 'z'))
7103	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7104	>	#endif
7105	>
7106	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7107	>	int
7108	>	main ()
7109	>	{
7110	>	int i;
7111	>	for (i = 0; i < 256; i++)
7112	>	if (XOR (islower (i), ISLOWER (i))
7113	>	|| toupper (i) != TOUPPER (i))
7114	>	exit(2);
7115	>	exit (0);
7116	>	}
7117	>	_ACEOF
7118	>	rm -f conftest$ac_exeext
7119	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7120	>	(eval $ac_link) 2>&5
7121	>	ac_status=$?
7122	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7123	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7124	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7125	>	(eval $ac_try) 2>&5
7126	>	ac_status=$?
7127	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7128	>	(exit $ac_status); }; }; then
7129	>	:
7130	>	else
7131	>	echo "$as_me: program exited with status $ac_status" >&5
7132	>	echo "$as_me: failed program was:" >&5
7133	>	sed 's/^/| /' conftest.$ac_ext >&5
7134	>
7135	>	( exit $ac_status )
7136	>	ac_cv_header_stdc=no
7137	>	fi
7138	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7139	>	fi
7140	>	fi
7141	>	fi
7142	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7143	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
7144	>	if test $ac_cv_header_stdc = yes; then
7145	>
7146	>	cat >>confdefs.h <<\_ACEOF
7147	>	#define STDC_HEADERS 1
7148	>	_ACEOF
7149	>
7150	>	fi
7151	>
7152	>
7153	>
7154	>
7155	>
7156	>
7157	>
7158	>
7159	>
7160	>
7161	>
7162	>
7163	>
7164	>
7165	>
7166	>
7167	>
7168	>
7169	>
7170	>
7171	>
7172	>
7173	>
7174	>
7175	>
7176	>
7177	>	for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7178	>	do
7179	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7180	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7181	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7182	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7183	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7184	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7185	>	fi
7186	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7187	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7188	>	else
7189	>	# Is the header compilable?
7190	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
7191	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7192	>	cat >conftest.$ac_ext <<_ACEOF
7193	>	/* confdefs.h.  */
7194	>	_ACEOF
7195	>	cat confdefs.h >>conftest.$ac_ext
7196	>	cat >>conftest.$ac_ext <<_ACEOF
7197	>	/* end confdefs.h.  */
7198	>	$ac_includes_default
7199	>	#include <$ac_header>
7200	>	_ACEOF
7201	>	rm -f conftest.$ac_objext
7202	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7203	>	(eval $ac_compile) 2>conftest.er1
7204	>	ac_status=$?
7205	>	grep -v '^ *+' conftest.er1 >conftest.err
7206	>	rm -f conftest.er1
7207	>	cat conftest.err >&5
7208	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7209	>	(exit $ac_status); } &&
7210	>	{ ac_try='test -z "$ac_c_werror_flag"
7211	>	|| test ! -s conftest.err'
7212	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7213	>	(eval $ac_try) 2>&5
7214	>	ac_status=$?
7215	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7216	>	(exit $ac_status); }; } &&
7217	>	{ ac_try='test -s conftest.$ac_objext'
7218	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7219	>	(eval $ac_try) 2>&5
7220	>	ac_status=$?
7221	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7222	>	(exit $ac_status); }; }; then
7223	>	ac_header_compiler=yes
7224	>	else
7225	>	echo "$as_me: failed program was:" >&5
7226	>	sed 's/^/| /' conftest.$ac_ext >&5
7227	>
7228	>	ac_header_compiler=no
7229	>	fi
7230	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7231	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7232	>	echo "${ECHO_T}$ac_header_compiler" >&6
7233	>
7234	>	# Is the header present?
7235	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
7236	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7237	>	cat >conftest.$ac_ext <<_ACEOF
7238	>	/* confdefs.h.  */
7239	>	_ACEOF
7240	>	cat confdefs.h >>conftest.$ac_ext
7241	>	cat >>conftest.$ac_ext <<_ACEOF
7242	>	/* end confdefs.h.  */
7243	>	#include <$ac_header>
7244	>	_ACEOF
7245	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7246	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7247	>	ac_status=$?
7248	>	grep -v '^ *+' conftest.er1 >conftest.err
7249	>	rm -f conftest.er1
7250	>	cat conftest.err >&5
7251	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252	>	(exit $ac_status); } >/dev/null; then
7253	>	if test -s conftest.err; then
7254	>	ac_cpp_err=$ac_c_preproc_warn_flag
7255	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7256	>	else
7257	>	ac_cpp_err=
7258	>	fi
7259	>	else
7260	>	ac_cpp_err=yes
7261	>	fi
7262	>	if test -z "$ac_cpp_err"; then
7263	>	ac_header_preproc=yes
7264	>	else
7265	>	echo "$as_me: failed program was:" >&5
7266	>	sed 's/^/| /' conftest.$ac_ext >&5
7267	>
7268	>	ac_header_preproc=no
7269	>	fi
7270	>	rm -f conftest.err conftest.$ac_ext
7271	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7272	>	echo "${ECHO_T}$ac_header_preproc" >&6
7273	>
7274	>	# So?  What about this header?
7275	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7276	>	yes:no: )
7277	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7278	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7279	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7280	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7281	>	ac_header_preproc=yes
7282	>	;;
7283	>	no:yes:* )
7284	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7285	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7286	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7287	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7288	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7289	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7290	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7291	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7292	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7293	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7294	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7295	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7296	>	(
7297	>	cat <<\_ASBOX
7298	>	## ------------------------------ ##
7299	>	## Report this to gezelter@nd.edu ##
7300	>	## ------------------------------ ##
7301	>	_ASBOX
7302	>	) |
7303	>	sed "s/^/$as_me: WARNING:     /" >&2
7304	>	;;
7305	>	esac
7306	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7307	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7308	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7309	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7310	>	else
7311	>	eval "$as_ac_Header=\$ac_header_preproc"
7312	>	fi
7313	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7314	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7315	>
7316	>	fi
7317	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
7318	>	cat >>confdefs.h <<_ACEOF
7319	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7320	>	_ACEOF
7321	>
7322	>	fi
7323	>
7324	>	done
7325	>
7326	>
7327	>	# Checks for typedefs, structures, and compiler characteristics.
7328	>	echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7329	>	echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7330	>	if test "${ac_cv_header_stdbool_h+set}" = set; then
7331	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7332	>	else
7333	>	cat >conftest.$ac_ext <<_ACEOF
7334	>	/* confdefs.h.  */
7335	>	_ACEOF
7336	>	cat confdefs.h >>conftest.$ac_ext
7337	>	cat >>conftest.$ac_ext <<_ACEOF
7338	>	/* end confdefs.h.  */
7339	>
7340	>	#include <stdbool.h>
7341	>	#ifndef bool
7342	>	# error bool is not defined
7343	>	#endif
7344	>	#ifndef false
7345	>	# error false is not defined
7346	>	#endif
7347	>	#if false
7348	>	# error false is not 0
7349	>	#endif
7350	>	#ifndef true
7351	>	# error true is not defined
7352	>	#endif
7353	>	#if true != 1
7354	>	# error true is not 1
7355	>	#endif
7356	>	#ifndef __bool_true_false_are_defined
7357	>	# error __bool_true_false_are_defined is not defined
7358	>	#endif
7359	>
7360	>	struct s { _Bool s: 1; _Bool t; } s;
7361	>
7362	>	char a[true == 1 ? 1 : -1];
7363	>	char b[false == 0 ? 1 : -1];
7364	>	char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7365	>	char d[(bool) -0.5 == true ? 1 : -1];
7366	>	bool e = &s;
7367	>	char f[(_Bool) -0.0 == false ? 1 : -1];
7368	>	char g[true];
7369	>	char h[sizeof (_Bool)];
7370	>	char i[sizeof s.t];
7371	>
7372	>	#ifdef FC_DUMMY_MAIN
7373	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7374	>	#  ifdef __cplusplus
7375	>	extern "C"
7376	>	#  endif
7377	>	int FC_DUMMY_MAIN() { return 1; }
7378	>	#endif
7379	>	#endif
7380	>	int
7381	>	main ()
7382	>	{
7383	>	return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7384	>	;
7385	>	return 0;
7386	>	}
7387	>	_ACEOF
7388	>	rm -f conftest.$ac_objext
7389	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7390	>	(eval $ac_compile) 2>conftest.er1
7391	>	ac_status=$?
7392	>	grep -v '^ *+' conftest.er1 >conftest.err
7393	>	rm -f conftest.er1
7394	>	cat conftest.err >&5
7395	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396	>	(exit $ac_status); } &&
7397	>	{ ac_try='test -z "$ac_c_werror_flag"
7398	>	|| test ! -s conftest.err'
7399	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7400	>	(eval $ac_try) 2>&5
7401	>	ac_status=$?
7402	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7403	>	(exit $ac_status); }; } &&
7404	>	{ ac_try='test -s conftest.$ac_objext'
7405	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7406	>	(eval $ac_try) 2>&5
7407	>	ac_status=$?
7408	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7409	>	(exit $ac_status); }; }; then
7410	>	ac_cv_header_stdbool_h=yes
7411	>	else
7412	>	echo "$as_me: failed program was:" >&5
7413	>	sed 's/^/| /' conftest.$ac_ext >&5
7414	>
7415	>	ac_cv_header_stdbool_h=no
7416	>	fi
7417	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7418	>	fi
7419	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7420	>	echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7421	>	echo "$as_me:$LINENO: checking for _Bool" >&5
7422	>	echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7423	>	if test "${ac_cv_type__Bool+set}" = set; then
7424	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7425	>	else
7426	>	cat >conftest.$ac_ext <<_ACEOF
7427	>	/* confdefs.h.  */
7428	>	_ACEOF
7429	>	cat confdefs.h >>conftest.$ac_ext
7430	>	cat >>conftest.$ac_ext <<_ACEOF
7431	>	/* end confdefs.h.  */
7432	>	$ac_includes_default
7433	>	#ifdef FC_DUMMY_MAIN
7434	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7435	>	#  ifdef __cplusplus
7436	>	extern "C"
7437	>	#  endif
7438	>	int FC_DUMMY_MAIN() { return 1; }
7439	>	#endif
7440	>	#endif
7441	>	int
7442	>	main ()
7443	>	{
7444	>	if ((_Bool *) 0)
7445	>	return 0;
7446	>	if (sizeof (_Bool))
7447	>	return 0;
7448	>	;
7449	>	return 0;
7450	>	}
7451	>	_ACEOF
7452	>	rm -f conftest.$ac_objext
7453	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7454	>	(eval $ac_compile) 2>conftest.er1
7455	>	ac_status=$?
7456	>	grep -v '^ *+' conftest.er1 >conftest.err
7457	>	rm -f conftest.er1
7458	>	cat conftest.err >&5
7459	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7460	>	(exit $ac_status); } &&
7461	>	{ ac_try='test -z "$ac_c_werror_flag"
7462	>	|| test ! -s conftest.err'
7463	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7464	>	(eval $ac_try) 2>&5
7465	>	ac_status=$?
7466	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7467	>	(exit $ac_status); }; } &&
7468	>	{ ac_try='test -s conftest.$ac_objext'
7469	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7470	>	(eval $ac_try) 2>&5
7471	>	ac_status=$?
7472	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7473	>	(exit $ac_status); }; }; then
7474	>	ac_cv_type__Bool=yes
7475	>	else
7476	>	echo "$as_me: failed program was:" >&5
7477	>	sed 's/^/| /' conftest.$ac_ext >&5
7478	>
7479	>	ac_cv_type__Bool=no
7480	>	fi
7481	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7482	>	fi
7483	>	echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7484	>	echo "${ECHO_T}$ac_cv_type__Bool" >&6
7485	>	if test $ac_cv_type__Bool = yes; then
7486	>
7487	>	cat >>confdefs.h <<_ACEOF
7488	>	#define HAVE__BOOL 1
7489	>	_ACEOF
7490	>
7491	>
7492	>	fi
7493	>
7494	>	if test $ac_cv_header_stdbool_h = yes; then
7495	>
7496	>	cat >>confdefs.h <<\_ACEOF
7497	>	#define HAVE_STDBOOL_H 1
7498	>	_ACEOF
7499	>
7500	>	fi
7501	>
7502	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7503	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7504	>	if test "${ac_cv_c_const+set}" = set; then
7505	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7506	>	else
7507	>	cat >conftest.$ac_ext <<_ACEOF
7508	>	/* confdefs.h.  */
7509	>	_ACEOF
7510	>	cat confdefs.h >>conftest.$ac_ext
7511	>	cat >>conftest.$ac_ext <<_ACEOF
7512	>	/* end confdefs.h.  */
7513	>
7514	>	#ifdef FC_DUMMY_MAIN
7515	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7516	>	#  ifdef __cplusplus
7517	>	extern "C"
7518	>	#  endif
7519	>	int FC_DUMMY_MAIN() { return 1; }
7520	>	#endif
7521	>	#endif
7522	>	int
7523	>	main ()
7524	>	{
7525	>	/* FIXME: Include the comments suggested by Paul. */
7526	>	#ifndef __cplusplus
7527	>	/* Ultrix mips cc rejects this.  */
7528	>	typedef int charset[2];
7529	>	const charset x;
7530	>	/* SunOS 4.1.1 cc rejects this.  */
7531	>	char const *const *ccp;
7532	>	char **p;
7533	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7534	>	struct point {int x, y;};
7535	>	static struct point const zero = {0,0};
7536	>	/* AIX XL C 1.02.0.0 rejects this.
7537	>	It does not let you subtract one const X* pointer from another in
7538	>	an arm of an if-expression whose if-part is not a constant
7539	>	expression */
7540	>	const char *g = "string";
7541	>	ccp = &g + (g ? g-g : 0);
7542	>	/* HPUX 7.0 cc rejects these. */
7543	>	++ccp;
7544	>	p = (char**) ccp;
7545	>	ccp = (char const *const *) p;
7546	>	{ /* SCO 3.2v4 cc rejects this.  */
7547	>	char *t;
7548	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7549	>
7550	>	*t++ = 0;
7551	>	}
7552	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7553	>	int x[] = {25, 17};
7554	>	const int *foo = &x[0];
7555	>	++foo;
7556	>	}
7557	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7558	>	typedef const int *iptr;
7559	>	iptr p = 0;
7560	>	++p;
7561	>	}
7562	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7563	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7564	>	struct s { int j; const int *ap[3]; };
7565	>	struct s *b; b->j = 5;
7566	>	}
7567	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7568	>	const int foo = 10;
7569	>	}
7570	>	#endif
7571	>
7572	>	;
7573	>	return 0;
7574	>	}
7575	>	_ACEOF
7576	>	rm -f conftest.$ac_objext
7577	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7578	>	(eval $ac_compile) 2>conftest.er1
7579	>	ac_status=$?
7580	>	grep -v '^ *+' conftest.er1 >conftest.err
7581	>	rm -f conftest.er1
7582	>	cat conftest.err >&5
7583	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7584	>	(exit $ac_status); } &&
7585	>	{ ac_try='test -z "$ac_c_werror_flag"
7586	>	|| test ! -s conftest.err'
7587	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7588	>	(eval $ac_try) 2>&5
7589	>	ac_status=$?
7590	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7591	>	(exit $ac_status); }; } &&
7592	>	{ ac_try='test -s conftest.$ac_objext'
7593	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7594	>	(eval $ac_try) 2>&5
7595	>	ac_status=$?
7596	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7597	>	(exit $ac_status); }; }; then
7598	>	ac_cv_c_const=yes
7599	>	else
7600	>	echo "$as_me: failed program was:" >&5
7601	>	sed 's/^/| /' conftest.$ac_ext >&5
7602	>
7603	>	ac_cv_c_const=no
7604	>	fi
7605	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7606	>	fi
7607	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7608	>	echo "${ECHO_T}$ac_cv_c_const" >&6
7609	>	if test $ac_cv_c_const = no; then
7610	>
7611	>	cat >>confdefs.h <<\_ACEOF
7612	>	#define const
7613	>	_ACEOF
7614	>
7615	>	fi
7616	>
7617	>	echo "$as_me:$LINENO: checking for inline" >&5
7618	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
7619	>	if test "${ac_cv_c_inline+set}" = set; then
7620	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7621	>	else
7622	>	ac_cv_c_inline=no
7623	>	for ac_kw in inline __inline__ __inline; do
7624	>	cat >conftest.$ac_ext <<_ACEOF
7625	>	/* confdefs.h.  */
7626	>	_ACEOF
7627	>	cat confdefs.h >>conftest.$ac_ext
7628	>	cat >>conftest.$ac_ext <<_ACEOF
7629	>	/* end confdefs.h.  */
7630	>	#ifndef __cplusplus
7631	>	typedef int foo_t;
7632	>	static $ac_kw foo_t static_foo () {return 0; }
7633	>	$ac_kw foo_t foo () {return 0; }
7634	>	#endif
7635	>
7636	>	_ACEOF
7637	>	rm -f conftest.$ac_objext
7638	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7639	>	(eval $ac_compile) 2>conftest.er1
7640	>	ac_status=$?
7641	>	grep -v '^ *+' conftest.er1 >conftest.err
7642	>	rm -f conftest.er1
7643	>	cat conftest.err >&5
7644	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7645	>	(exit $ac_status); } &&
7646	>	{ ac_try='test -z "$ac_c_werror_flag"
7647	>	|| test ! -s conftest.err'
7648	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7649	>	(eval $ac_try) 2>&5
7650	>	ac_status=$?
7651	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7652	>	(exit $ac_status); }; } &&
7653	>	{ ac_try='test -s conftest.$ac_objext'
7654	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7655	>	(eval $ac_try) 2>&5
7656	>	ac_status=$?
7657	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7658	>	(exit $ac_status); }; }; then
7659	>	ac_cv_c_inline=$ac_kw; break
7660	>	else
7661	>	echo "$as_me: failed program was:" >&5
7662	>	sed 's/^/| /' conftest.$ac_ext >&5
7663	>
7664	>	fi
7665	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666	>	done
7667	>
7668	>	fi
7669	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7670	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
7671	>
7672	>
7673	>	case $ac_cv_c_inline in
7674	>	inline | yes) ;;
7675	>	*)
7676	>	case $ac_cv_c_inline in
7677	>	no) ac_val=;;
7678	>	*) ac_val=$ac_cv_c_inline;;
7679	>	esac
7680	>	cat >>confdefs.h <<_ACEOF
7681	>	#ifndef __cplusplus
7682	>	#define inline $ac_val
7683	>	#endif
7684	>	_ACEOF
7685	>	;;
7686	>	esac
7687	>
7688	>	echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7689	>	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7690	>	if test "${ac_cv_c_restrict+set}" = set; then
7691	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7692	>	else
7693	>	ac_cv_c_restrict=no
7694	>	# Try the official restrict keyword, then gcc's __restrict, and
7695	>	# the less common variants.
7696	>	for ac_kw in restrict __restrict __restrict__ _Restrict; do
7697	>	cat >conftest.$ac_ext <<_ACEOF
7698	>	/* confdefs.h.  */
7699	>	_ACEOF
7700	>	cat confdefs.h >>conftest.$ac_ext
7701	>	cat >>conftest.$ac_ext <<_ACEOF
7702	>	/* end confdefs.h.  */
7703	>	float * $ac_kw x;
7704	>	_ACEOF
7705	>	rm -f conftest.$ac_objext
7706	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7707	>	(eval $ac_compile) 2>conftest.er1
7708	>	ac_status=$?
7709	>	grep -v '^ *+' conftest.er1 >conftest.err
7710	>	rm -f conftest.er1
7711	>	cat conftest.err >&5
7712	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7713	>	(exit $ac_status); } &&
7714	>	{ ac_try='test -z "$ac_c_werror_flag"
7715	>	|| test ! -s conftest.err'
7716	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717	>	(eval $ac_try) 2>&5
7718	>	ac_status=$?
7719	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720	>	(exit $ac_status); }; } &&
7721	>	{ ac_try='test -s conftest.$ac_objext'
7722	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7723	>	(eval $ac_try) 2>&5
7724	>	ac_status=$?
7725	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7726	>	(exit $ac_status); }; }; then
7727	>	ac_cv_c_restrict=$ac_kw; break
7728	>	else
7729	>	echo "$as_me: failed program was:" >&5
7730	>	sed 's/^/| /' conftest.$ac_ext >&5
7731	>
7732	>	fi
7733	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7734	>	done
7735	>
7736	>	fi
7737	>	echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7738	>	echo "${ECHO_T}$ac_cv_c_restrict" >&6
7739	>	case $ac_cv_c_restrict in
7740	>	restrict) ;;
7741	>	no)
7742	>	cat >>confdefs.h <<\_ACEOF
7743	>	#define restrict
7744	>	_ACEOF
7745	>	;;
7746	>	*)  cat >>confdefs.h <<_ACEOF
7747	>	#define restrict $ac_cv_c_restrict
7748	>	_ACEOF
7749	>	;;
7750	>	esac
7751	>
7752	>	echo "$as_me:$LINENO: checking for size_t" >&5
7753	>	echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7754	>	if test "${ac_cv_type_size_t+set}" = set; then
7755	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7756	>	else
7757	>	cat >conftest.$ac_ext <<_ACEOF
7758	>	/* confdefs.h.  */
7759	>	_ACEOF
7760	>	cat confdefs.h >>conftest.$ac_ext
7761	>	cat >>conftest.$ac_ext <<_ACEOF
7762	>	/* end confdefs.h.  */
7763	>	$ac_includes_default
7764	>	#ifdef FC_DUMMY_MAIN
7765	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7766	>	#  ifdef __cplusplus
7767	>	extern "C"
7768	>	#  endif
7769	>	int FC_DUMMY_MAIN() { return 1; }
7770	>	#endif
7771	>	#endif
7772	>	int
7773	>	main ()
7774	>	{
7775	>	if ((size_t *) 0)
7776	>	return 0;
7777	>	if (sizeof (size_t))
7778	>	return 0;
7779	>	;
7780	>	return 0;
7781	>	}
7782	>	_ACEOF
7783	>	rm -f conftest.$ac_objext
7784	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7785	>	(eval $ac_compile) 2>conftest.er1
7786	>	ac_status=$?
7787	>	grep -v '^ *+' conftest.er1 >conftest.err
7788	>	rm -f conftest.er1
7789	>	cat conftest.err >&5
7790	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7791	>	(exit $ac_status); } &&
7792	>	{ ac_try='test -z "$ac_c_werror_flag"
7793	>	|| test ! -s conftest.err'
7794	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7795	>	(eval $ac_try) 2>&5
7796	>	ac_status=$?
7797	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7798	>	(exit $ac_status); }; } &&
7799	>	{ ac_try='test -s conftest.$ac_objext'
7800	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7801	>	(eval $ac_try) 2>&5
7802	>	ac_status=$?
7803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7804	>	(exit $ac_status); }; }; then
7805	>	ac_cv_type_size_t=yes
7806	>	else
7807	>	echo "$as_me: failed program was:" >&5
7808	>	sed 's/^/| /' conftest.$ac_ext >&5
7809	>
7810	>	ac_cv_type_size_t=no
7811	>	fi
7812	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7813	>	fi
7814	>	echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7815	>	echo "${ECHO_T}$ac_cv_type_size_t" >&6
7816	>	if test $ac_cv_type_size_t = yes; then
7817	>	:
7818	>	else
7819	>
7820	>	cat >>confdefs.h <<_ACEOF
7821	>	#define size_t unsigned
7822	>	_ACEOF
7823	>
7824	>	fi
7825	>
7826	>	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7827	>	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7828	>	if test "${ac_cv_header_time+set}" = set; then
7829	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7830	>	else
7831	>	cat >conftest.$ac_ext <<_ACEOF
7832	>	/* confdefs.h.  */
7833	>	_ACEOF
7834	>	cat confdefs.h >>conftest.$ac_ext
7835	>	cat >>conftest.$ac_ext <<_ACEOF
7836	>	/* end confdefs.h.  */
7837	>	#include <sys/types.h>
7838	>	#include <sys/time.h>
7839	>	#include <time.h>
7840	>
7841	>	#ifdef FC_DUMMY_MAIN
7842	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7843	>	#  ifdef __cplusplus
7844	>	extern "C"
7845	>	#  endif
7846	>	int FC_DUMMY_MAIN() { return 1; }
7847	>	#endif
7848	>	#endif
7849	>	int
7850	>	main ()
7851	>	{
7852	>	if ((struct tm *) 0)
7853	>	return 0;
7854	>	;
7855	>	return 0;
7856	>	}
7857	>	_ACEOF
7858	>	rm -f conftest.$ac_objext
7859	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7860	>	(eval $ac_compile) 2>conftest.er1
7861	>	ac_status=$?
7862	>	grep -v '^ *+' conftest.er1 >conftest.err
7863	>	rm -f conftest.er1
7864	>	cat conftest.err >&5
7865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7866	>	(exit $ac_status); } &&
7867	>	{ ac_try='test -z "$ac_c_werror_flag"
7868	>	|| test ! -s conftest.err'
7869	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7870	>	(eval $ac_try) 2>&5
7871	>	ac_status=$?
7872	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7873	>	(exit $ac_status); }; } &&
7874	>	{ ac_try='test -s conftest.$ac_objext'
7875	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7876	>	(eval $ac_try) 2>&5
7877	>	ac_status=$?
7878	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879	>	(exit $ac_status); }; }; then
7880	>	ac_cv_header_time=yes
7881	>	else
7882	>	echo "$as_me: failed program was:" >&5
7883	>	sed 's/^/| /' conftest.$ac_ext >&5
7884	>
7885	>	ac_cv_header_time=no
7886	>	fi
7887	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7888	>	fi
7889	>	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7890	>	echo "${ECHO_T}$ac_cv_header_time" >&6
7891	>	if test $ac_cv_header_time = yes; then
7892	>
7893	>	cat >>confdefs.h <<\_ACEOF
7894	>	#define TIME_WITH_SYS_TIME 1
7895	>	_ACEOF
7896	>
7897	>	fi
7898	>
7899	>	echo "$as_me:$LINENO: checking for clock_t" >&5
7900	>	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7901	>	if test "${ac_cv_type_clock_t+set}" = set; then
7902	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7903	>	else
7904	>	cat >conftest.$ac_ext <<_ACEOF
7905	>	/* confdefs.h.  */
7906	>	_ACEOF
7907	>	cat confdefs.h >>conftest.$ac_ext
7908	>	cat >>conftest.$ac_ext <<_ACEOF
7909	>	/* end confdefs.h.  */
7910	>	$ac_includes_default
7911	>	#ifdef FC_DUMMY_MAIN
7912	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7913	>	#  ifdef __cplusplus
7914	>	extern "C"
7915	>	#  endif
7916	>	int FC_DUMMY_MAIN() { return 1; }
7917	>	#endif
7918	>	#endif
7919	>	int
7920	>	main ()
7921	>	{
7922	>	if ((clock_t *) 0)
7923	>	return 0;
7924	>	if (sizeof (clock_t))
7925	>	return 0;
7926	>	;
7927	>	return 0;
7928	>	}
7929	>	_ACEOF
7930	>	rm -f conftest.$ac_objext
7931	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7932	>	(eval $ac_compile) 2>conftest.er1
7933	>	ac_status=$?
7934	>	grep -v '^ *+' conftest.er1 >conftest.err
7935	>	rm -f conftest.er1
7936	>	cat conftest.err >&5
7937	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7938	>	(exit $ac_status); } &&
7939	>	{ ac_try='test -z "$ac_c_werror_flag"
7940	>	|| test ! -s conftest.err'
7941	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7942	>	(eval $ac_try) 2>&5
7943	>	ac_status=$?
7944	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7945	>	(exit $ac_status); }; } &&
7946	>	{ ac_try='test -s conftest.$ac_objext'
7947	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7948	>	(eval $ac_try) 2>&5
7949	>	ac_status=$?
7950	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7951	>	(exit $ac_status); }; }; then
7952	>	ac_cv_type_clock_t=yes
7953	>	else
7954	>	echo "$as_me: failed program was:" >&5
7955	>	sed 's/^/| /' conftest.$ac_ext >&5
7956	>
7957	>	ac_cv_type_clock_t=no
7958	>	fi
7959	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7960	>	fi
7961	>	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7962	>	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7963	>	if test $ac_cv_type_clock_t = yes; then
7964	>
7965	>	cat >>confdefs.h <<_ACEOF
7966	>	#define HAVE_CLOCK_T 1
7967	>	_ACEOF
7968	>
7969	>
7970	>	fi
7971	>
7972	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7973	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7974	>	if test "${ac_cv_c_const+set}" = set; then
7975	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7976	>	else
7977	>	cat >conftest.$ac_ext <<_ACEOF
7978	>	/* confdefs.h.  */
7979	>	_ACEOF
7980	>	cat confdefs.h >>conftest.$ac_ext
7981	>	cat >>conftest.$ac_ext <<_ACEOF
7982	>	/* end confdefs.h.  */
7983	>
7984	>	#ifdef FC_DUMMY_MAIN
7985	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7986	>	#  ifdef __cplusplus
7987	>	extern "C"
7988	>	#  endif
7989	>	int FC_DUMMY_MAIN() { return 1; }
7990	>	#endif
7991	>	#endif
7992	>	int
7993	>	main ()
7994	>	{
7995	>	/* FIXME: Include the comments suggested by Paul. */
7996	>	#ifndef __cplusplus
7997	>	/* Ultrix mips cc rejects this.  */
7998	>	typedef int charset[2];
7999	>	const charset x;
8000	>	/* SunOS 4.1.1 cc rejects this.  */
8001	>	char const *const *ccp;
8002	>	char **p;
8003	>	/* NEC SVR4.0.2 mips cc rejects this.  */
8004	>	struct point {int x, y;};
8005	>	static struct point const zero = {0,0};
8006	>	/* AIX XL C 1.02.0.0 rejects this.
8007	>	It does not let you subtract one const X* pointer from another in
8008	>	an arm of an if-expression whose if-part is not a constant
8009	>	expression */
8010	>	const char *g = "string";
8011	>	ccp = &g + (g ? g-g : 0);
8012	>	/* HPUX 7.0 cc rejects these. */
8013	>	++ccp;
8014	>	p = (char**) ccp;
8015	>	ccp = (char const *const *) p;
8016	>	{ /* SCO 3.2v4 cc rejects this.  */
8017	>	char *t;
8018	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
8019	>
8020	>	*t++ = 0;
8021	>	}
8022	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8023	>	int x[] = {25, 17};
8024	>	const int *foo = &x[0];
8025	>	++foo;
8026	>	}
8027	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8028	>	typedef const int *iptr;
8029	>	iptr p = 0;
8030	>	++p;
8031	>	}
8032	>	{ /* AIX XL C 1.02.0.0 rejects this saying
8033	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8034	>	struct s { int j; const int *ap[3]; };
8035	>	struct s *b; b->j = 5;
8036	>	}
8037	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8038	>	const int foo = 10;
8039	>	}
8040	>	#endif
8041	>
8042	>	;
8043	>	return 0;
8044	>	}
8045	>	_ACEOF
8046	>	rm -f conftest.$ac_objext
8047	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8048	>	(eval $ac_compile) 2>conftest.er1
8049	>	ac_status=$?
8050	>	grep -v '^ *+' conftest.er1 >conftest.err
8051	>	rm -f conftest.er1
8052	>	cat conftest.err >&5
8053	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8054	>	(exit $ac_status); } &&
8055	>	{ ac_try='test -z "$ac_c_werror_flag"
8056	>	|| test ! -s conftest.err'
8057	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8058	>	(eval $ac_try) 2>&5
8059	>	ac_status=$?
8060	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8061	>	(exit $ac_status); }; } &&
8062	>	{ ac_try='test -s conftest.$ac_objext'
8063	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8064	>	(eval $ac_try) 2>&5
8065	>	ac_status=$?
8066	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8067	>	(exit $ac_status); }; }; then
8068	>	ac_cv_c_const=yes
8069	>	else
8070	>	echo "$as_me: failed program was:" >&5
8071	>	sed 's/^/| /' conftest.$ac_ext >&5
8072	>
8073	>	ac_cv_c_const=no
8074	>	fi
8075	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8076	>	fi
8077	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8078	>	echo "${ECHO_T}$ac_cv_c_const" >&6
8079	>	if test $ac_cv_c_const = no; then
8080	>
8081	>	cat >>confdefs.h <<\_ACEOF
8082	>	#define const
8083	>	_ACEOF
8084	>
8085	>	fi
8086	>
8087	>	echo "$as_me:$LINENO: checking for inline" >&5
8088	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
8089	>	if test "${ac_cv_c_inline+set}" = set; then
8090	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8091	>	else
8092	>	ac_cv_c_inline=no
8093	>	for ac_kw in inline __inline__ __inline; do
8094	>	cat >conftest.$ac_ext <<_ACEOF
8095	>	/* confdefs.h.  */
8096	>	_ACEOF
8097	>	cat confdefs.h >>conftest.$ac_ext
8098	>	cat >>conftest.$ac_ext <<_ACEOF
8099	>	/* end confdefs.h.  */
8100	>	#ifndef __cplusplus
8101	>	typedef int foo_t;
8102	>	static $ac_kw foo_t static_foo () {return 0; }
8103	>	$ac_kw foo_t foo () {return 0; }
8104	>	#endif
8105	>
8106	>	_ACEOF
8107	>	rm -f conftest.$ac_objext
8108	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8109	>	(eval $ac_compile) 2>conftest.er1
8110	>	ac_status=$?
8111	>	grep -v '^ *+' conftest.er1 >conftest.err
8112	>	rm -f conftest.er1
8113	>	cat conftest.err >&5
8114	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8115	>	(exit $ac_status); } &&
8116	>	{ ac_try='test -z "$ac_c_werror_flag"
8117	>	|| test ! -s conftest.err'
8118	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8119	>	(eval $ac_try) 2>&5
8120	>	ac_status=$?
8121	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122	>	(exit $ac_status); }; } &&
8123	>	{ ac_try='test -s conftest.$ac_objext'
8124	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8125	>	(eval $ac_try) 2>&5
8126	>	ac_status=$?
8127	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8128	>	(exit $ac_status); }; }; then
8129	>	ac_cv_c_inline=$ac_kw; break
8130	>	else
8131	>	echo "$as_me: failed program was:" >&5
8132	>	sed 's/^/| /' conftest.$ac_ext >&5
8133	>
8134	>	fi
8135	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136	>	done
8137	>
8138	>	fi
8139	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8140	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
8141	>
8142	>
8143	>	case $ac_cv_c_inline in
8144	>	inline | yes) ;;
8145	>	*)
8146	>	case $ac_cv_c_inline in
8147	>	no) ac_val=;;
8148	>	*) ac_val=$ac_cv_c_inline;;
8149	>	esac
8150	>	cat >>confdefs.h <<_ACEOF
8151	>	#ifndef __cplusplus
8152	>	#define inline $ac_val
8153	>	#endif
8154	>	_ACEOF
8155	>	;;
8156	>	esac
8157	>
8158	>
8159	>	# Checks for library functions.
8160	>
8161	>	for ac_header in stdlib.h
8162	>	do
8163	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8164	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8165	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8166	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8167	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8168	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8169	>	fi
8170	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8171	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8172	>	else
8173	>	# Is the header compilable?
8174	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8175	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8176	>	cat >conftest.$ac_ext <<_ACEOF
8177	>	/* confdefs.h.  */
8178	>	_ACEOF
8179	>	cat confdefs.h >>conftest.$ac_ext
8180	>	cat >>conftest.$ac_ext <<_ACEOF
8181	>	/* end confdefs.h.  */
8182	>	$ac_includes_default
8183	>	#include <$ac_header>
8184	>	_ACEOF
8185	>	rm -f conftest.$ac_objext
8186	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8187	>	(eval $ac_compile) 2>conftest.er1
8188	>	ac_status=$?
8189	>	grep -v '^ *+' conftest.er1 >conftest.err
8190	>	rm -f conftest.er1
8191	>	cat conftest.err >&5
8192	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193	>	(exit $ac_status); } &&
8194	>	{ ac_try='test -z "$ac_c_werror_flag"
8195	>	|| test ! -s conftest.err'
8196	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8197	>	(eval $ac_try) 2>&5
8198	>	ac_status=$?
8199	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8200	>	(exit $ac_status); }; } &&
8201	>	{ ac_try='test -s conftest.$ac_objext'
8202	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8203	>	(eval $ac_try) 2>&5
8204	>	ac_status=$?
8205	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8206	>	(exit $ac_status); }; }; then
8207	>	ac_header_compiler=yes
8208	>	else
8209	>	echo "$as_me: failed program was:" >&5
8210	>	sed 's/^/| /' conftest.$ac_ext >&5
8211	>
8212	>	ac_header_compiler=no
8213	>	fi
8214	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8215	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8216	>	echo "${ECHO_T}$ac_header_compiler" >&6
8217	>
8218	>	# Is the header present?
8219	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8220	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8221	>	cat >conftest.$ac_ext <<_ACEOF
8222	>	/* confdefs.h.  */
8223	>	_ACEOF
8224	>	cat confdefs.h >>conftest.$ac_ext
8225	>	cat >>conftest.$ac_ext <<_ACEOF
8226	>	/* end confdefs.h.  */
8227	>	#include <$ac_header>
8228	>	_ACEOF
8229	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8230	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8231	>	ac_status=$?
8232	>	grep -v '^ *+' conftest.er1 >conftest.err
8233	>	rm -f conftest.er1
8234	>	cat conftest.err >&5
8235	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8236	>	(exit $ac_status); } >/dev/null; then
8237	>	if test -s conftest.err; then
8238	>	ac_cpp_err=$ac_c_preproc_warn_flag
8239	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8240	>	else
8241	>	ac_cpp_err=
8242	>	fi
8243	>	else
8244	>	ac_cpp_err=yes
8245	>	fi
8246	>	if test -z "$ac_cpp_err"; then
8247	>	ac_header_preproc=yes
8248	>	else
8249	>	echo "$as_me: failed program was:" >&5
8250	>	sed 's/^/| /' conftest.$ac_ext >&5
8251	>
8252	>	ac_header_preproc=no
8253	>	fi
8254	>	rm -f conftest.err conftest.$ac_ext
8255	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8256	>	echo "${ECHO_T}$ac_header_preproc" >&6
8257	>
8258	>	# So?  What about this header?
8259	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8260	>	yes:no: )
8261	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8262	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8263	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8264	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8265	>	ac_header_preproc=yes
8266	>	;;
8267	>	no:yes:* )
8268	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8269	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8270	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8271	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8272	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8273	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8274	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8275	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8276	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8277	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8278	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8279	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8280	>	(
8281	>	cat <<\_ASBOX
8282	>	## ------------------------------ ##
8283	>	## Report this to gezelter@nd.edu ##
8284	>	## ------------------------------ ##
8285	>	_ASBOX
8286	>	) |
8287	>	sed "s/^/$as_me: WARNING:     /" >&2
8288	>	;;
8289	>	esac
8290	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8291	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8292	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8293	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8294	>	else
8295	>	eval "$as_ac_Header=\$ac_header_preproc"
8296	>	fi
8297	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8298	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8299	>
8300	>	fi
8301	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8302	>	cat >>confdefs.h <<_ACEOF
8303	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8304	>	_ACEOF
8305	>
8306	>	fi
8307	>
8308	>	done
8309	>
8310	>	echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8311	>	echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8312	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8313	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8314	>	else
8315	>	if test "$cross_compiling" = yes; then
8316	>	ac_cv_func_malloc_0_nonnull=no
8317	>	else
8318	>	cat >conftest.$ac_ext <<_ACEOF
8319	>	/* confdefs.h.  */
8320	>	_ACEOF
8321	>	cat confdefs.h >>conftest.$ac_ext
8322	>	cat >>conftest.$ac_ext <<_ACEOF
8323	>	/* end confdefs.h.  */
8324	>	#if STDC_HEADERS || HAVE_STDLIB_H
8325	>	# include <stdlib.h>
8326	>	#else
8327	>	char *malloc ();
8328	>	#endif
8329	>
8330	>	#ifdef FC_DUMMY_MAIN
8331	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8332	>	#  ifdef __cplusplus
8333	>	extern "C"
8334	>	#  endif
8335	>	int FC_DUMMY_MAIN() { return 1; }
8336	>	#endif
8337	>	#endif
8338	>	int
8339	>	main ()
8340	>	{
8341	>	exit (malloc (0) ? 0 : 1);
8342	>	;
8343	>	return 0;
8344	>	}
8345	>	_ACEOF
8346	>	rm -f conftest$ac_exeext
8347	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8348	>	(eval $ac_link) 2>&5
8349	>	ac_status=$?
8350	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8351	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8352	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8353	>	(eval $ac_try) 2>&5
8354	>	ac_status=$?
8355	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8356	>	(exit $ac_status); }; }; then
8357	>	ac_cv_func_malloc_0_nonnull=yes
8358	>	else
8359	>	echo "$as_me: program exited with status $ac_status" >&5
8360	>	echo "$as_me: failed program was:" >&5
8361	>	sed 's/^/| /' conftest.$ac_ext >&5
8362	>
8363	>	( exit $ac_status )
8364	>	ac_cv_func_malloc_0_nonnull=no
8365	>	fi
8366	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8367	>	fi
8368	>	fi
8369	>	echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8370	>	echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8371	>	if test $ac_cv_func_malloc_0_nonnull = yes; then
8372	>
8373	>	cat >>confdefs.h <<\_ACEOF
8374	>	#define HAVE_MALLOC 1
8375	>	_ACEOF
8376	>
8377	>	else
8378	>	cat >>confdefs.h <<\_ACEOF
8379	>	#define HAVE_MALLOC 0
8380	>	_ACEOF
8381	>
8382	>	case $LIBOBJS in
8383	>	"malloc.$ac_objext"   | \
8384	>	*" malloc.$ac_objext"   | \
8385	>	"malloc.$ac_objext "* | \
8386	>	*" malloc.$ac_objext "* ) ;;
8387	>	*) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8388	>	esac
8389	>
8390	>
8391	>	cat >>confdefs.h <<\_ACEOF
8392	>	#define malloc rpl_malloc
8393	>	_ACEOF
8394	>
8395	>	fi
8396	>
8397	>
8398	>
8399	>	echo "$as_me:$LINENO: checking for working memcmp" >&5
8400	>	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8401	>	if test "${ac_cv_func_memcmp_working+set}" = set; then
8402	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8403	>	else
8404	>	if test "$cross_compiling" = yes; then
8405	>	ac_cv_func_memcmp_working=no
8406	>	else
8407	>	cat >conftest.$ac_ext <<_ACEOF
8408	>	/* confdefs.h.  */
8409	>	_ACEOF
8410	>	cat confdefs.h >>conftest.$ac_ext
8411	>	cat >>conftest.$ac_ext <<_ACEOF
8412	>	/* end confdefs.h.  */
8413	>	$ac_includes_default
8414	>	#ifdef FC_DUMMY_MAIN
8415	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8416	>	#  ifdef __cplusplus
8417	>	extern "C"
8418	>	#  endif
8419	>	int FC_DUMMY_MAIN() { return 1; }
8420	>	#endif
8421	>	#endif
8422	>	int
8423	>	main ()
8424	>	{
8425	>
8426	>	/* Some versions of memcmp are not 8-bit clean.  */
8427	>	char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8428	>	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8429	>	exit (1);
8430	>
8431	>	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8432	>	or more and with at least one buffer not starting on a 4-byte boundary.
8433	>	William Lewis provided this test program.   */
8434	>	{
8435	>	char foo[21];
8436	>	char bar[21];
8437	>	int i;
8438	>	for (i = 0; i < 4; i++)
8439	>	{
8440	>	char *a = foo + i;
8441	>	char *b = bar + i;
8442	>	strcpy (a, "--------01111111");
8443	>	strcpy (b, "--------10000000");
8444	>	if (memcmp (a, b, 16) >= 0)
8445	>	exit (1);
8446	>	}
8447	>	exit (0);
8448	>	}
8449	>
8450	>	;
8451	>	return 0;
8452	>	}
8453	>	_ACEOF
8454	>	rm -f conftest$ac_exeext
8455	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8456	>	(eval $ac_link) 2>&5
8457	>	ac_status=$?
8458	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8459	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8460	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8461	>	(eval $ac_try) 2>&5
8462	>	ac_status=$?
8463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8464	>	(exit $ac_status); }; }; then
8465	>	ac_cv_func_memcmp_working=yes
8466	>	else
8467	>	echo "$as_me: program exited with status $ac_status" >&5
8468	>	echo "$as_me: failed program was:" >&5
8469	>	sed 's/^/| /' conftest.$ac_ext >&5
8470	>
8471	>	( exit $ac_status )
8472	>	ac_cv_func_memcmp_working=no
8473	>	fi
8474	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8475	>	fi
8476	>	fi
8477	>	echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8478	>	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8479	>	test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8480	>	"memcmp.$ac_objext"   | \
8481	>	*" memcmp.$ac_objext"   | \
8482	>	"memcmp.$ac_objext "* | \
8483	>	*" memcmp.$ac_objext "* ) ;;
8484	>	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8485	>	esac
8486	>
8487	>
8488	>
8489	>	for ac_header in stdlib.h
8490	>	do
8491	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8492	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8493	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8494	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8495	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8496	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8497	>	fi
8498	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8499	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8500	>	else
8501	>	# Is the header compilable?
8502	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8503	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8504	>	cat >conftest.$ac_ext <<_ACEOF
8505	>	/* confdefs.h.  */
8506	>	_ACEOF
8507	>	cat confdefs.h >>conftest.$ac_ext
8508	>	cat >>conftest.$ac_ext <<_ACEOF
8509	>	/* end confdefs.h.  */
8510	>	$ac_includes_default
8511	>	#include <$ac_header>
8512	>	_ACEOF
8513	>	rm -f conftest.$ac_objext
8514	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8515	>	(eval $ac_compile) 2>conftest.er1
8516	>	ac_status=$?
8517	>	grep -v '^ *+' conftest.er1 >conftest.err
8518	>	rm -f conftest.er1
8519	>	cat conftest.err >&5
8520	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8521	>	(exit $ac_status); } &&
8522	>	{ ac_try='test -z "$ac_c_werror_flag"
8523	>	|| test ! -s conftest.err'
8524	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8525	>	(eval $ac_try) 2>&5
8526	>	ac_status=$?
8527	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8528	>	(exit $ac_status); }; } &&
8529	>	{ ac_try='test -s conftest.$ac_objext'
8530	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8531	>	(eval $ac_try) 2>&5
8532	>	ac_status=$?
8533	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8534	>	(exit $ac_status); }; }; then
8535	>	ac_header_compiler=yes
8536	>	else
8537	>	echo "$as_me: failed program was:" >&5
8538	>	sed 's/^/| /' conftest.$ac_ext >&5
8539	>
8540	>	ac_header_compiler=no
8541	>	fi
8542	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8543	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8544	>	echo "${ECHO_T}$ac_header_compiler" >&6
8545	>
8546	>	# Is the header present?
8547	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8548	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8549	>	cat >conftest.$ac_ext <<_ACEOF
8550	>	/* confdefs.h.  */
8551	>	_ACEOF
8552	>	cat confdefs.h >>conftest.$ac_ext
8553	>	cat >>conftest.$ac_ext <<_ACEOF
8554	>	/* end confdefs.h.  */
8555	>	#include <$ac_header>
8556	>	_ACEOF
8557	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8558	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8559	>	ac_status=$?
8560	>	grep -v '^ *+' conftest.er1 >conftest.err
8561	>	rm -f conftest.er1
8562	>	cat conftest.err >&5
8563	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8564	>	(exit $ac_status); } >/dev/null; then
8565	>	if test -s conftest.err; then
8566	>	ac_cpp_err=$ac_c_preproc_warn_flag
8567	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8568	>	else
8569	>	ac_cpp_err=
8570	>	fi
8571	>	else
8572	>	ac_cpp_err=yes
8573	>	fi
8574	>	if test -z "$ac_cpp_err"; then
8575	>	ac_header_preproc=yes
8576	>	else
8577	>	echo "$as_me: failed program was:" >&5
8578	>	sed 's/^/| /' conftest.$ac_ext >&5
8579	>
8580	>	ac_header_preproc=no
8581	>	fi
8582	>	rm -f conftest.err conftest.$ac_ext
8583	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8584	>	echo "${ECHO_T}$ac_header_preproc" >&6
8585	>
8586	>	# So?  What about this header?
8587	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8588	>	yes:no: )
8589	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8590	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8591	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8592	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8593	>	ac_header_preproc=yes
8594	>	;;
8595	>	no:yes:* )
8596	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8597	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8598	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8599	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8600	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8601	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8602	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8603	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8604	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8605	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8606	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8607	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8608	>	(
8609	>	cat <<\_ASBOX
8610	>	## ------------------------------ ##
8611	>	## Report this to gezelter@nd.edu ##
8612	>	## ------------------------------ ##
8613	>	_ASBOX
8614	>	) |
8615	>	sed "s/^/$as_me: WARNING:     /" >&2
8616	>	;;
8617	>	esac
8618	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8619	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8620	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8621	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8622	>	else
8623	>	eval "$as_ac_Header=\$ac_header_preproc"
8624	>	fi
8625	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8626	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8627	>
8628	>	fi
8629	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8630	>	cat >>confdefs.h <<_ACEOF
8631	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8632	>	_ACEOF
8633	>
8634	>	fi
8635	>
8636	>	done
8637	>
8638	>	echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8639	>	echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8640	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8641	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8642	>	else
8643	>	if test "$cross_compiling" = yes; then
8644	>	ac_cv_func_realloc_0_nonnull=no
8645	>	else
8646	>	cat >conftest.$ac_ext <<_ACEOF
8647	>	/* confdefs.h.  */
8648	>	_ACEOF
8649	>	cat confdefs.h >>conftest.$ac_ext
8650	>	cat >>conftest.$ac_ext <<_ACEOF
8651	>	/* end confdefs.h.  */
8652	>	#if STDC_HEADERS || HAVE_STDLIB_H
8653	>	# include <stdlib.h>
8654	>	#else
8655	>	char *realloc ();
8656	>	#endif
8657	>
8658	>	#ifdef FC_DUMMY_MAIN
8659	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8660	>	#  ifdef __cplusplus
8661	>	extern "C"
8662	>	#  endif
8663	>	int FC_DUMMY_MAIN() { return 1; }
8664	>	#endif
8665	>	#endif
8666	>	int
8667	>	main ()
8668	>	{
8669	>	exit (realloc (0, 0) ? 0 : 1);
8670	>	;
8671	>	return 0;
8672	>	}
8673	>	_ACEOF
8674	>	rm -f conftest$ac_exeext
8675	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8676	>	(eval $ac_link) 2>&5
8677	>	ac_status=$?
8678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8679	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8680	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8681	>	(eval $ac_try) 2>&5
8682	>	ac_status=$?
8683	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8684	>	(exit $ac_status); }; }; then
8685	>	ac_cv_func_realloc_0_nonnull=yes
8686	>	else
8687	>	echo "$as_me: program exited with status $ac_status" >&5
8688	>	echo "$as_me: failed program was:" >&5
8689	>	sed 's/^/| /' conftest.$ac_ext >&5
8690	>
8691	>	( exit $ac_status )
8692	>	ac_cv_func_realloc_0_nonnull=no
8693	>	fi
8694	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8695	>	fi
8696	>	fi
8697	>	echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8698	>	echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8699	>	if test $ac_cv_func_realloc_0_nonnull = yes; then
8700	>
8701	>	cat >>confdefs.h <<\_ACEOF
8702	>	#define HAVE_REALLOC 1
8703	>	_ACEOF
8704	>
8705	>	else
8706	>	cat >>confdefs.h <<\_ACEOF
8707	>	#define HAVE_REALLOC 0
8708	>	_ACEOF
8709	>
8710	>	case $LIBOBJS in
8711	>	"realloc.$ac_objext"   | \
8712	>	*" realloc.$ac_objext"   | \
8713	>	"realloc.$ac_objext "* | \
8714	>	*" realloc.$ac_objext "* ) ;;
8715	>	*) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8716	>	esac
8717	>
8718	>
8719	>	cat >>confdefs.h <<\_ACEOF
8720	>	#define realloc rpl_realloc
8721	>	_ACEOF
8722	>
8723	>	fi
8724	>
8725	>
8726	>
8727	>
8728	>
8729	>	for ac_header in sys/select.h sys/socket.h
8730	>	do
8731	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8732	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8733	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8734	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8735	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8736	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8737	>	fi
8738	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8739	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8740	>	else
8741	>	# Is the header compilable?
8742	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8743	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8744	>	cat >conftest.$ac_ext <<_ACEOF
8745	>	/* confdefs.h.  */
8746	>	_ACEOF
8747	>	cat confdefs.h >>conftest.$ac_ext
8748	>	cat >>conftest.$ac_ext <<_ACEOF
8749	>	/* end confdefs.h.  */
8750	>	$ac_includes_default
8751	>	#include <$ac_header>
8752	>	_ACEOF
8753	>	rm -f conftest.$ac_objext
8754	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8755	>	(eval $ac_compile) 2>conftest.er1
8756	>	ac_status=$?
8757	>	grep -v '^ *+' conftest.er1 >conftest.err
8758	>	rm -f conftest.er1
8759	>	cat conftest.err >&5
8760	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8761	>	(exit $ac_status); } &&
8762	>	{ ac_try='test -z "$ac_c_werror_flag"
8763	>	|| test ! -s conftest.err'
8764	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8765	>	(eval $ac_try) 2>&5
8766	>	ac_status=$?
8767	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8768	>	(exit $ac_status); }; } &&
8769	>	{ ac_try='test -s conftest.$ac_objext'
8770	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8771	>	(eval $ac_try) 2>&5
8772	>	ac_status=$?
8773	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8774	>	(exit $ac_status); }; }; then
8775	>	ac_header_compiler=yes
8776	>	else
8777	>	echo "$as_me: failed program was:" >&5
8778	>	sed 's/^/| /' conftest.$ac_ext >&5
8779	>
8780	>	ac_header_compiler=no
8781	>	fi
8782	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8783	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8784	>	echo "${ECHO_T}$ac_header_compiler" >&6
8785	>
8786	>	# Is the header present?
8787	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8788	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8789	>	cat >conftest.$ac_ext <<_ACEOF
8790	>	/* confdefs.h.  */
8791	>	_ACEOF
8792	>	cat confdefs.h >>conftest.$ac_ext
8793	>	cat >>conftest.$ac_ext <<_ACEOF
8794	>	/* end confdefs.h.  */
8795	>	#include <$ac_header>
8796	>	_ACEOF
8797	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8798	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8799	>	ac_status=$?
8800	>	grep -v '^ *+' conftest.er1 >conftest.err
8801	>	rm -f conftest.er1
8802	>	cat conftest.err >&5
8803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8804	>	(exit $ac_status); } >/dev/null; then
8805	>	if test -s conftest.err; then
8806	>	ac_cpp_err=$ac_c_preproc_warn_flag
8807	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8808	>	else
8809	>	ac_cpp_err=
8810	>	fi
8811	>	else
8812	>	ac_cpp_err=yes
8813	>	fi
8814	>	if test -z "$ac_cpp_err"; then
8815	>	ac_header_preproc=yes
8816	>	else
8817	>	echo "$as_me: failed program was:" >&5
8818	>	sed 's/^/| /' conftest.$ac_ext >&5
8819	>
8820	>	ac_header_preproc=no
8821	>	fi
8822	>	rm -f conftest.err conftest.$ac_ext
8823	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8824	>	echo "${ECHO_T}$ac_header_preproc" >&6
8825	>
8826	>	# So?  What about this header?
8827	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8828	>	yes:no: )
8829	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8830	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8831	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8832	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8833	>	ac_header_preproc=yes
8834	>	;;
8835	>	no:yes:* )
8836	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8837	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8838	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8839	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8840	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8841	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8842	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8843	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8844	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8845	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8846	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8847	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8848	>	(
8849	>	cat <<\_ASBOX
8850	>	## ------------------------------ ##
8851	>	## Report this to gezelter@nd.edu ##
8852	>	## ------------------------------ ##
8853	>	_ASBOX
8854	>	) |
8855	>	sed "s/^/$as_me: WARNING:     /" >&2
8856	>	;;
8857	>	esac
8858	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8859	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8860	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8861	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8862	>	else
8863	>	eval "$as_ac_Header=\$ac_header_preproc"
8864	>	fi
8865	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8866	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8867	>
8868	>	fi
8869	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8870	>	cat >>confdefs.h <<_ACEOF
8871	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8872	>	_ACEOF
8873	>
8874	>	fi
8875	>
8876	>	done
8877	>
8878	>	echo "$as_me:$LINENO: checking types of arguments for select" >&5
8879	>	echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8880	>	if test "${ac_cv_func_select_args+set}" = set; then
8881	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8882	>	else
8883	>	for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8884	>	for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8885	>	for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8886	>	cat >conftest.$ac_ext <<_ACEOF
8887	>	/* confdefs.h.  */
8888	>	_ACEOF
8889	>	cat confdefs.h >>conftest.$ac_ext
8890	>	cat >>conftest.$ac_ext <<_ACEOF
8891	>	/* end confdefs.h.  */
8892	>	$ac_includes_default
8893	>	#if HAVE_SYS_SELECT_H
8894	>	# include <sys/select.h>
8895	>	#endif
8896	>	#if HAVE_SYS_SOCKET_H
8897	>	# include <sys/socket.h>
8898	>	#endif
8899	>
8900	>	#ifdef FC_DUMMY_MAIN
8901	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8902	>	#  ifdef __cplusplus
8903	>	extern "C"
8904	>	#  endif
8905	>	int FC_DUMMY_MAIN() { return 1; }
8906	>	#endif
8907	>	#endif
8908	>	int
8909	>	main ()
8910	>	{
8911	>	extern int select ($ac_arg1,
8912	>	$ac_arg234, $ac_arg234, $ac_arg234,
8913	>	$ac_arg5);
8914	>	;
8915	>	return 0;
8916	>	}
8917	>	_ACEOF
8918	>	rm -f conftest.$ac_objext
8919	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8920	>	(eval $ac_compile) 2>conftest.er1
8921	>	ac_status=$?
8922	>	grep -v '^ *+' conftest.er1 >conftest.err
8923	>	rm -f conftest.er1
8924	>	cat conftest.err >&5
8925	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8926	>	(exit $ac_status); } &&
8927	>	{ ac_try='test -z "$ac_c_werror_flag"
8928	>	|| test ! -s conftest.err'
8929	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8930	>	(eval $ac_try) 2>&5
8931	>	ac_status=$?
8932	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8933	>	(exit $ac_status); }; } &&
8934	>	{ ac_try='test -s conftest.$ac_objext'
8935	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8936	>	(eval $ac_try) 2>&5
8937	>	ac_status=$?
8938	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8939	>	(exit $ac_status); }; }; then
8940	>	ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8941	>	else
8942	>	echo "$as_me: failed program was:" >&5
8943	>	sed 's/^/| /' conftest.$ac_ext >&5
8944	>
8945	>	fi
8946	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8947	>	done
8948	>	done
8949	>	done
8950	>	# Provide a safe default value.
8951	>	: ${ac_cv_func_select_args='int,int *,struct timeval *'}
8952	>
8953	>	fi
8954	>	echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8955	>	echo "${ECHO_T}$ac_cv_func_select_args" >&6
8956	>	ac_save_IFS=$IFS; IFS=','
8957	>	set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8958	>	IFS=$ac_save_IFS
8959	>	shift
8960	>
8961	>	cat >>confdefs.h <<_ACEOF
8962	>	#define SELECT_TYPE_ARG1 $1
8963	>	_ACEOF
8964	>
8965	>
8966	>	cat >>confdefs.h <<_ACEOF
8967	>	#define SELECT_TYPE_ARG234 ($2)
8968	>	_ACEOF
8969	>
8970	>
8971	>	cat >>confdefs.h <<_ACEOF
8972	>	#define SELECT_TYPE_ARG5 ($3)
8973	>	_ACEOF
8974	>
8975	>	rm -f conftest*
8976	>
8977	>
8978	>	for ac_func in strftime
8979	>	do
8980	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8981	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
8982	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8983	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
8984	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8985	>	else
8986	>	cat >conftest.$ac_ext <<_ACEOF
8987	>	/* confdefs.h.  */
8988	>	_ACEOF
8989	>	cat confdefs.h >>conftest.$ac_ext
8990	>	cat >>conftest.$ac_ext <<_ACEOF
8991	>	/* end confdefs.h.  */
8992	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8993	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8994	>	#define $ac_func innocuous_$ac_func
8995	>
8996	>	/* System header to define __stub macros and hopefully few prototypes,
8997	>	which can conflict with char $ac_func (); below.
8998	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8999	>	<limits.h> exists even on freestanding compilers.  */
9000	>
9001	>	#ifdef __STDC__
9002	>	# include <limits.h>
9003	>	#else
9004	>	# include <assert.h>
9005	>	#endif
9006	>
9007	>	#undef $ac_func
9008	>
9009	>	/* Override any gcc2 internal prototype to avoid an error.  */
9010	>	#ifdef __cplusplus
9011	>	extern "C"
9012	>	{
9013	>	#endif
9014	>	/* We use char because int might match the return type of a gcc2
9015	>	builtin and then its argument prototype would still apply.  */
9016	>	char $ac_func ();
9017	>	/* The GNU C library defines this for functions which it implements
9018	>	to always fail with ENOSYS.  Some functions are actually named
9019	>	something starting with __ and the normal name is an alias.  */
9020	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9021	>	choke me
9022	>	#else
9023	>	char (*f) () = $ac_func;
9024	>	#endif
9025	>	#ifdef __cplusplus
9026	>	}
9027	>	#endif
9028	>
9029	>	#ifdef FC_DUMMY_MAIN
9030	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9031	>	#  ifdef __cplusplus
9032	>	extern "C"
9033	>	#  endif
9034	>	int FC_DUMMY_MAIN() { return 1; }
9035	>	#endif
9036	>	#endif
9037	>	int
9038	>	main ()
9039	>	{
9040	>	return f != $ac_func;
9041	>	;
9042	>	return 0;
9043	>	}
9044	>	_ACEOF
9045	>	rm -f conftest.$ac_objext conftest$ac_exeext
9046	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9047	>	(eval $ac_link) 2>conftest.er1
9048	>	ac_status=$?
9049	>	grep -v '^ *+' conftest.er1 >conftest.err
9050	>	rm -f conftest.er1
9051	>	cat conftest.err >&5
9052	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9053	>	(exit $ac_status); } &&
9054	>	{ ac_try='test -z "$ac_c_werror_flag"
9055	>	|| test ! -s conftest.err'
9056	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9057	>	(eval $ac_try) 2>&5
9058	>	ac_status=$?
9059	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9060	>	(exit $ac_status); }; } &&
9061	>	{ ac_try='test -s conftest$ac_exeext'
9062	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9063	>	(eval $ac_try) 2>&5
9064	>	ac_status=$?
9065	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9066	>	(exit $ac_status); }; }; then
9067	>	eval "$as_ac_var=yes"
9068	>	else
9069	>	echo "$as_me: failed program was:" >&5
9070	>	sed 's/^/| /' conftest.$ac_ext >&5
9071	>
9072	>	eval "$as_ac_var=no"
9073	>	fi
9074	>	rm -f conftest.err conftest.$ac_objext \
9075	>	conftest$ac_exeext conftest.$ac_ext
9076	>	fi
9077	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9078	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9079	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9080	>	cat >>confdefs.h <<_ACEOF
9081	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9082	>	_ACEOF
9083	>
9084	>	else
9085	>	# strftime is in -lintl on SCO UNIX.
9086	>	echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9087	>	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9088	>	if test "${ac_cv_lib_intl_strftime+set}" = set; then
9089	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9090	>	else
9091	>	ac_check_lib_save_LIBS=$LIBS
9092	>	LIBS="-lintl  $LIBS"
9093	>	cat >conftest.$ac_ext <<_ACEOF
9094	>	/* confdefs.h.  */
9095	>	_ACEOF
9096	>	cat confdefs.h >>conftest.$ac_ext
9097	>	cat >>conftest.$ac_ext <<_ACEOF
9098	>	/* end confdefs.h.  */
9099	>
9100	>	/* Override any gcc2 internal prototype to avoid an error.  */
9101	>	#ifdef __cplusplus
9102	>	extern "C"
9103	>	#endif
9104	>	/* We use char because int might match the return type of a gcc2
9105	>	builtin and then its argument prototype would still apply.  */
9106	>	char strftime ();
9107	>	#ifdef FC_DUMMY_MAIN
9108	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9109	>	#  ifdef __cplusplus
9110	>	extern "C"
9111	>	#  endif
9112	>	int FC_DUMMY_MAIN() { return 1; }
9113	>	#endif
9114	>	#endif
9115	>	int
9116	>	main ()
9117	>	{
9118	>	strftime ();
9119	>	;
9120	>	return 0;
9121	>	}
9122	>	_ACEOF
9123	>	rm -f conftest.$ac_objext conftest$ac_exeext
9124	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9125	>	(eval $ac_link) 2>conftest.er1
9126	>	ac_status=$?
9127	>	grep -v '^ *+' conftest.er1 >conftest.err
9128	>	rm -f conftest.er1
9129	>	cat conftest.err >&5
9130	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9131	>	(exit $ac_status); } &&
9132	>	{ ac_try='test -z "$ac_c_werror_flag"
9133	>	|| test ! -s conftest.err'
9134	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9135	>	(eval $ac_try) 2>&5
9136	>	ac_status=$?
9137	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9138	>	(exit $ac_status); }; } &&
9139	>	{ ac_try='test -s conftest$ac_exeext'
9140	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9141	>	(eval $ac_try) 2>&5
9142	>	ac_status=$?
9143	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9144	>	(exit $ac_status); }; }; then
9145	>	ac_cv_lib_intl_strftime=yes
9146	>	else
9147	>	echo "$as_me: failed program was:" >&5
9148	>	sed 's/^/| /' conftest.$ac_ext >&5
9149	>
9150	>	ac_cv_lib_intl_strftime=no
9151	>	fi
9152	>	rm -f conftest.err conftest.$ac_objext \
9153	>	conftest$ac_exeext conftest.$ac_ext
9154	>	LIBS=$ac_check_lib_save_LIBS
9155	>	fi
9156	>	echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9157	>	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9158	>	if test $ac_cv_lib_intl_strftime = yes; then
9159	>	cat >>confdefs.h <<\_ACEOF
9160	>	#define HAVE_STRFTIME 1
9161	>	_ACEOF
9162	>
9163	>	LIBS="-lintl $LIBS"
9164	>	fi
9165	>
9166	>	fi
9167	>	done
9168	>
9169	>	echo "$as_me:$LINENO: checking for working strtod" >&5
9170	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9171	>	if test "${ac_cv_func_strtod+set}" = set; then
9172	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9173	>	else
9174	>	if test "$cross_compiling" = yes; then
9175	>	ac_cv_func_strtod=no
9176	>	else
9177	>	cat >conftest.$ac_ext <<_ACEOF
9178	>	/* confdefs.h.  */
9179	>	_ACEOF
9180	>	cat confdefs.h >>conftest.$ac_ext
9181	>	cat >>conftest.$ac_ext <<_ACEOF
9182	>	/* end confdefs.h.  */
9183	>
9184	>	double strtod ();
9185	>	int
9186	>	main()
9187	>	{
9188	>	{
9189	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9190	>	char *string = " +69";
9191	>	char *term;
9192	>	double value;
9193	>	value = strtod (string, &term);
9194	>	if (value != 69 || term != (string + 4))
9195	>	exit (1);
9196	>	}
9197	>
9198	>	{
9199	>	/* Under Solaris 2.4, strtod returns the wrong value for the
9200	>	terminating character under some conditions.  */
9201	>	char *string = "NaN";
9202	>	char *term;
9203	>	strtod (string, &term);
9204	>	if (term != string && *(term - 1) == 0)
9205	>	exit (1);
9206	>	}
9207	>	exit (0);
9208	>	}
9209	>
9210	>	_ACEOF
9211	>	rm -f conftest$ac_exeext
9212	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9213	>	(eval $ac_link) 2>&5
9214	>	ac_status=$?
9215	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9216	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9217	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9218	>	(eval $ac_try) 2>&5
9219	>	ac_status=$?
9220	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9221	>	(exit $ac_status); }; }; then
9222	>	ac_cv_func_strtod=yes
9223	>	else
9224	>	echo "$as_me: program exited with status $ac_status" >&5
9225	>	echo "$as_me: failed program was:" >&5
9226	>	sed 's/^/| /' conftest.$ac_ext >&5
9227	>
9228	>	( exit $ac_status )
9229	>	ac_cv_func_strtod=no
9230	>	fi
9231	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9232	>	fi
9233	>	fi
9234	>	echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9235	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6
9236	>	if test $ac_cv_func_strtod = no; then
9237	>	case $LIBOBJS in
9238	>	"strtod.$ac_objext"   | \
9239	>	*" strtod.$ac_objext"   | \
9240	>	"strtod.$ac_objext "* | \
9241	>	*" strtod.$ac_objext "* ) ;;
9242	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9243	>	esac
9244	>
9245	>	echo "$as_me:$LINENO: checking for pow" >&5
9246	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6
9247	>	if test "${ac_cv_func_pow+set}" = set; then
9248	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9249	>	else
9250	>	cat >conftest.$ac_ext <<_ACEOF
9251	>	/* confdefs.h.  */
9252	>	_ACEOF
9253	>	cat confdefs.h >>conftest.$ac_ext
9254	>	cat >>conftest.$ac_ext <<_ACEOF
9255	>	/* end confdefs.h.  */
9256	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
9257	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9258	>	#define pow innocuous_pow
9259	>
9260	>	/* System header to define __stub macros and hopefully few prototypes,
9261	>	which can conflict with char pow (); below.
9262	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9263	>	<limits.h> exists even on freestanding compilers.  */
9264	>
9265	>	#ifdef __STDC__
9266	>	# include <limits.h>
9267	>	#else
9268	>	# include <assert.h>
9269	>	#endif
9270	>
9271	>	#undef pow
9272	>
9273	>	/* Override any gcc2 internal prototype to avoid an error.  */
9274	>	#ifdef __cplusplus
9275	>	extern "C"
9276	>	{
9277	>	#endif
9278	>	/* We use char because int might match the return type of a gcc2
9279	>	builtin and then its argument prototype would still apply.  */
9280	>	char pow ();
9281	>	/* The GNU C library defines this for functions which it implements
9282	>	to always fail with ENOSYS.  Some functions are actually named
9283	>	something starting with __ and the normal name is an alias.  */
9284	>	#if defined (__stub_pow) || defined (__stub___pow)
9285	>	choke me
9286	>	#else
9287	>	char (*f) () = pow;
9288	>	#endif
9289	>	#ifdef __cplusplus
9290	>	}
9291	>	#endif
9292	>
9293	>	#ifdef FC_DUMMY_MAIN
9294	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9295	>	#  ifdef __cplusplus
9296	>	extern "C"
9297	>	#  endif
9298	>	int FC_DUMMY_MAIN() { return 1; }
9299	>	#endif
9300	>	#endif
9301	>	int
9302	>	main ()
9303	>	{
9304	>	return f != pow;
9305	>	;
9306	>	return 0;
9307	>	}
9308	>	_ACEOF
9309	>	rm -f conftest.$ac_objext conftest$ac_exeext
9310	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9311	>	(eval $ac_link) 2>conftest.er1
9312	>	ac_status=$?
9313	>	grep -v '^ *+' conftest.er1 >conftest.err
9314	>	rm -f conftest.er1
9315	>	cat conftest.err >&5
9316	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9317	>	(exit $ac_status); } &&
9318	>	{ ac_try='test -z "$ac_c_werror_flag"
9319	>	|| test ! -s conftest.err'
9320	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9321	>	(eval $ac_try) 2>&5
9322	>	ac_status=$?
9323	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9324	>	(exit $ac_status); }; } &&
9325	>	{ ac_try='test -s conftest$ac_exeext'
9326	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9327	>	(eval $ac_try) 2>&5
9328	>	ac_status=$?
9329	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330	>	(exit $ac_status); }; }; then
9331	>	ac_cv_func_pow=yes
9332	>	else
9333	>	echo "$as_me: failed program was:" >&5
9334	>	sed 's/^/| /' conftest.$ac_ext >&5
9335	>
9336	>	ac_cv_func_pow=no
9337	>	fi
9338	>	rm -f conftest.err conftest.$ac_objext \
9339	>	conftest$ac_exeext conftest.$ac_ext
9340	>	fi
9341	>	echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9342	>	echo "${ECHO_T}$ac_cv_func_pow" >&6
9343	>
9344	>	if test $ac_cv_func_pow = no; then
9345	>	echo "$as_me:$LINENO: checking for pow in -lm" >&5
9346	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9347	>	if test "${ac_cv_lib_m_pow+set}" = set; then
9348	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9349	>	else
9350	>	ac_check_lib_save_LIBS=$LIBS
9351	>	LIBS="-lm  $LIBS"
9352	>	cat >conftest.$ac_ext <<_ACEOF
9353	>	/* confdefs.h.  */
9354	>	_ACEOF
9355	>	cat confdefs.h >>conftest.$ac_ext
9356	>	cat >>conftest.$ac_ext <<_ACEOF
9357	>	/* end confdefs.h.  */
9358	>
9359	>	/* Override any gcc2 internal prototype to avoid an error.  */
9360	>	#ifdef __cplusplus
9361	>	extern "C"
9362	>	#endif
9363	>	/* We use char because int might match the return type of a gcc2
9364	>	builtin and then its argument prototype would still apply.  */
9365	>	char pow ();
9366	>	#ifdef FC_DUMMY_MAIN
9367	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9368	>	#  ifdef __cplusplus
9369	>	extern "C"
9370	>	#  endif
9371	>	int FC_DUMMY_MAIN() { return 1; }
9372	>	#endif
9373	>	#endif
9374	>	int
9375	>	main ()
9376	>	{
9377	>	pow ();
9378	>	;
9379	>	return 0;
9380	>	}
9381	>	_ACEOF
9382	>	rm -f conftest.$ac_objext conftest$ac_exeext
9383	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9384	>	(eval $ac_link) 2>conftest.er1
9385	>	ac_status=$?
9386	>	grep -v '^ *+' conftest.er1 >conftest.err
9387	>	rm -f conftest.er1
9388	>	cat conftest.err >&5
9389	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9390	>	(exit $ac_status); } &&
9391	>	{ ac_try='test -z "$ac_c_werror_flag"
9392	>	|| test ! -s conftest.err'
9393	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9394	>	(eval $ac_try) 2>&5
9395	>	ac_status=$?
9396	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9397	>	(exit $ac_status); }; } &&
9398	>	{ ac_try='test -s conftest$ac_exeext'
9399	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9400	>	(eval $ac_try) 2>&5
9401	>	ac_status=$?
9402	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9403	>	(exit $ac_status); }; }; then
9404	>	ac_cv_lib_m_pow=yes
9405	>	else
9406	>	echo "$as_me: failed program was:" >&5
9407	>	sed 's/^/| /' conftest.$ac_ext >&5
9408	>
9409	>	ac_cv_lib_m_pow=no
9410	>	fi
9411	>	rm -f conftest.err conftest.$ac_objext \
9412	>	conftest$ac_exeext conftest.$ac_ext
9413	>	LIBS=$ac_check_lib_save_LIBS
9414	>	fi
9415	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9416	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9417	>	if test $ac_cv_lib_m_pow = yes; then
9418	>	POW_LIB=-lm
9419	>	else
9420	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9421	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9422	>	fi
9423	>
9424	>	fi
9425	>
9426	>	fi
9427	>
9428	>
9429	>
9430	>
9431	>
9432	>
9433	>
9434	>
9435	>
9436	>
9437	>
9438	>
9439	>
9440	>
9441	>
9442	>
9443	>
9444	>
9445	>
9446	>
9447	>
9448	>
9449	>
9450	>
9451	>
9452	>
9453	>
9454	>
9455	>	for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9456	>	do
9457	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9458	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9459	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9460	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9461	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9462	>	else
9463	>	cat >conftest.$ac_ext <<_ACEOF
9464	>	/* confdefs.h.  */
9465	>	_ACEOF
9466	>	cat confdefs.h >>conftest.$ac_ext
9467	>	cat >>conftest.$ac_ext <<_ACEOF
9468	>	/* end confdefs.h.  */
9469	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9470	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9471	>	#define $ac_func innocuous_$ac_func
9472	>
9473	>	/* System header to define __stub macros and hopefully few prototypes,
9474	>	which can conflict with char $ac_func (); below.
9475	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9476	>	<limits.h> exists even on freestanding compilers.  */
9477	>
9478	>	#ifdef __STDC__
9479	>	# include <limits.h>
9480	>	#else
9481	>	# include <assert.h>
9482	>	#endif
9483	>
9484	>	#undef $ac_func
9485	>
9486	>	/* Override any gcc2 internal prototype to avoid an error.  */
9487	>	#ifdef __cplusplus
9488	>	extern "C"
9489	>	{
9490	>	#endif
9491	>	/* We use char because int might match the return type of a gcc2
9492	>	builtin and then its argument prototype would still apply.  */
9493	>	char $ac_func ();
9494	>	/* The GNU C library defines this for functions which it implements
9495	>	to always fail with ENOSYS.  Some functions are actually named
9496	>	something starting with __ and the normal name is an alias.  */
9497	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9498	>	choke me
9499	>	#else
9500	>	char (*f) () = $ac_func;
9501	>	#endif
9502	>	#ifdef __cplusplus
9503	>	}
9504	>	#endif
9505	>
9506	>	#ifdef FC_DUMMY_MAIN
9507	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9508	>	#  ifdef __cplusplus
9509	>	extern "C"
9510	>	#  endif
9511	>	int FC_DUMMY_MAIN() { return 1; }
9512	>	#endif
9513	>	#endif
9514	>	int
9515	>	main ()
9516	>	{
9517	>	return f != $ac_func;
9518	>	;
9519	>	return 0;
9520	>	}
9521	>	_ACEOF
9522	>	rm -f conftest.$ac_objext conftest$ac_exeext
9523	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9524	>	(eval $ac_link) 2>conftest.er1
9525	>	ac_status=$?
9526	>	grep -v '^ *+' conftest.er1 >conftest.err
9527	>	rm -f conftest.er1
9528	>	cat conftest.err >&5
9529	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9530	>	(exit $ac_status); } &&
9531	>	{ ac_try='test -z "$ac_c_werror_flag"
9532	>	|| test ! -s conftest.err'
9533	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9534	>	(eval $ac_try) 2>&5
9535	>	ac_status=$?
9536	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537	>	(exit $ac_status); }; } &&
9538	>	{ ac_try='test -s conftest$ac_exeext'
9539	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9540	>	(eval $ac_try) 2>&5
9541	>	ac_status=$?
9542	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543	>	(exit $ac_status); }; }; then
9544	>	eval "$as_ac_var=yes"
9545	>	else
9546	>	echo "$as_me: failed program was:" >&5
9547	>	sed 's/^/| /' conftest.$ac_ext >&5
9548	>
9549	>	eval "$as_ac_var=no"
9550	>	fi
9551	>	rm -f conftest.err conftest.$ac_objext \
9552	>	conftest$ac_exeext conftest.$ac_ext
9553	>	fi
9554	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9555	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9556	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9557	>	cat >>confdefs.h <<_ACEOF
9558	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9559	>	_ACEOF
9560	>
9561	>	fi
9562	>	done
9563	>
9564	>
9565	>	# special check for _system_configuration because AIX <4.3.2 do not
9566	>	# contain the `physmem' member.
9567	>	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9568	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9569	>	cat >conftest.$ac_ext <<_ACEOF
9570	>	/* confdefs.h.  */
9571	>	_ACEOF
9572	>	cat confdefs.h >>conftest.$ac_ext
9573	>	cat >>conftest.$ac_ext <<_ACEOF
9574	>	/* end confdefs.h.  */
9575	>	#include <sys/systemcfg.h>
9576	>	#ifdef FC_DUMMY_MAIN
9577	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9578	>	#  ifdef __cplusplus
9579	>	extern "C"
9580	>	#  endif
9581	>	int FC_DUMMY_MAIN() { return 1; }
9582	>	#endif
9583	>	#endif
9584	>	int
9585	>	main ()
9586	>	{
9587	>	double x = _system_configuration.physmem;
9588	>	;
9589	>	return 0;
9590	>	}
9591	>	_ACEOF
9592	>	rm -f conftest.$ac_objext
9593	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9594	>	(eval $ac_compile) 2>conftest.er1
9595	>	ac_status=$?
9596	>	grep -v '^ *+' conftest.er1 >conftest.err
9597	>	rm -f conftest.er1
9598	>	cat conftest.err >&5
9599	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9600	>	(exit $ac_status); } &&
9601	>	{ ac_try='test -z "$ac_c_werror_flag"
9602	>	|| test ! -s conftest.err'
9603	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9604	>	(eval $ac_try) 2>&5
9605	>	ac_status=$?
9606	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9607	>	(exit $ac_status); }; } &&
9608	>	{ ac_try='test -s conftest.$ac_objext'
9609	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9610	>	(eval $ac_try) 2>&5
9611	>	ac_status=$?
9612	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9613	>	(exit $ac_status); }; }; then
9614	>	echo "$as_me:$LINENO: result: yes" >&5
9615	>	echo "${ECHO_T}yes" >&6
9616	>
9617	>	cat >>confdefs.h <<\_ACEOF
9618	>	#define HAVE__SYSTEM_CONFIGURATION 1
9619	>	_ACEOF
9620	>
9621	>	else
9622	>	echo "$as_me: failed program was:" >&5
9623	>	sed 's/^/| /' conftest.$ac_ext >&5
9624	>
9625	>	echo "$as_me:$LINENO: result: no" >&5
9626	>	echo "${ECHO_T}no" >&6
9627	>	fi
9628	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9629	>
9630	>	# clean out junk possibly left behind by a previous configuration
9631	>	rm -f src/getopt.h
9632	>	# Check for getopt_long support
9633	>
9634	>	for ac_header in getopt.h
9635	>	do
9636	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9637	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9638	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9639	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9640	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9641	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9642	>	fi
9643	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9644	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9645	>	else
9646	>	# Is the header compilable?
9647	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
9648	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9649	>	cat >conftest.$ac_ext <<_ACEOF
9650	>	/* confdefs.h.  */
9651	>	_ACEOF
9652	>	cat confdefs.h >>conftest.$ac_ext
9653	>	cat >>conftest.$ac_ext <<_ACEOF
9654	>	/* end confdefs.h.  */
9655	>	$ac_includes_default
9656	>	#include <$ac_header>
9657	>	_ACEOF
9658	>	rm -f conftest.$ac_objext
9659	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9660	>	(eval $ac_compile) 2>conftest.er1
9661	>	ac_status=$?
9662	>	grep -v '^ *+' conftest.er1 >conftest.err
9663	>	rm -f conftest.er1
9664	>	cat conftest.err >&5
9665	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9666	>	(exit $ac_status); } &&
9667	>	{ ac_try='test -z "$ac_c_werror_flag"
9668	>	|| test ! -s conftest.err'
9669	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9670	>	(eval $ac_try) 2>&5
9671	>	ac_status=$?
9672	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9673	>	(exit $ac_status); }; } &&
9674	>	{ ac_try='test -s conftest.$ac_objext'
9675	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9676	>	(eval $ac_try) 2>&5
9677	>	ac_status=$?
9678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9679	>	(exit $ac_status); }; }; then
9680	>	ac_header_compiler=yes
9681	>	else
9682	>	echo "$as_me: failed program was:" >&5
9683	>	sed 's/^/| /' conftest.$ac_ext >&5
9684	>
9685	>	ac_header_compiler=no
9686	>	fi
9687	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9688	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9689	>	echo "${ECHO_T}$ac_header_compiler" >&6
9690	>
9691	>	# Is the header present?
9692	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9693	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9694	>	cat >conftest.$ac_ext <<_ACEOF
9695	>	/* confdefs.h.  */
9696	>	_ACEOF
9697	>	cat confdefs.h >>conftest.$ac_ext
9698	>	cat >>conftest.$ac_ext <<_ACEOF
9699	>	/* end confdefs.h.  */
9700	>	#include <$ac_header>
9701	>	_ACEOF
9702	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9703	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9704	>	ac_status=$?
9705	>	grep -v '^ *+' conftest.er1 >conftest.err
9706	>	rm -f conftest.er1
9707	>	cat conftest.err >&5
9708	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9709	>	(exit $ac_status); } >/dev/null; then
9710	>	if test -s conftest.err; then
9711	>	ac_cpp_err=$ac_c_preproc_warn_flag
9712	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9713	>	else
9714	>	ac_cpp_err=
9715	>	fi
9716	>	else
9717	>	ac_cpp_err=yes
9718	>	fi
9719	>	if test -z "$ac_cpp_err"; then
9720	>	ac_header_preproc=yes
9721	>	else
9722	>	echo "$as_me: failed program was:" >&5
9723	>	sed 's/^/| /' conftest.$ac_ext >&5
9724	>
9725	>	ac_header_preproc=no
9726	>	fi
9727	>	rm -f conftest.err conftest.$ac_ext
9728	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9729	>	echo "${ECHO_T}$ac_header_preproc" >&6
9730	>
9731	>	# So?  What about this header?
9732	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9733	>	yes:no: )
9734	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9735	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9736	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9737	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9738	>	ac_header_preproc=yes
9739	>	;;
9740	>	no:yes:* )
9741	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9742	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9743	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9744	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9745	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9746	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9747	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9748	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9749	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9750	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9751	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9752	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9753	>	(
9754	>	cat <<\_ASBOX
9755	>	## ------------------------------ ##
9756	>	## Report this to gezelter@nd.edu ##
9757	>	## ------------------------------ ##
9758	>	_ASBOX
9759	>	) |
9760	>	sed "s/^/$as_me: WARNING:     /" >&2
9761	>	;;
9762	>	esac
9763	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9764	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9765	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9766	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9767	>	else
9768	>	eval "$as_ac_Header=\$ac_header_preproc"
9769	>	fi
9770	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9771	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9772	>
9773	>	fi
9774	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
9775	>	cat >>confdefs.h <<_ACEOF
9776	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9777	>	_ACEOF
9778	>
9779	>	fi
9780	>
9781	>	done
9782	>
9783	>
9784	>	for ac_func in getopt_long
9785	>	do
9786	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9787	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9788	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9789	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9790	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9791	>	else
9792	>	cat >conftest.$ac_ext <<_ACEOF
9793	>	/* confdefs.h.  */
9794	>	_ACEOF
9795	>	cat confdefs.h >>conftest.$ac_ext
9796	>	cat >>conftest.$ac_ext <<_ACEOF
9797	>	/* end confdefs.h.  */
9798	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9799	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9800	>	#define $ac_func innocuous_$ac_func
9801	>
9802	>	/* System header to define __stub macros and hopefully few prototypes,
9803	>	which can conflict with char $ac_func (); below.
9804	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9805	>	<limits.h> exists even on freestanding compilers.  */
9806	>
9807	>	#ifdef __STDC__
9808	>	# include <limits.h>
9809	>	#else
9810	>	# include <assert.h>
9811	>	#endif
9812	>
9813	>	#undef $ac_func
9814	>
9815	>	/* Override any gcc2 internal prototype to avoid an error.  */
9816	>	#ifdef __cplusplus
9817	>	extern "C"
9818	>	{
9819	>	#endif
9820	>	/* We use char because int might match the return type of a gcc2
9821	>	builtin and then its argument prototype would still apply.  */
9822	>	char $ac_func ();
9823	>	/* The GNU C library defines this for functions which it implements
9824	>	to always fail with ENOSYS.  Some functions are actually named
9825	>	something starting with __ and the normal name is an alias.  */
9826	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9827	>	choke me
9828	>	#else
9829	>	char (*f) () = $ac_func;
9830	>	#endif
9831	>	#ifdef __cplusplus
9832	>	}
9833	>	#endif
9834	>
9835	>	#ifdef FC_DUMMY_MAIN
9836	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9837	>	#  ifdef __cplusplus
9838	>	extern "C"
9839	>	#  endif
9840	>	int FC_DUMMY_MAIN() { return 1; }
9841	>	#endif
9842	>	#endif
9843	>	int
9844	>	main ()
9845	>	{
9846	>	return f != $ac_func;
9847	>	;
9848	>	return 0;
9849	>	}
9850	>	_ACEOF
9851	>	rm -f conftest.$ac_objext conftest$ac_exeext
9852	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9853	>	(eval $ac_link) 2>conftest.er1
9854	>	ac_status=$?
9855	>	grep -v '^ *+' conftest.er1 >conftest.err
9856	>	rm -f conftest.er1
9857	>	cat conftest.err >&5
9858	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9859	>	(exit $ac_status); } &&
9860	>	{ ac_try='test -z "$ac_c_werror_flag"
9861	>	|| test ! -s conftest.err'
9862	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9863	>	(eval $ac_try) 2>&5
9864	>	ac_status=$?
9865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866	>	(exit $ac_status); }; } &&
9867	>	{ ac_try='test -s conftest$ac_exeext'
9868	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9869	>	(eval $ac_try) 2>&5
9870	>	ac_status=$?
9871	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9872	>	(exit $ac_status); }; }; then
9873	>	eval "$as_ac_var=yes"
9874	>	else
9875	>	echo "$as_me: failed program was:" >&5
9876	>	sed 's/^/| /' conftest.$ac_ext >&5
9877	>
9878	>	eval "$as_ac_var=no"
9879	>	fi
9880	>	rm -f conftest.err conftest.$ac_objext \
9881	>	conftest$ac_exeext conftest.$ac_ext
9882	>	fi
9883	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9884	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9885	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9886	>	cat >>confdefs.h <<_ACEOF
9887	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9888	>	_ACEOF
9889	>
9890	>	else
9891	>	# FreeBSD has a gnugetopt library for this
9892	>	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9893	>	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9894	>	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9895	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9896	>	else
9897	>	ac_check_lib_save_LIBS=$LIBS
9898	>	LIBS="-lgnugetopt  $LIBS"
9899	>	cat >conftest.$ac_ext <<_ACEOF
9900	>	/* confdefs.h.  */
9901	>	_ACEOF
9902	>	cat confdefs.h >>conftest.$ac_ext
9903	>	cat >>conftest.$ac_ext <<_ACEOF
9904	>	/* end confdefs.h.  */
9905	>
9906	>	/* Override any gcc2 internal prototype to avoid an error.  */
9907	>	#ifdef __cplusplus
9908	>	extern "C"
9909	>	#endif
9910	>	/* We use char because int might match the return type of a gcc2
9911	>	builtin and then its argument prototype would still apply.  */
9912	>	char getopt_long ();
9913	>	#ifdef FC_DUMMY_MAIN
9914	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9915	>	#  ifdef __cplusplus
9916	>	extern "C"
9917	>	#  endif
9918	>	int FC_DUMMY_MAIN() { return 1; }
9919	>	#endif
9920	>	#endif
9921	>	int
9922	>	main ()
9923	>	{
9924	>	getopt_long ();
9925	>	;
9926	>	return 0;
9927	>	}
9928	>	_ACEOF
9929	>	rm -f conftest.$ac_objext conftest$ac_exeext
9930	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9931	>	(eval $ac_link) 2>conftest.er1
9932	>	ac_status=$?
9933	>	grep -v '^ *+' conftest.er1 >conftest.err
9934	>	rm -f conftest.er1
9935	>	cat conftest.err >&5
9936	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9937	>	(exit $ac_status); } &&
9938	>	{ ac_try='test -z "$ac_c_werror_flag"
9939	>	|| test ! -s conftest.err'
9940	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9941	>	(eval $ac_try) 2>&5
9942	>	ac_status=$?
9943	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9944	>	(exit $ac_status); }; } &&
9945	>	{ ac_try='test -s conftest$ac_exeext'
9946	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9947	>	(eval $ac_try) 2>&5
9948	>	ac_status=$?
9949	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9950	>	(exit $ac_status); }; }; then
9951	>	ac_cv_lib_gnugetopt_getopt_long=yes
9952	>	else
9953	>	echo "$as_me: failed program was:" >&5
9954	>	sed 's/^/| /' conftest.$ac_ext >&5
9955	>
9956	>	ac_cv_lib_gnugetopt_getopt_long=no
9957	>	fi
9958	>	rm -f conftest.err conftest.$ac_objext \
9959	>	conftest$ac_exeext conftest.$ac_ext
9960	>	LIBS=$ac_check_lib_save_LIBS
9961	>	fi
9962	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9963	>	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9964	>	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9965	>	cat >>confdefs.h <<\_ACEOF
9966	>	#define HAVE_GETOPT_LONG 1
9967	>	_ACEOF
9968	>
9969	>	else
9970	>	# use the GNU replacement
9971	>	case $LIBOBJS in
9972	>	"getopt.$ac_objext"   | \
9973	>	*" getopt.$ac_objext"   | \
9974	>	"getopt.$ac_objext "* | \
9975	>	*" getopt.$ac_objext "* ) ;;
9976	>	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9977	>	esac
9978	>
9979	>	case $LIBOBJS in
9980	>	"getopt1.$ac_objext"   | \
9981	>	*" getopt1.$ac_objext"   | \
9982	>	"getopt1.$ac_objext "* | \
9983	>	*" getopt1.$ac_objext "* ) ;;
9984	>	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9985	>	esac
9986	>
9987	>	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9988	>
9989	>	fi
9990	>
9991	>	fi
9992	>	done
9993	>
9994	>
9995	>	ac_ext=cc
9996	>	ac_cpp='$CXXCPP $CPPFLAGS'
9997	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9998	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9999	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10000	>
10001	>
10002	>	echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10003	>	echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10004	>	if test "${ac_cv_cxx_namespaces+set}" = set; then
10005	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10006	>	else
10007	>
10008	>
10009	>	ac_ext=cc
10010	>	ac_cpp='$CXXCPP $CPPFLAGS'
10011	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10012	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10013	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10014	>
10015	>	cat >conftest.$ac_ext <<_ACEOF
10016	>	/* confdefs.h.  */
10017	>	_ACEOF
10018	>	cat confdefs.h >>conftest.$ac_ext
10019	>	cat >>conftest.$ac_ext <<_ACEOF
10020	>	/* end confdefs.h.  */
10021	>	namespace Outer { namespace Inner { int i = 0; }}
10022	>	#ifdef FC_DUMMY_MAIN
10023	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10024	>	#  ifdef __cplusplus
10025	>	extern "C"
10026	>	#  endif
10027	>	int FC_DUMMY_MAIN() { return 1; }
10028	>	#endif
10029	>	#endif
10030	>	int
10031	>	main ()
10032	>	{
10033	>	using namespace Outer::Inner; return i;
10034	>	;
10035	>	return 0;
10036	>	}
10037	>	_ACEOF
10038	>	rm -f conftest.$ac_objext
10039	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10040	>	(eval $ac_compile) 2>conftest.er1
10041	>	ac_status=$?
10042	>	grep -v '^ *+' conftest.er1 >conftest.err
10043	>	rm -f conftest.er1
10044	>	cat conftest.err >&5
10045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10046	>	(exit $ac_status); } &&
10047	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10048	>	|| test ! -s conftest.err'
10049	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10050	>	(eval $ac_try) 2>&5
10051	>	ac_status=$?
10052	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10053	>	(exit $ac_status); }; } &&
10054	>	{ ac_try='test -s conftest.$ac_objext'
10055	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10056	>	(eval $ac_try) 2>&5
10057	>	ac_status=$?
10058	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10059	>	(exit $ac_status); }; }; then
10060	>	ac_cv_cxx_namespaces=yes
10061	>	else
10062	>	echo "$as_me: failed program was:" >&5
10063	>	sed 's/^/| /' conftest.$ac_ext >&5
10064	>
10065	>	ac_cv_cxx_namespaces=no
10066	>	fi
10067	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10068	>	ac_ext=cc
10069	>	ac_cpp='$CXXCPP $CPPFLAGS'
10070	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10071	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10072	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10073	>
10074	>
10075	>	fi
10076	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10077	>	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10078	>	if test "$ac_cv_cxx_namespaces" = yes; then
10079	>
10080	>	cat >>confdefs.h <<\_ACEOF
10081	>	#define HAVE_NAMESPACES
10082	>	_ACEOF
10083	>
10084	>	fi
10085	>
10086	>	ac_ext=cc
10087	>	ac_cpp='$CXXCPP $CPPFLAGS'
10088	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10089	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10090	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10091	>	echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10092	>	echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10093	>	if test -z "$CXXCPP"; then
10094	>	if test "${ac_cv_prog_CXXCPP+set}" = set; then
10095	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10096	>	else
10097	>	# Double quotes because CXXCPP needs to be expanded
10098	>	for CXXCPP in "$CXX -E" "/lib/cpp"
10099	>	do
10100	>	ac_preproc_ok=false
10101	>	for ac_cxx_preproc_warn_flag in '' yes
10102	>	do
10103	>	# Use a header file that comes with gcc, so configuring glibc
10104	>	# with a fresh cross-compiler works.
10105	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10106	>	# <limits.h> exists even on freestanding compilers.
10107	>	# On the NeXT, cc -E runs the code through the compiler's parser,
10108	>	# not just through cpp. "Syntax error" is here to catch this case.
10109	>	cat >conftest.$ac_ext <<_ACEOF
10110	>	/* confdefs.h.  */
10111	>	_ACEOF
10112	>	cat confdefs.h >>conftest.$ac_ext
10113	>	cat >>conftest.$ac_ext <<_ACEOF
10114	>	/* end confdefs.h.  */
10115	>	#ifdef __STDC__
10116	>	# include <limits.h>
10117	>	#else
10118	>	# include <assert.h>
10119	>	#endif
10120	>	Syntax error
10121	>	_ACEOF
10122	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10123	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10124	>	ac_status=$?
10125	>	grep -v '^ *+' conftest.er1 >conftest.err
10126	>	rm -f conftest.er1
10127	>	cat conftest.err >&5
10128	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10129	>	(exit $ac_status); } >/dev/null; then
10130	>	if test -s conftest.err; then
10131	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10132	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10133	>	else
10134	>	ac_cpp_err=
10135	>	fi
10136	>	else
10137	>	ac_cpp_err=yes
10138	>	fi
10139	>	if test -z "$ac_cpp_err"; then
10140	>	:
10141	>	else
10142	>	echo "$as_me: failed program was:" >&5
10143	>	sed 's/^/| /' conftest.$ac_ext >&5
10144	>
10145	>	# Broken: fails on valid input.
10146	>	continue
10147	>	fi
10148	>	rm -f conftest.err conftest.$ac_ext
10149	>
10150	>	# OK, works on sane cases.  Now check whether non-existent headers
10151	>	# can be detected and how.
10152	>	cat >conftest.$ac_ext <<_ACEOF
10153	>	/* confdefs.h.  */
10154	>	_ACEOF
10155	>	cat confdefs.h >>conftest.$ac_ext
10156	>	cat >>conftest.$ac_ext <<_ACEOF
10157	>	/* end confdefs.h.  */
10158	>	#include <ac_nonexistent.h>
10159	>	_ACEOF
10160	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10161	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10162	>	ac_status=$?
10163	>	grep -v '^ *+' conftest.er1 >conftest.err
10164	>	rm -f conftest.er1
10165	>	cat conftest.err >&5
10166	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10167	>	(exit $ac_status); } >/dev/null; then
10168	>	if test -s conftest.err; then
10169	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10170	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10171	>	else
10172	>	ac_cpp_err=
10173	>	fi
10174	>	else
10175	>	ac_cpp_err=yes
10176	>	fi
10177	>	if test -z "$ac_cpp_err"; then
10178	>	# Broken: success on invalid input.
10179	>	continue
10180	>	else
10181	>	echo "$as_me: failed program was:" >&5
10182	>	sed 's/^/| /' conftest.$ac_ext >&5
10183	>
10184	>	# Passes both tests.
10185	>	ac_preproc_ok=:
10186	>	break
10187	>	fi
10188	>	rm -f conftest.err conftest.$ac_ext
10189	>
10190	>	done
10191	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10192	>	rm -f conftest.err conftest.$ac_ext
10193	>	if $ac_preproc_ok; then
10194	>	break
10195	>	fi
10196	>
10197	>	done
10198	>	ac_cv_prog_CXXCPP=$CXXCPP
10199	>
10200	>	fi
10201	>	CXXCPP=$ac_cv_prog_CXXCPP
10202	>	else
10203	>	ac_cv_prog_CXXCPP=$CXXCPP
10204	>	fi
10205	>	echo "$as_me:$LINENO: result: $CXXCPP" >&5
10206	>	echo "${ECHO_T}$CXXCPP" >&6
10207	>	ac_preproc_ok=false
10208	>	for ac_cxx_preproc_warn_flag in '' yes
10209	>	do
10210	>	# Use a header file that comes with gcc, so configuring glibc
10211	>	# with a fresh cross-compiler works.
10212	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10213	>	# <limits.h> exists even on freestanding compilers.
10214	>	# On the NeXT, cc -E runs the code through the compiler's parser,
10215	>	# not just through cpp. "Syntax error" is here to catch this case.
10216	>	cat >conftest.$ac_ext <<_ACEOF
10217	>	/* confdefs.h.  */
10218	>	_ACEOF
10219	>	cat confdefs.h >>conftest.$ac_ext
10220	>	cat >>conftest.$ac_ext <<_ACEOF
10221	>	/* end confdefs.h.  */
10222	>	#ifdef __STDC__
10223	>	# include <limits.h>
10224	>	#else
10225	>	# include <assert.h>
10226	>	#endif
10227	>	Syntax error
10228	>	_ACEOF
10229	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10230	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10231	>	ac_status=$?
10232	>	grep -v '^ *+' conftest.er1 >conftest.err
10233	>	rm -f conftest.er1
10234	>	cat conftest.err >&5
10235	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10236	>	(exit $ac_status); } >/dev/null; then
10237	>	if test -s conftest.err; then
10238	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10239	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10240	>	else
10241	>	ac_cpp_err=
10242	>	fi
10243	>	else
10244	>	ac_cpp_err=yes
10245	>	fi
10246	>	if test -z "$ac_cpp_err"; then
10247	>	:
10248	>	else
10249	>	echo "$as_me: failed program was:" >&5
10250	>	sed 's/^/| /' conftest.$ac_ext >&5
10251	>
10252	>	# Broken: fails on valid input.
10253	>	continue
10254	>	fi
10255	>	rm -f conftest.err conftest.$ac_ext
10256	>
10257	>	# OK, works on sane cases.  Now check whether non-existent headers
10258	>	# can be detected and how.
10259	>	cat >conftest.$ac_ext <<_ACEOF
10260	>	/* confdefs.h.  */
10261	>	_ACEOF
10262	>	cat confdefs.h >>conftest.$ac_ext
10263	>	cat >>conftest.$ac_ext <<_ACEOF
10264	>	/* end confdefs.h.  */
10265	>	#include <ac_nonexistent.h>
10266	>	_ACEOF
10267	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10268	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10269	>	ac_status=$?
10270	>	grep -v '^ *+' conftest.er1 >conftest.err
10271	>	rm -f conftest.er1
10272	>	cat conftest.err >&5
10273	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10274	>	(exit $ac_status); } >/dev/null; then
10275	>	if test -s conftest.err; then
10276	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10277	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10278	>	else
10279	>	ac_cpp_err=
10280	>	fi
10281	>	else
10282	>	ac_cpp_err=yes
10283	>	fi
10284	>	if test -z "$ac_cpp_err"; then
10285	>	# Broken: success on invalid input.
10286	>	continue
10287	>	else
10288	>	echo "$as_me: failed program was:" >&5
10289	>	sed 's/^/| /' conftest.$ac_ext >&5
10290	>
10291	>	# Passes both tests.
10292	>	ac_preproc_ok=:
10293	>	break
10294	>	fi
10295	>	rm -f conftest.err conftest.$ac_ext
10296	>
10297	>	done
10298	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10299	>	rm -f conftest.err conftest.$ac_ext
10300	>	if $ac_preproc_ok; then
10301	>	:
10302	>	else
10303	>	{ { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10304	>	See \`config.log' for more details." >&5
10305	>	echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10306	>	See \`config.log' for more details." >&2;}
10307	>	{ (exit 1); exit 1; }; }
10308	>	fi
10309	>
10310	>	ac_ext=cc
10311	>	ac_cpp='$CXXCPP $CPPFLAGS'
10312	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10313	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10314	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10315	>
10316	>
10317	>	echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10318	>	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10319	>	if test "${ac_cv_cxx_have_stl+set}" = set; then
10320	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10321	>	else
10322	>
10323	>
10324	>
10325	>	ac_ext=cc
10326	>	ac_cpp='$CXXCPP $CPPFLAGS'
10327	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10328	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10329	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10330	>
10331	>	cat >conftest.$ac_ext <<_ACEOF
10332	>	/* confdefs.h.  */
10333	>	_ACEOF
10334	>	cat confdefs.h >>conftest.$ac_ext
10335	>	cat >>conftest.$ac_ext <<_ACEOF
10336	>	/* end confdefs.h.  */
10337	>	#include <list>
10338	>	#include <deque>
10339	>	#ifdef HAVE_NAMESPACES
10340	>	using namespace std;
10341	>	#endif
10342	>	#ifdef FC_DUMMY_MAIN
10343	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10344	>	#  ifdef __cplusplus
10345	>	extern "C"
10346	>	#  endif
10347	>	int FC_DUMMY_MAIN() { return 1; }
10348	>	#endif
10349	>	#endif
10350	>	int
10351	>	main ()
10352	>	{
10353	>	list<int> x; x.push_back(5);
10354	>	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10355	>	;
10356	>	return 0;
10357	>	}
10358	>	_ACEOF
10359	>	rm -f conftest.$ac_objext
10360	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10361	>	(eval $ac_compile) 2>conftest.er1
10362	>	ac_status=$?
10363	>	grep -v '^ *+' conftest.er1 >conftest.err
10364	>	rm -f conftest.er1
10365	>	cat conftest.err >&5
10366	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367	>	(exit $ac_status); } &&
10368	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10369	>	|| test ! -s conftest.err'
10370	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371	>	(eval $ac_try) 2>&5
10372	>	ac_status=$?
10373	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374	>	(exit $ac_status); }; } &&
10375	>	{ ac_try='test -s conftest.$ac_objext'
10376	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10377	>	(eval $ac_try) 2>&5
10378	>	ac_status=$?
10379	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380	>	(exit $ac_status); }; }; then
10381	>	ac_cv_cxx_have_stl=yes
10382	>	else
10383	>	echo "$as_me: failed program was:" >&5
10384	>	sed 's/^/| /' conftest.$ac_ext >&5
10385	>
10386	>	ac_cv_cxx_have_stl=no
10387	>	fi
10388	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389	>	ac_ext=cc
10390	>	ac_cpp='$CXXCPP $CPPFLAGS'
10391	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10392	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10393	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10394	>
10395	>
10396	>	fi
10397	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10398	>	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10399	>	if test "$ac_cv_cxx_have_stl" = yes; then
10400	>
10401	>	cat >>confdefs.h <<\_ACEOF
10402	>	#define HAVE_STL
10403	>	_ACEOF
10404	>
10405	>	fi
10406	>
10407	>
10408	>
10409	>	if test "${ac_cv_header_iostream+set}" = set; then
10410	>	echo "$as_me:$LINENO: checking for iostream" >&5
10411	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10412	>	if test "${ac_cv_header_iostream+set}" = set; then
10413	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10414	>	fi
10415	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10416	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10417	>	else
10418	>	# Is the header compilable?
10419	>	echo "$as_me:$LINENO: checking iostream usability" >&5
10420	>	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10421	>	cat >conftest.$ac_ext <<_ACEOF
10422	>	/* confdefs.h.  */
10423	>	_ACEOF
10424	>	cat confdefs.h >>conftest.$ac_ext
10425	>	cat >>conftest.$ac_ext <<_ACEOF
10426	>	/* end confdefs.h.  */
10427	>	$ac_includes_default
10428	>	#include <iostream>
10429	>	_ACEOF
10430	>	rm -f conftest.$ac_objext
10431	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10432	>	(eval $ac_compile) 2>conftest.er1
10433	>	ac_status=$?
10434	>	grep -v '^ *+' conftest.er1 >conftest.err
10435	>	rm -f conftest.er1
10436	>	cat conftest.err >&5
10437	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10438	>	(exit $ac_status); } &&
10439	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10440	>	|| test ! -s conftest.err'
10441	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10442	>	(eval $ac_try) 2>&5
10443	>	ac_status=$?
10444	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10445	>	(exit $ac_status); }; } &&
10446	>	{ ac_try='test -s conftest.$ac_objext'
10447	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10448	>	(eval $ac_try) 2>&5
10449	>	ac_status=$?
10450	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10451	>	(exit $ac_status); }; }; then
10452	>	ac_header_compiler=yes
10453	>	else
10454	>	echo "$as_me: failed program was:" >&5
10455	>	sed 's/^/| /' conftest.$ac_ext >&5
10456	>
10457	>	ac_header_compiler=no
10458	>	fi
10459	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10460	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10461	>	echo "${ECHO_T}$ac_header_compiler" >&6
10462	>
10463	>	# Is the header present?
10464	>	echo "$as_me:$LINENO: checking iostream presence" >&5
10465	>	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10466	>	cat >conftest.$ac_ext <<_ACEOF
10467	>	/* confdefs.h.  */
10468	>	_ACEOF
10469	>	cat confdefs.h >>conftest.$ac_ext
10470	>	cat >>conftest.$ac_ext <<_ACEOF
10471	>	/* end confdefs.h.  */
10472	>	#include <iostream>
10473	>	_ACEOF
10474	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10475	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10476	>	ac_status=$?
10477	>	grep -v '^ *+' conftest.er1 >conftest.err
10478	>	rm -f conftest.er1
10479	>	cat conftest.err >&5
10480	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10481	>	(exit $ac_status); } >/dev/null; then
10482	>	if test -s conftest.err; then
10483	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10484	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10485	>	else
10486	>	ac_cpp_err=
10487	>	fi
10488	>	else
10489	>	ac_cpp_err=yes
10490	>	fi
10491	>	if test -z "$ac_cpp_err"; then
10492	>	ac_header_preproc=yes
10493	>	else
10494	>	echo "$as_me: failed program was:" >&5
10495	>	sed 's/^/| /' conftest.$ac_ext >&5
10496	>
10497	>	ac_header_preproc=no
10498	>	fi
10499	>	rm -f conftest.err conftest.$ac_ext
10500	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10501	>	echo "${ECHO_T}$ac_header_preproc" >&6
10502	>
10503	>	# So?  What about this header?
10504	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10505	>	yes:no: )
10506	>	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10507	>	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10508	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10509	>	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10510	>	ac_header_preproc=yes
10511	>	;;
10512	>	no:yes:* )
10513	>	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10514	>	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10515	>	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10516	>	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10517	>	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10518	>	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10519	>	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10520	>	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10521	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10522	>	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10523	>	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10524	>	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10525	>	(
10526	>	cat <<\_ASBOX
10527	>	## ------------------------------ ##
10528	>	## Report this to gezelter@nd.edu ##
10529	>	## ------------------------------ ##
10530	>	_ASBOX
10531	>	) |
10532	>	sed "s/^/$as_me: WARNING:     /" >&2
10533	>	;;
10534	>	esac
10535	>	echo "$as_me:$LINENO: checking for iostream" >&5
10536	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10537	>	if test "${ac_cv_header_iostream+set}" = set; then
10538	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10539	>	else
10540	>	ac_cv_header_iostream=$ac_header_preproc
10541	>	fi
10542	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10543	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10544	>
10545	>	fi
10546	>	if test $ac_cv_header_iostream = yes; then
10547	>
10548	>
10549	>	cat >>confdefs.h <<\_ACEOF
10550	>	#define HAVE_IOSTREAM 1
10551	>	_ACEOF
10552	>
10553	>
10554	>	else
10555	>
10556	>
10557	>	for ac_header in iostream.h
10558	>	do
10559	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10560	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10561	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10562	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10563	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10564	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10565	>	fi
10566	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10567	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10568	>	else
10569	>	# Is the header compilable?
10570	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10571	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10572	>	cat >conftest.$ac_ext <<_ACEOF
10573	>	/* confdefs.h.  */
10574	>	_ACEOF
10575	>	cat confdefs.h >>conftest.$ac_ext
10576	>	cat >>conftest.$ac_ext <<_ACEOF
10577	>	/* end confdefs.h.  */
10578	>	$ac_includes_default
10579	>	#include <$ac_header>
10580	>	_ACEOF
10581	>	rm -f conftest.$ac_objext
10582	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10583	>	(eval $ac_compile) 2>conftest.er1
10584	>	ac_status=$?
10585	>	grep -v '^ *+' conftest.er1 >conftest.err
10586	>	rm -f conftest.er1
10587	>	cat conftest.err >&5
10588	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589	>	(exit $ac_status); } &&
10590	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10591	>	|| test ! -s conftest.err'
10592	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10593	>	(eval $ac_try) 2>&5
10594	>	ac_status=$?
10595	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10596	>	(exit $ac_status); }; } &&
10597	>	{ ac_try='test -s conftest.$ac_objext'
10598	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10599	>	(eval $ac_try) 2>&5
10600	>	ac_status=$?
10601	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602	>	(exit $ac_status); }; }; then
10603	>	ac_header_compiler=yes
10604	>	else
10605	>	echo "$as_me: failed program was:" >&5
10606	>	sed 's/^/| /' conftest.$ac_ext >&5
10607	>
10608	>	ac_header_compiler=no
10609	>	fi
10610	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10611	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10612	>	echo "${ECHO_T}$ac_header_compiler" >&6
10613	>
10614	>	# Is the header present?
10615	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10616	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10617	>	cat >conftest.$ac_ext <<_ACEOF
10618	>	/* confdefs.h.  */
10619	>	_ACEOF
10620	>	cat confdefs.h >>conftest.$ac_ext
10621	>	cat >>conftest.$ac_ext <<_ACEOF
10622	>	/* end confdefs.h.  */
10623	>	#include <$ac_header>
10624	>	_ACEOF
10625	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10626	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10627	>	ac_status=$?
10628	>	grep -v '^ *+' conftest.er1 >conftest.err
10629	>	rm -f conftest.er1
10630	>	cat conftest.err >&5
10631	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10632	>	(exit $ac_status); } >/dev/null; then
10633	>	if test -s conftest.err; then
10634	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10635	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10636	>	else
10637	>	ac_cpp_err=
10638	>	fi
10639	>	else
10640	>	ac_cpp_err=yes
10641	>	fi
10642	>	if test -z "$ac_cpp_err"; then
10643	>	ac_header_preproc=yes
10644	>	else
10645	>	echo "$as_me: failed program was:" >&5
10646	>	sed 's/^/| /' conftest.$ac_ext >&5
10647	>
10648	>	ac_header_preproc=no
10649	>	fi
10650	>	rm -f conftest.err conftest.$ac_ext
10651	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10652	>	echo "${ECHO_T}$ac_header_preproc" >&6
10653	>
10654	>	# So?  What about this header?
10655	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10656	>	yes:no: )
10657	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10658	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10659	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10660	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10661	>	ac_header_preproc=yes
10662	>	;;
10663	>	no:yes:* )
10664	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10665	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10666	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10667	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10668	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10669	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10670	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10671	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10672	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10673	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10674	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10675	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10676	>	(
10677	>	cat <<\_ASBOX
10678	>	## ------------------------------ ##
10679	>	## Report this to gezelter@nd.edu ##
10680	>	## ------------------------------ ##
10681	>	_ASBOX
10682	>	) |
10683	>	sed "s/^/$as_me: WARNING:     /" >&2
10684	>	;;
10685	>	esac
10686	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10687	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10688	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10689	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10690	>	else
10691	>	eval "$as_ac_Header=\$ac_header_preproc"
10692	>	fi
10693	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10694	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10695	>
10696	>	fi
10697	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10698	>	cat >>confdefs.h <<_ACEOF
10699	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10700	>	_ACEOF
10701	>
10702	>	fi
10703	>
10704	>	done
10705	>
10706	>
10707	>	fi
10708	>
10709	>
10710	>
10711	>
10712	>	if test "${ac_cv_header_iomanip+set}" = set; then
10713	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10714	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10715	>	if test "${ac_cv_header_iomanip+set}" = set; then
10716	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10717	>	fi
10718	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10719	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10720	>	else
10721	>	# Is the header compilable?
10722	>	echo "$as_me:$LINENO: checking iomanip usability" >&5
10723	>	echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10724	>	cat >conftest.$ac_ext <<_ACEOF
10725	>	/* confdefs.h.  */
10726	>	_ACEOF
10727	>	cat confdefs.h >>conftest.$ac_ext
10728	>	cat >>conftest.$ac_ext <<_ACEOF
10729	>	/* end confdefs.h.  */
10730	>	$ac_includes_default
10731	>	#include <iomanip>
10732	>	_ACEOF
10733	>	rm -f conftest.$ac_objext
10734	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10735	>	(eval $ac_compile) 2>conftest.er1
10736	>	ac_status=$?
10737	>	grep -v '^ *+' conftest.er1 >conftest.err
10738	>	rm -f conftest.er1
10739	>	cat conftest.err >&5
10740	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10741	>	(exit $ac_status); } &&
10742	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10743	>	|| test ! -s conftest.err'
10744	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10745	>	(eval $ac_try) 2>&5
10746	>	ac_status=$?
10747	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748	>	(exit $ac_status); }; } &&
10749	>	{ ac_try='test -s conftest.$ac_objext'
10750	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10751	>	(eval $ac_try) 2>&5
10752	>	ac_status=$?
10753	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10754	>	(exit $ac_status); }; }; then
10755	>	ac_header_compiler=yes
10756	>	else
10757	>	echo "$as_me: failed program was:" >&5
10758	>	sed 's/^/| /' conftest.$ac_ext >&5
10759	>
10760	>	ac_header_compiler=no
10761	>	fi
10762	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10763	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10764	>	echo "${ECHO_T}$ac_header_compiler" >&6
10765	>
10766	>	# Is the header present?
10767	>	echo "$as_me:$LINENO: checking iomanip presence" >&5
10768	>	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10769	>	cat >conftest.$ac_ext <<_ACEOF
10770	>	/* confdefs.h.  */
10771	>	_ACEOF
10772	>	cat confdefs.h >>conftest.$ac_ext
10773	>	cat >>conftest.$ac_ext <<_ACEOF
10774	>	/* end confdefs.h.  */
10775	>	#include <iomanip>
10776	>	_ACEOF
10777	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10778	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10779	>	ac_status=$?
10780	>	grep -v '^ *+' conftest.er1 >conftest.err
10781	>	rm -f conftest.er1
10782	>	cat conftest.err >&5
10783	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10784	>	(exit $ac_status); } >/dev/null; then
10785	>	if test -s conftest.err; then
10786	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10787	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10788	>	else
10789	>	ac_cpp_err=
10790	>	fi
10791	>	else
10792	>	ac_cpp_err=yes
10793	>	fi
10794	>	if test -z "$ac_cpp_err"; then
10795	>	ac_header_preproc=yes
10796	>	else
10797	>	echo "$as_me: failed program was:" >&5
10798	>	sed 's/^/| /' conftest.$ac_ext >&5
10799	>
10800	>	ac_header_preproc=no
10801	>	fi
10802	>	rm -f conftest.err conftest.$ac_ext
10803	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10804	>	echo "${ECHO_T}$ac_header_preproc" >&6
10805	>
10806	>	# So?  What about this header?
10807	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10808	>	yes:no: )
10809	>	{ echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10810	>	echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10811	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10812	>	echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10813	>	ac_header_preproc=yes
10814	>	;;
10815	>	no:yes:* )
10816	>	{ echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10817	>	echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10818	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10819	>	echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10820	>	{ echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10821	>	echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10822	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10823	>	echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10824	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10825	>	echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10826	>	{ echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10827	>	echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10828	>	(
10829	>	cat <<\_ASBOX
10830	>	## ------------------------------ ##
10831	>	## Report this to gezelter@nd.edu ##
10832	>	## ------------------------------ ##
10833	>	_ASBOX
10834	>	) |
10835	>	sed "s/^/$as_me: WARNING:     /" >&2
10836	>	;;
10837	>	esac
10838	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10839	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10840	>	if test "${ac_cv_header_iomanip+set}" = set; then
10841	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10842	>	else
10843	>	ac_cv_header_iomanip=$ac_header_preproc
10844	>	fi
10845	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10846	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10847	>
10848	>	fi
10849	>	if test $ac_cv_header_iomanip = yes; then
10850	>
10851	>
10852	>	cat >>confdefs.h <<\_ACEOF
10853	>	#define HAVE_IOMANIP 1
10854	>	_ACEOF
10855	>
10856
4460	–	ac_ext=c
4461	–	ac_cpp='$CPP $CPPFLAGS'
4462	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4463	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4464	–	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
4473	–	echo $ECHO_N "(cached) $ECHO_C" >&6
10857		else
10858	<	# Double quotes because CPP needs to be expanded
10859	<	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10860	<	do
4478	<	ac_preproc_ok=false
4479	<	for ac_c_preproc_warn_flag in '' yes
10858	>
10859	>
10860	>	for ac_header in iomanip.h
10861		do
10862	<	# Use a header file that comes with gcc, so configuring glibc
10863	<	# with a fresh cross-compiler works.
10864	<	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10865	<	# <limits.h> exists even on freestanding compilers.
10866	<	# On the NeXT, cc -E runs the code through the compiler's parser,
10867	<	# not just through cpp. "Syntax error" is here to catch this case.
10868	<	cat >conftest.$ac_ext <<_ACEOF
10862	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10863	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10864	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10865	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10866	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10867	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10868	>	fi
10869	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10870	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10871	>	else
10872	>	# Is the header compilable?
10873	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10874	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10875	>	cat >conftest.$ac_ext <<_ACEOF
10876		/* confdefs.h.  */
10877		_ACEOF
10878		cat confdefs.h >>conftest.$ac_ext
10879		cat >>conftest.$ac_ext <<_ACEOF
10880		/* end confdefs.h.  */
10881	<	#ifdef __STDC__
10882	<	# include <limits.h>
4495	<	#else
4496	<	# include <assert.h>
4497	<	#endif
4498	<	Syntax error
10881	>	$ac_includes_default
10882	>	#include <$ac_header>
10883		_ACEOF
10884	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10885	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10884	>	rm -f conftest.$ac_objext
10885	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10886	>	(eval $ac_compile) 2>conftest.er1
10887		ac_status=$?
10888		grep -v '^ *+' conftest.er1 >conftest.err
10889		rm -f conftest.er1
10890		cat conftest.err >&5
10891		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10892	<	(exit $ac_status); } >/dev/null; then
10893	<	if test -s conftest.err; then
10894	<	ac_cpp_err=$ac_c_preproc_warn_flag
10895	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10896	<	else
10897	<	ac_cpp_err=
10898	<	fi
10892	>	(exit $ac_status); } &&
10893	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10894	>	|| test ! -s conftest.err'
10895	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10896	>	(eval $ac_try) 2>&5
10897	>	ac_status=$?
10898	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10899	>	(exit $ac_status); }; } &&
10900	>	{ ac_try='test -s conftest.$ac_objext'
10901	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10902	>	(eval $ac_try) 2>&5
10903	>	ac_status=$?
10904	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10905	>	(exit $ac_status); }; }; then
10906	>	ac_header_compiler=yes
10907		else
4515	–	ac_cpp_err=yes
4516	–	fi
4517	–	if test -z "$ac_cpp_err"; then
4518	–	:
4519	–	else
10908		echo "$as_me: failed program was:" >&5
10909		sed 's/^/| /' conftest.$ac_ext >&5
10910
10911	<	# Broken: fails on valid input.
4524	<	continue
10911	>	ac_header_compiler=no
10912		fi
10913	<	rm -f conftest.err conftest.$ac_ext
10913	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10914	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10915	>	echo "${ECHO_T}$ac_header_compiler" >&6
10916
10917	<	# OK, works on sane cases.  Now check whether non-existent headers
10918	<	# can be detected and how.
10919	<	cat >conftest.$ac_ext <<_ACEOF
10917	>	# Is the header present?
10918	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10919	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10920	>	cat >conftest.$ac_ext <<_ACEOF
10921		/* confdefs.h.  */
10922		_ACEOF
10923		cat confdefs.h >>conftest.$ac_ext
10924		cat >>conftest.$ac_ext <<_ACEOF
10925		/* end confdefs.h.  */
10926	<	#include <ac_nonexistent.h>
10926	>	#include <$ac_header>
10927		_ACEOF
10928		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10929		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 4544 | Line 10934 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10934		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10935		(exit $ac_status); } >/dev/null; then
10936		if test -s conftest.err; then
10937	<	ac_cpp_err=$ac_c_preproc_warn_flag
10938	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10937	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10938	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10939		else
10940		ac_cpp_err=
10941		fi
#	Line 4553 | Line 10943 | if test -z "$ac_cpp_err"; then
10943		ac_cpp_err=yes
10944		fi
10945		if test -z "$ac_cpp_err"; then
10946	<	# Broken: success on invalid input.
4557	<	continue
10946	>	ac_header_preproc=yes
10947		else
10948		echo "$as_me: failed program was:" >&5
10949		sed 's/^/| /' conftest.$ac_ext >&5
10950
10951	<	# Passes both tests.
4563	<	ac_preproc_ok=:
4564	<	break
10951	>	ac_header_preproc=no
10952		fi
10953		rm -f conftest.err conftest.$ac_ext
10954	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10955	+	echo "${ECHO_T}$ac_header_preproc" >&6
10956
10957	<	done
10958	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10959	<	rm -f conftest.err conftest.$ac_ext
10960	<	if $ac_preproc_ok; then
10961	<	break
10957	>	# So?  What about this header?
10958	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10959	>	yes:no: )
10960	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10961	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10962	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10963	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10964	>	ac_header_preproc=yes
10965	>	;;
10966	>	no:yes:* )
10967	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10968	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10969	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10970	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10971	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10972	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10973	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10974	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10975	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10976	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10977	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10978	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10979	>	(
10980	>	cat <<\_ASBOX
10981	>	## ------------------------------ ##
10982	>	## Report this to gezelter@nd.edu ##
10983	>	## ------------------------------ ##
10984	>	_ASBOX
10985	>	) |
10986	>	sed "s/^/$as_me: WARNING:     /" >&2
10987	>	;;
10988	>	esac
10989	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10990	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10991	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10992	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10993	>	else
10994	>	eval "$as_ac_Header=\$ac_header_preproc"
10995		fi
10996	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10997	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10998
10999	<	done
11000	<	ac_cv_prog_CPP=$CPP
10999	>	fi
11000	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11001	>	cat >>confdefs.h <<_ACEOF
11002	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11003	>	_ACEOF
11004
11005		fi
11006	<	CPP=$ac_cv_prog_CPP
11007	<	else
11008	<	ac_cv_prog_CPP=$CPP
11006	>
11007	>	done
11008	>
11009	>
11010		fi
11011	<	echo "$as_me:$LINENO: result: $CPP" >&5
11012	<	echo "${ECHO_T}$CPP" >&6
11013	<	ac_preproc_ok=false
11014	<	for ac_c_preproc_warn_flag in '' yes
11011	>
11012	>
11013	>
11014	>
11015	>	for ac_header in cmath
11016		do
11017	<	# Use a header file that comes with gcc, so configuring glibc
11018	<	# with a fresh cross-compiler works.
11019	<	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11020	<	# <limits.h> exists even on freestanding compilers.
11021	<	# On the NeXT, cc -E runs the code through the compiler's parser,
11022	<	# not just through cpp. "Syntax error" is here to catch this case.
11023	<	cat >conftest.$ac_ext <<_ACEOF
11017	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11018	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11019	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11020	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11021	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11022	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11023	>	fi
11024	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11025	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11026	>	else
11027	>	# Is the header compilable?
11028	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
11029	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11030	>	cat >conftest.$ac_ext <<_ACEOF
11031		/* confdefs.h.  */
11032		_ACEOF
11033		cat confdefs.h >>conftest.$ac_ext
11034		cat >>conftest.$ac_ext <<_ACEOF
11035		/* end confdefs.h.  */
11036	<	#ifdef __STDC__
11037	<	# include <limits.h>
4602	<	#else
4603	<	# include <assert.h>
4604	<	#endif
4605	<	Syntax error
11036	>	$ac_includes_default
11037	>	#include <$ac_header>
11038		_ACEOF
11039	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11040	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11039	>	rm -f conftest.$ac_objext
11040	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11041	>	(eval $ac_compile) 2>conftest.er1
11042		ac_status=$?
11043		grep -v '^ *+' conftest.er1 >conftest.err
11044		rm -f conftest.er1
11045		cat conftest.err >&5
11046		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11047	<	(exit $ac_status); } >/dev/null; then
11048	<	if test -s conftest.err; then
11049	<	ac_cpp_err=$ac_c_preproc_warn_flag
11050	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11051	<	else
11052	<	ac_cpp_err=
11053	<	fi
11047	>	(exit $ac_status); } &&
11048	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11049	>	|| test ! -s conftest.err'
11050	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11051	>	(eval $ac_try) 2>&5
11052	>	ac_status=$?
11053	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11054	>	(exit $ac_status); }; } &&
11055	>	{ ac_try='test -s conftest.$ac_objext'
11056	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11057	>	(eval $ac_try) 2>&5
11058	>	ac_status=$?
11059	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11060	>	(exit $ac_status); }; }; then
11061	>	ac_header_compiler=yes
11062		else
4622	–	ac_cpp_err=yes
4623	–	fi
4624	–	if test -z "$ac_cpp_err"; then
4625	–	:
4626	–	else
11063		echo "$as_me: failed program was:" >&5
11064		sed 's/^/| /' conftest.$ac_ext >&5
11065
11066	<	# Broken: fails on valid input.
4631	<	continue
11066	>	ac_header_compiler=no
11067		fi
11068	<	rm -f conftest.err conftest.$ac_ext
11068	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11069	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11070	>	echo "${ECHO_T}$ac_header_compiler" >&6
11071
11072	<	# OK, works on sane cases.  Now check whether non-existent headers
11073	<	# can be detected and how.
11074	<	cat >conftest.$ac_ext <<_ACEOF
11072	>	# Is the header present?
11073	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
11074	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11075	>	cat >conftest.$ac_ext <<_ACEOF
11076		/* confdefs.h.  */
11077		_ACEOF
11078		cat confdefs.h >>conftest.$ac_ext
11079		cat >>conftest.$ac_ext <<_ACEOF
11080		/* end confdefs.h.  */
11081	<	#include <ac_nonexistent.h>
11081	>	#include <$ac_header>
11082		_ACEOF
11083		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11084		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 4651 | Line 11089 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11089		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090		(exit $ac_status); } >/dev/null; then
11091		if test -s conftest.err; then
11092	<	ac_cpp_err=$ac_c_preproc_warn_flag
11093	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11092	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11093	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11094		else
11095		ac_cpp_err=
11096		fi
#	Line 4660 | Line 11098 | if test -z "$ac_cpp_err"; then
11098		ac_cpp_err=yes
11099		fi
11100		if test -z "$ac_cpp_err"; then
11101	<	# Broken: success on invalid input.
4664	<	continue
11101	>	ac_header_preproc=yes
11102		else
11103		echo "$as_me: failed program was:" >&5
11104		sed 's/^/| /' conftest.$ac_ext >&5
11105
11106	<	# Passes both tests.
4670	<	ac_preproc_ok=:
4671	<	break
11106	>	ac_header_preproc=no
11107		fi
11108		rm -f conftest.err conftest.$ac_ext
11109	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11110	+	echo "${ECHO_T}$ac_header_preproc" >&6
11111
11112	<	done
11113	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
11114	<	rm -f conftest.err conftest.$ac_ext
11115	<	if $ac_preproc_ok; then
11116	<	:
11112	>	# So?  What about this header?
11113	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11114	>	yes:no: )
11115	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11116	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11117	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11118	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11119	>	ac_header_preproc=yes
11120	>	;;
11121	>	no:yes:* )
11122	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11123	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11124	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11125	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11126	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11127	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11128	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11129	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11130	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11131	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11132	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11133	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11134	>	(
11135	>	cat <<\_ASBOX
11136	>	## ------------------------------ ##
11137	>	## Report this to gezelter@nd.edu ##
11138	>	## ------------------------------ ##
11139	>	_ASBOX
11140	>	) |
11141	>	sed "s/^/$as_me: WARNING:     /" >&2
11142	>	;;
11143	>	esac
11144	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11145	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11146	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11147	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11148		else
11149	<	{ { 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; }; }
11149	>	eval "$as_ac_Header=\$ac_header_preproc"
11150		fi
11151	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11152	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11153
11154	<	ac_ext=c
11155	<	ac_cpp='$CPP $CPPFLAGS'
11156	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11157	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11158	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
11154	>	fi
11155	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11156	>	cat >>confdefs.h <<_ACEOF
11157	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11158	>	_ACEOF
11159
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
11160		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
11161
11162	+	done
11163
11164	<	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
11165	<	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
11166	<	if test "${ac_cv_header_stdc+set}" = set; then
11164	>
11165	>
11166	>
11167	>	echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11168	>	echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11169	>	if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11170		echo $ECHO_N "(cached) $ECHO_C" >&6
11171		else
11172	<	cat >conftest.$ac_ext <<_ACEOF
11172	>
11173	>	ac_cv_cxx_have_std_iostream=no
11174	>	ac_cv_cxx_need_use_std_iostream=no
11175	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11176	>
11177	>
11178	>	ac_ext=cc
11179	>	ac_cpp='$CXXCPP $CPPFLAGS'
11180	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11181	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11182	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11183	>
11184	>	cat >conftest.$ac_ext <<_ACEOF
11185		/* confdefs.h.  */
11186		_ACEOF
11187		cat confdefs.h >>conftest.$ac_ext
11188		cat >>conftest.$ac_ext <<_ACEOF
11189		/* end confdefs.h.  */
4721	–	#include <stdlib.h>
4722	–	#include <stdarg.h>
4723	–	#include <string.h>
4724	–	#include <float.h>
11190
11191	+	#ifdef HAVE_IOSTREAM
11192	+	#include <iostream>
11193	+	#else
11194	+	#include <iostream.h>
11195	+	#endif
11196	+
11197	+	#ifdef FC_DUMMY_MAIN
11198	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11199	+	#  ifdef __cplusplus
11200	+	extern "C"
11201	+	#  endif
11202	+	int FC_DUMMY_MAIN() { return 1; }
11203	+	#endif
11204	+	#endif
11205		int
11206		main ()
11207		{
11208	<
11208	>	std::cout<<"Hello World"<<std::endl;return 0;
11209		;
11210		return 0;
11211		}
#	Line 4740 | Line 11219 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11219		cat conftest.err >&5
11220		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11221		(exit $ac_status); } &&
11222	<	{ ac_try='test -z "$ac_c_werror_flag"
11222	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11223		|| test ! -s conftest.err'
11224		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11225		(eval $ac_try) 2>&5
#	Line 4753 | Line 11232 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11232		ac_status=$?
11233		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11234		(exit $ac_status); }; }; then
11235	<	ac_cv_header_stdc=yes
11235	>	ac_cv_cxx_have_std_iostream=yes
11236		else
11237		echo "$as_me: failed program was:" >&5
11238		sed 's/^/| /' conftest.$ac_ext >&5
11239
4761	–	ac_cv_header_stdc=no
11240		fi
11241		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11242	<
4765	<	if test $ac_cv_header_stdc = yes; then
4766	<	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4767	<	cat >conftest.$ac_ext <<_ACEOF
11242	>	cat >conftest.$ac_ext <<_ACEOF
11243		/* confdefs.h.  */
11244		_ACEOF
11245		cat confdefs.h >>conftest.$ac_ext
11246		cat >>conftest.$ac_ext <<_ACEOF
11247		/* end confdefs.h.  */
4773	–	#include <string.h>
11248
11249	+	#define __USE_STD_IOSTREAM 1
11250	+	#ifdef HAVE_IOSTREAM
11251	+	#include <iostream>
11252	+	#else
11253	+	#include <iostream.h>
11254	+	#endif
11255	+
11256	+	#ifdef FC_DUMMY_MAIN
11257	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11258	+	#  ifdef __cplusplus
11259	+	extern "C"
11260	+	#  endif
11261	+	int FC_DUMMY_MAIN() { return 1; }
11262	+	#endif
11263	+	#endif
11264	+	int
11265	+	main ()
11266	+	{
11267	+	std::cout<<"Hello World"<<std::endl;return 0;
11268	+	;
11269	+	return 0;
11270	+	}
11271		_ACEOF
11272	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11273	<	$EGREP "memchr" >/dev/null 2>&1; then
11274	<	:
11272	>	rm -f conftest.$ac_objext
11273	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11274	>	(eval $ac_compile) 2>conftest.er1
11275	>	ac_status=$?
11276	>	grep -v '^ *+' conftest.er1 >conftest.err
11277	>	rm -f conftest.er1
11278	>	cat conftest.err >&5
11279	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11280	>	(exit $ac_status); } &&
11281	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11282	>	|| test ! -s conftest.err'
11283	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11284	>	(eval $ac_try) 2>&5
11285	>	ac_status=$?
11286	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11287	>	(exit $ac_status); }; } &&
11288	>	{ ac_try='test -s conftest.$ac_objext'
11289	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11290	>	(eval $ac_try) 2>&5
11291	>	ac_status=$?
11292	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11293	>	(exit $ac_status); }; }; then
11294	>	ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11295		else
11296	<	ac_cv_header_stdc=no
11296	>	echo "$as_me: failed program was:" >&5
11297	>	sed 's/^/| /' conftest.$ac_ext >&5
11298	>
11299		fi
11300	<	rm -f conftest*
11300	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11301	>	ac_ext=cc
11302	>	ac_cpp='$CXXCPP $CPPFLAGS'
11303	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11304	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11305	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11306
11307	+	fi
11308	+
11309		fi
11310	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11311	+	echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11312	+	if test "$ac_cv_cxx_have_std_iostream" = yes; then
11313
11314	<	if test $ac_cv_header_stdc = yes; then
11315	<	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
4788	<	cat >conftest.$ac_ext <<_ACEOF
4789	<	/* confdefs.h.  */
11314	>	cat >>confdefs.h <<\_ACEOF
11315	>	#define HAVE_STD_IOSTREAM 1
11316		_ACEOF
4791	–	cat confdefs.h >>conftest.$ac_ext
4792	–	cat >>conftest.$ac_ext <<_ACEOF
4793	–	/* end confdefs.h.  */
4794	–	#include <stdlib.h>
11317
11318	+	fi
11319	+	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11320	+
11321	+	cat >>confdefs.h <<\_ACEOF
11322	+	#define __USE_STD_IOSTREAM 1
11323		_ACEOF
11324	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11325	<	$EGREP "free" >/dev/null 2>&1; then
11326	<	:
11324	>
11325	>	fi
11326	>
11327	>
11328	>
11329	>
11330	>	echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11331	>	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11332	>	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11333	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11334		else
11335	<	ac_cv_header_stdc=no
11335	>
11336	>	ac_cv_cxx_have_std_stl=no
11337	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11338	>
11339	>
11340	>	ac_ext=cc
11341	>	ac_cpp='$CXXCPP $CPPFLAGS'
11342	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11343	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11344	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11345	>
11346	>	cat >conftest.$ac_ext <<_ACEOF
11347	>	/* confdefs.h.  */
11348	>	_ACEOF
11349	>	cat confdefs.h >>conftest.$ac_ext
11350	>	cat >>conftest.$ac_ext <<_ACEOF
11351	>	/* end confdefs.h.  */
11352	>	#include <list>
11353	>
11354	>	#ifdef FC_DUMMY_MAIN
11355	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11356	>	#  ifdef __cplusplus
11357	>	extern "C"
11358	>	#  endif
11359	>	int FC_DUMMY_MAIN() { return 1; }
11360	>	#endif
11361	>	#endif
11362	>	int
11363	>	main ()
11364	>	{
11365	>	std::list<int> foo;return 0;
11366	>	;
11367	>	return 0;
11368	>	}
11369	>	_ACEOF
11370	>	rm -f conftest.$ac_objext
11371	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11372	>	(eval $ac_compile) 2>conftest.er1
11373	>	ac_status=$?
11374	>	grep -v '^ *+' conftest.er1 >conftest.err
11375	>	rm -f conftest.er1
11376	>	cat conftest.err >&5
11377	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378	>	(exit $ac_status); } &&
11379	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11380	>	|| test ! -s conftest.err'
11381	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11382	>	(eval $ac_try) 2>&5
11383	>	ac_status=$?
11384	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11385	>	(exit $ac_status); }; } &&
11386	>	{ ac_try='test -s conftest.$ac_objext'
11387	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11388	>	(eval $ac_try) 2>&5
11389	>	ac_status=$?
11390	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11391	>	(exit $ac_status); }; }; then
11392	>	ac_cv_cxx_have_std_stl=yes
11393	>	else
11394	>	echo "$as_me: failed program was:" >&5
11395	>	sed 's/^/| /' conftest.$ac_ext >&5
11396	>
11397		fi
11398	<	rm -f conftest*
11398	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11399	>	ac_ext=cc
11400	>	ac_cpp='$CXXCPP $CPPFLAGS'
11401	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11402	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11403	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11404
11405	+	fi
11406	+
11407		fi
11408	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11409	+	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11410	+	if test "$ac_cv_cxx_have_std_stl" = yes; then
11411
11412	<	if test $ac_cv_header_stdc = yes; then
11413	<	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
11414	<	if test "$cross_compiling" = yes; then
11415	<	:
11412	>	cat >>confdefs.h <<\_ACEOF
11413	>	#define HAVE_STD_STL 1
11414	>	_ACEOF
11415	>
11416	>	fi
11417	>
11418	>
11419	>
11420	>	echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11421	>	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11422	>	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11423	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11424		else
11425	<	cat >conftest.$ac_ext <<_ACEOF
11425	>
11426	>	ac_cv_cxx_have_fstream_attach=no
11427	>
11428	>
11429	>	ac_ext=cc
11430	>	ac_cpp='$CXXCPP $CPPFLAGS'
11431	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11432	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11433	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11434	>
11435	>	cat >conftest.$ac_ext <<_ACEOF
11436		/* confdefs.h.  */
11437		_ACEOF
11438		cat confdefs.h >>conftest.$ac_ext
11439		cat >>conftest.$ac_ext <<_ACEOF
11440		/* end confdefs.h.  */
11441	<	#include <ctype.h>
11442	<	#if ((' ' & 0x0FF) == 0x020)
11443	<	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4821	<	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
11441	>
11442	>	#ifdef HAVE_IOSTREAM
11443	>	#include <fstream>
11444		#else
11445	<	# 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))
11445	>	#include <fstream.h>
11446		#endif
11447	+	#ifdef HAVE_STD_IOSTREAM
11448	+	using namespace std;
11449	+	#endif
11450
11451	<	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
11451	>	#ifdef FC_DUMMY_MAIN
11452	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11453	>	#  ifdef __cplusplus
11454	>	extern "C"
11455	>	#  endif
11456	>	int FC_DUMMY_MAIN() { return 1; }
11457	>	#endif
11458	>	#endif
11459		int
11460		main ()
11461		{
11462	<	int i;
11463	<	for (i = 0; i < 256; i++)
11464	<	if (XOR (islower (i), ISLOWER (i))
4837	<	|| toupper (i) != TOUPPER (i))
4838	<	exit(2);
4839	<	exit (0);
11462	>	int fd=0;ofstream s;s.attach(fd);
11463	>	;
11464	>	return 0;
11465		}
11466		_ACEOF
11467	<	rm -f conftest$ac_exeext
11468	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11469	<	(eval $ac_link) 2>&5
11467	>	rm -f conftest.$ac_objext
11468	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11469	>	(eval $ac_compile) 2>conftest.er1
11470		ac_status=$?
11471	+	grep -v '^ *+' conftest.er1 >conftest.err
11472	+	rm -f conftest.er1
11473	+	cat conftest.err >&5
11474		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11475	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11475	>	(exit $ac_status); } &&
11476	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11477	>	|| test ! -s conftest.err'
11478		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479		(eval $ac_try) 2>&5
11480		ac_status=$?
11481		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482	+	(exit $ac_status); }; } &&
11483	+	{ ac_try='test -s conftest.$ac_objext'
11484	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11485	+	(eval $ac_try) 2>&5
11486	+	ac_status=$?
11487	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11488		(exit $ac_status); }; }; then
11489	<	:
11489	>	ac_cv_cxx_have_fstream_attach=yes
11490		else
11491	<	echo "$as_me: program exited with status $ac_status" >&5
4856	<	echo "$as_me: failed program was:" >&5
11491	>	echo "$as_me: failed program was:" >&5
11492		sed 's/^/| /' conftest.$ac_ext >&5
11493
4859	–	( exit $ac_status )
4860	–	ac_cv_header_stdc=no
11494		fi
11495	<	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11495	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11496	>	ac_ext=cc
11497	>	ac_cpp='$CXXCPP $CPPFLAGS'
11498	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11499	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11500	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11501	>
11502	>
11503		fi
11504	<	fi
11505	<	fi
11506	<	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
11504	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11505	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11506	>	if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11507
11508		cat >>confdefs.h <<\_ACEOF
11509	<	#define STDC_HEADERS 1
11509	>	#define HAVE_FSTREAM_ATTACH 1
11510		_ACEOF
11511
11512	<	fi
11512	>	fi
11513
4876	–	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
11514
11515
11516	+	echo "$as_me:$LINENO: checking for fstream::open()" >&5
11517	+	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11518	+	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11519	+	echo $ECHO_N "(cached) $ECHO_C" >&6
11520	+	else
11521
11522	+	ac_cv_cxx_have_fstream_open=no
11523	+	ac_cv_cxx_fstream_open_prot=no
11524
11525
11526	+	ac_ext=cc
11527	+	ac_cpp='$CXXCPP $CPPFLAGS'
11528	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11529	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11530	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11531
11532	+	# Try with 2 parameters
11533	+	cat >conftest.$ac_ext <<_ACEOF
11534	+	/* confdefs.h.  */
11535	+	_ACEOF
11536	+	cat confdefs.h >>conftest.$ac_ext
11537	+	cat >>conftest.$ac_ext <<_ACEOF
11538	+	/* end confdefs.h.  */
11539
11540	+	#ifdef HAVE_IOSTREAM
11541	+	#include <fstream>
11542	+	#else
11543	+	#include <fstream.h>
11544	+	#endif
11545	+	#ifdef HAVE_STD_IOSTREAM
11546	+	using namespace std;
11547	+	#endif
11548
11549	<
11550	<	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
11551	<	inttypes.h stdint.h unistd.h
11552	<	do
11553	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11554	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
11555	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11556	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11557	<	echo $ECHO_N "(cached) $ECHO_C" >&6
11549	>	#ifdef FC_DUMMY_MAIN
11550	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11551	>	#  ifdef __cplusplus
11552	>	extern "C"
11553	>	#  endif
11554	>	int FC_DUMMY_MAIN() { return 1; }
11555	>	#endif
11556	>	#endif
11557	>	int
11558	>	main ()
11559	>	{
11560	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11561	>	;
11562	>	return 0;
11563	>	}
11564	>	_ACEOF
11565	>	rm -f conftest.$ac_objext
11566	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11567	>	(eval $ac_compile) 2>conftest.er1
11568	>	ac_status=$?
11569	>	grep -v '^ *+' conftest.er1 >conftest.err
11570	>	rm -f conftest.er1
11571	>	cat conftest.err >&5
11572	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11573	>	(exit $ac_status); } &&
11574	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11575	>	|| test ! -s conftest.err'
11576	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11577	>	(eval $ac_try) 2>&5
11578	>	ac_status=$?
11579	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11580	>	(exit $ac_status); }; } &&
11581	>	{ ac_try='test -s conftest.$ac_objext'
11582	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11583	>	(eval $ac_try) 2>&5
11584	>	ac_status=$?
11585	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11586	>	(exit $ac_status); }; }; then
11587	>	ac_cv_cxx_have_fstream_open=yes
11588		else
11589	<	cat >conftest.$ac_ext <<_ACEOF
11589	>	echo "$as_me: failed program was:" >&5
11590	>	sed 's/^/| /' conftest.$ac_ext >&5
11591	>
11592	>	fi
11593	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11594	>	# Try with mode parameter
11595	>	cat >conftest.$ac_ext <<_ACEOF
11596		/* confdefs.h.  */
11597		_ACEOF
11598		cat confdefs.h >>conftest.$ac_ext
11599		cat >>conftest.$ac_ext <<_ACEOF
11600		/* end confdefs.h.  */
4901	–	$ac_includes_default
11601
11602	<	#include <$ac_header>
11602	>	#ifdef HAVE_IOSTREAM
11603	>	#include <fstream>
11604	>	#else
11605	>	#include <fstream.h>
11606	>	#endif
11607	>	#ifdef HAVE_STD_IOSTREAM
11608	>	using namespace std;
11609	>	#endif
11610	>
11611	>	#ifdef FC_DUMMY_MAIN
11612	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11613	>	#  ifdef __cplusplus
11614	>	extern "C"
11615	>	#  endif
11616	>	int FC_DUMMY_MAIN() { return 1; }
11617	>	#endif
11618	>	#endif
11619	>	int
11620	>	main ()
11621	>	{
11622	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11623	>	;
11624	>	return 0;
11625	>	}
11626		_ACEOF
11627		rm -f conftest.$ac_objext
11628		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 4911 | Line 11633 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11633		cat conftest.err >&5
11634		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11635		(exit $ac_status); } &&
11636	<	{ ac_try='test -z "$ac_c_werror_flag"
11636	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11637		|| test ! -s conftest.err'
11638		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11639		(eval $ac_try) 2>&5
#	Line 4924 | Line 11646 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11646		ac_status=$?
11647		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648		(exit $ac_status); }; }; then
11649	<	eval "$as_ac_Header=yes"
11649	>	ac_cv_cxx_fstream_open_prot=yes
11650		else
11651		echo "$as_me: failed program was:" >&5
11652		sed 's/^/| /' conftest.$ac_ext >&5
11653
4932	–	eval "$as_ac_Header=no"
11654		fi
11655		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11656	+	ac_ext=cc
11657	+	ac_cpp='$CXXCPP $CPPFLAGS'
11658	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11659	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11660	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11661	+
11662	+
11663		fi
11664	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11665	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11666	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11667	<	cat >>confdefs.h <<_ACEOF
11668	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11664	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11665	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11666	>	if test "$ac_cv_cxx_have_fstream_open" = yes; then
11667	>
11668	>	cat >>confdefs.h <<\_ACEOF
11669	>	#define HAVE_FSTREAM_OPEN 1
11670		_ACEOF
11671
11672	<	fi
11672	>	fi
11673	>	if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11674
11675	<	done
11675	>	cat >>confdefs.h <<\_ACEOF
11676	>	#define FSTREAM_OPEN_PROT 1
11677	>	_ACEOF
11678
11679	+	fi
11680
4948	–	# clean out junk possibly left behind by a previous configuration
4949	–	rm -f src/utils/getopt.h
4950	–	# Check for getopt_long support
11681
11682	<	for ac_header in getopt.h
11682	>
11683	>
11684	>
11685	>
11686	>
11687	>	for ac_header in ctype.h iostream fstream sstream strstream
11688		do
11689		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11690		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 4982 | Line 11717 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717		cat conftest.err >&5
11718		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11719		(exit $ac_status); } &&
11720	<	{ ac_try='test -z "$ac_c_werror_flag"
11720	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11721		|| test ! -s conftest.err'
11722		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11723		(eval $ac_try) 2>&5
#	Line 5026 | Line 11761 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11761		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11762		(exit $ac_status); } >/dev/null; then
11763		if test -s conftest.err; then
11764	<	ac_cpp_err=$ac_c_preproc_warn_flag
11765	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11764	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11765	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11766		else
11767		ac_cpp_err=
11768		fi
#	Line 5047 | Line 11782 | echo "${ECHO_T}$ac_header_preproc" >&6
11782		echo "${ECHO_T}$ac_header_preproc" >&6
11783
11784		# So?  What about this header?
11785	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11785	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11786		yes:no: )
11787		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11788		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 5098 | Line 11833 | done
11833
11834		done
11835
11836	+	# AC_CPP_FUNC
11837	+	# ------------------ #
11838	+	# Checks to see if ANSI C99 CPP variable __func__ works.
11839	+	# If not, perhaps __FUNCTION__ works instead.
11840	+	# If not, we'll just define __func__ to "".
11841	+	# AC_CPP_FUNC
11842
11843	<	for ac_func in getopt_long
11844	<	do
11845	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11846	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
5106	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5107	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
11843	>
11844	>	echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11845	>	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11846	>	if test "${ac_cv_cpp_func+set}" = set; then
11847		echo $ECHO_N "(cached) $ECHO_C" >&6
11848		else
11849		cat >conftest.$ac_ext <<_ACEOF
#	Line 5113 | Line 11852 | cat >>conftest.$ac_ext <<_ACEOF
11852		cat confdefs.h >>conftest.$ac_ext
11853		cat >>conftest.$ac_ext <<_ACEOF
11854		/* end confdefs.h.  */
5116	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5117	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5118	–	#define $ac_func innocuous_$ac_func
11855
11856	<	/* System header to define __stub macros and hopefully few prototypes,
11857	<	which can conflict with char $ac_func (); below.
11858	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11859	<	<limits.h> exists even on freestanding compilers.  */
11860	<
11861	<	#ifdef __STDC__
5126	<	# include <limits.h>
5127	<	#else
5128	<	# include <assert.h>
11856	>	#ifdef FC_DUMMY_MAIN
11857	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11858	>	#  ifdef __cplusplus
11859	>	extern "C"
11860	>	#  endif
11861	>	int FC_DUMMY_MAIN() { return 1; }
11862		#endif
5130	–
5131	–	#undef $ac_func
5132	–
5133	–	/* Override any gcc2 internal prototype to avoid an error.  */
5134	–	#ifdef __cplusplus
5135	–	extern "C"
5136	–	{
11863		#endif
5138	–	/* We use char because int might match the return type of a gcc2
5139	–	builtin and then its argument prototype would still apply.  */
5140	–	char $ac_func ();
5141	–	/* The GNU C library defines this for functions which it implements
5142	–	to always fail with ENOSYS.  Some functions are actually named
5143	–	something starting with __ and the normal name is an alias.  */
5144	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5145	–	choke me
5146	–	#else
5147	–	char (*f) () = $ac_func;
5148	–	#endif
5149	–	#ifdef __cplusplus
5150	–	}
5151	–	#endif
5152	–
11864		int
11865		main ()
11866		{
11867	<	return f != $ac_func;
11867	>	const char *foo = __func__;
11868		;
11869		return 0;
11870		}
11871		_ACEOF
11872	<	rm -f conftest.$ac_objext conftest$ac_exeext
11873	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11874	<	(eval $ac_link) 2>conftest.er1
11872	>	rm -f conftest.$ac_objext
11873	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11874	>	(eval $ac_compile) 2>conftest.er1
11875		ac_status=$?
11876		grep -v '^ *+' conftest.er1 >conftest.err
11877		rm -f conftest.er1
11878		cat conftest.err >&5
11879		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11880		(exit $ac_status); } &&
11881	<	{ ac_try='test -z "$ac_c_werror_flag"
11881	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11882		|| test ! -s conftest.err'
11883		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11884		(eval $ac_try) 2>&5
11885		ac_status=$?
11886		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11887		(exit $ac_status); }; } &&
11888	<	{ ac_try='test -s conftest$ac_exeext'
11888	>	{ ac_try='test -s conftest.$ac_objext'
11889		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11890		(eval $ac_try) 2>&5
11891		ac_status=$?
11892		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11893		(exit $ac_status); }; }; then
11894	<	eval "$as_ac_var=yes"
11894	>	ac_cv_cpp_func=yes
11895		else
11896		echo "$as_me: failed program was:" >&5
11897		sed 's/^/| /' conftest.$ac_ext >&5
11898
5188	–	eval "$as_ac_var=no"
5189	–	fi
5190	–	rm -f conftest.err conftest.$ac_objext \
5191	–	conftest$ac_exeext conftest.$ac_ext
5192	–	fi
5193	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5194	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5195	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
5196	–	cat >>confdefs.h <<_ACEOF
5197	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5198	–	_ACEOF
5199	–
5200	–	else
5201	–	# FreeBSD has a gnugetopt library for this
5202	–	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5203	–	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5204	–	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5205	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5206	–	else
5207	–	ac_check_lib_save_LIBS=$LIBS
5208	–	LIBS="-lgnugetopt  $LIBS"
11899		cat >conftest.$ac_ext <<_ACEOF
11900		/* confdefs.h.  */
11901		_ACEOF
#	Line 5213 | Line 11903 | cat >>conftest.$ac_ext <<_ACEOF
11903		cat >>conftest.$ac_ext <<_ACEOF
11904		/* end confdefs.h.  */
11905
11906	<	/* Override any gcc2 internal prototype to avoid an error.  */
11907	<	#ifdef __cplusplus
11908	<	extern "C"
11906	>	#ifdef FC_DUMMY_MAIN
11907	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11908	>	#  ifdef __cplusplus
11909	>	extern "C"
11910	>	#  endif
11911	>	int FC_DUMMY_MAIN() { return 1; }
11912		#endif
11913	<	/* We use char because int might match the return type of a gcc2
5221	<	builtin and then its argument prototype would still apply.  */
5222	<	char getopt_long ();
11913	>	#endif
11914		int
11915		main ()
11916		{
11917	<	getopt_long ();
11917	>	const char *foo = __FUNCTION__;
11918		;
11919		return 0;
11920		}
11921		_ACEOF
11922	<	rm -f conftest.$ac_objext conftest$ac_exeext
11923	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11924	<	(eval $ac_link) 2>conftest.er1
11922	>	rm -f conftest.$ac_objext
11923	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11924	>	(eval $ac_compile) 2>conftest.er1
11925		ac_status=$?
11926		grep -v '^ *+' conftest.er1 >conftest.err
11927		rm -f conftest.er1
11928		cat conftest.err >&5
11929		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11930		(exit $ac_status); } &&
11931	<	{ ac_try='test -z "$ac_c_werror_flag"
11931	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11932		|| test ! -s conftest.err'
11933		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11934		(eval $ac_try) 2>&5
11935		ac_status=$?
11936		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11937		(exit $ac_status); }; } &&
11938	<	{ ac_try='test -s conftest$ac_exeext'
11938	>	{ ac_try='test -s conftest.$ac_objext'
11939		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11940		(eval $ac_try) 2>&5
11941		ac_status=$?
11942		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11943		(exit $ac_status); }; }; then
11944	<	ac_cv_lib_gnugetopt_getopt_long=yes
11944	>	ac_cv_cpp_func=__FUNCTION__
11945		else
11946		echo "$as_me: failed program was:" >&5
11947		sed 's/^/| /' conftest.$ac_ext >&5
11948
11949	<	ac_cv_lib_gnugetopt_getopt_long=no
11949	>	ac_cv_cpp_func=no
11950		fi
11951	<	rm -f conftest.err conftest.$ac_objext \
11952	<	conftest$ac_exeext conftest.$ac_ext
11953	<	LIBS=$ac_check_lib_save_LIBS
11954	<	fi
11955	<	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11956	<	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11957	<	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11958	<	cat >>confdefs.h <<\_ACEOF
11959	<	#define HAVE_GETOPT_LONG 1
11951	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11952	>	fi
11953	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11954	>	fi
11955	>	echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11956	>	echo "${ECHO_T}$ac_cv_cpp_func" >&6
11957	>	if test $ac_cv_cpp_func = __FUNCTION__; then
11958	>
11959	>	cat >>confdefs.h <<\_ACEOF
11960	>	#define __func__ __FUNCTION__
11961	>	_ACEOF
11962	>
11963	>	elif test $ac_cv_cpp_func = no; then
11964	>
11965	>	cat >>confdefs.h <<\_ACEOF
11966	>	#define __func__ ""
11967		_ACEOF
11968
11969	+	fi
11970	+
11971	+
11972	+
11973	+
11974	+
11975	+	case $debug in
11976	+	1)
11977	+	;;
11978	+	*)
11979	+
11980	+
11981	+
11982	+
11983	+	# Try to determine "good" native compiler flags if none specified on command
11984	+	# line
11985	+
11986	+	if test "$ac_test_FFLAGS" != "set"; then
11987	+	FCFLAGS=""
11988	+	case "${host_cpu}-${host_os}" in
11989	+
11990	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11991	+	FCFLAGS="-O3 -ip -no-prec-div"
11992	+	fi;;
11993	+	rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11994	+	FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11995	+	fi;;
11996	+	powerpc*-aix*)
11997	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11998	+	FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11999	+	echo "*******************************************************"
12000	+	echo "*  You have AIX on an unknown powerpc system.  It is  *"
12001	+	echo "*  recommended that you use                           *"
12002	+	echo "*                                                     *"
12003	+	echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12004	+	echo "*                                 ^^^                 *"
12005	+	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12006	+	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12007	+	echo "*******************************************************"
12008	+	fi;;
12009	+	*darwin*)
12010	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12011	+	FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12012	+	fi
12013	+	if test "$FC" = ifort; then
12014	+	FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12015	+	fi;;
12016	+	esac
12017	+
12018	+	if test -n "$CPU_FLAGS"; then
12019	+	FCFLAGS="$FCFLAGS $CPU_FLAGS"
12020	+	fi
12021	+
12022	+	if test -z "$FCFLAGS"; then
12023	+	echo ""
12024	+	echo "*********************************************************"
12025	+	echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12026	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12027	+	echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12028	+	echo "*********************************************************"
12029	+	echo ""
12030	+	FCFLAGS="-O3"
12031	+	fi
12032	+
12033	+
12034	+	echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12035	+	echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12036	+	if test "${ac_guessed_f90flags+set}" = set; then
12037	+	echo $ECHO_N "(cached) $ECHO_C" >&6
12038		else
5272	–	# use the GNU replacement
5273	–	case $LIBOBJS in
5274	–	"getopt.$ac_objext"   | \
5275	–	*" getopt.$ac_objext"   | \
5276	–	"getopt.$ac_objext "* | \
5277	–	*" getopt.$ac_objext "* ) ;;
5278	–	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5279	–	esac
12039
5281	–	case $LIBOBJS in
5282	–	"getopt1.$ac_objext"   | \
5283	–	*" getopt1.$ac_objext"   | \
5284	–	"getopt1.$ac_objext "* | \
5285	–	*" getopt1.$ac_objext "* ) ;;
5286	–	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5287	–	esac
12040
5289	–	ac_config_links="$ac_config_links src/utils/getopt.h:src/utils/gnugetopt.h"
12041
12042	+	ac_ext=${FC_SRCEXT-f}
12043	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12044	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12045	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12046	+
12047	+	echo 'program main' > conftest.$ac_ext
12048	+	echo 'end program main' >> conftest.$ac_ext
12049	+	ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12050	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12051	+	(eval $ac_compile) 2>&5
12052	+	ac_status=$?
12053	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12054	+	(exit $ac_status); }; then
12055	+	ac_guessed_f90flags=yes
12056	+	else
12057	+	ac_guessed_f90flags=no
12058		fi
12059	+	rm -f conftest*
12060	+	ac_ext=cc
12061	+	ac_cpp='$CXXCPP $CPPFLAGS'
12062	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12063	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12064	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12065
12066	+
12067		fi
12068	<	done
12068	>	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12069	>	echo "${ECHO_T}$ac_guessed_f90flags" >&6
12070	>	if test "$ac_guessed_f90flags" = yes; then
12071	>	:
12072
12073	+	else
12074	+	:
12075
12076	+	echo ""
12077	+	echo "**********************************************************"
12078	+	echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12079	+	echo "* your compiler.                                        *"
12080	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12081	+	echo "*********************************************************"
12082	+	echo ""
12083	+	FCFLAGS=""
12084
12085	<	case $debug in
5299	<	1)
5300	<	;;
5301	<	*)
12085	>	fi
12086
12087
12088	+	fi
12089
12090
12091
12092
12093	+
12094	+
12095	+
12096		echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12097		echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12098		if test "${ac_cv_prog_really_gcc+set}" = set; then
#	Line 5313 | Line 12101 | cat > conftest.c <<EOF
12101
12102		cat > conftest.c <<EOF
12103		#ifdef __GNUC__
12104	<	#ifndef __INTEL_COMPILER
12104	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12105	>	no;
12106	>	#else
12107		yes;
12108		#endif
12109		#endif
#	Line 5351 | Line 12141 | if test "$ac_test_CFLAGS" != "set"; then
12141		CFLAGS="-O"
12142		fi;;
12143		sparc-solaris2*) if test "$CC" = cc; then
12144	<	CFLAGS="-native -fast -xO5 -dalign"
12144	>	CFLAGS="-O -dalign"
12145		fi;;
12146
12147		alpha*-osf*)  if test "$CC" = cc; then
#	Line 5381 | Line 12171 | if test "$ac_test_CFLAGS" != "set"; then
12171		*darwin*)
12172		if test "$CC" = xlc -o "$CC" = cc; then
12173		CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12174	+	fi
12175	+	if test "$CC" = icc; then
12176	+	CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12177		fi;;
12178		esac
12179
#	Line 5394 | Line 12187 | if test "$ac_test_CFLAGS" != "set"; then
12187		# -malign-double for x86 systems
12188
12189
12190	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12191	<	echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12190	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12191	>	echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12192		if test "${ac_align_double+set}" = set; then
12193		echo $ECHO_N "(cached) $ECHO_C" >&6
12194		else
12195		echo 'void f(){}' > conftest.c
12196	<	if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12196	>	if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12197		ac_align_double=yes
12198		else
12199		ac_align_double=no
#	Line 5421 | Line 12214 | fi
12214		# -fstrict-aliasing for gcc-2.95+
12215
12216
12217	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12218	<	echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12217	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12218	>	echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12219		if test "${ac_fstrict_aliasing+set}" = set; then
12220		echo $ECHO_N "(cached) $ECHO_C" >&6
12221		else
12222		echo 'void f(){}' > conftest.c
12223	<	if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12223	>	if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12224		ac_fstrict_aliasing=yes
12225		else
12226		ac_fstrict_aliasing=no
#	Line 5452 | Line 12245 | fi
12245		case "${host_cpu}" in
12246		i586*)
12247
12248	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12249	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12248	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12249	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12250		if test "${ac_cpu_pentium+set}" = set; then
12251		echo $ECHO_N "(cached) $ECHO_C" >&6
12252		else
12253		echo 'void f(){}' > conftest.c
12254	<	if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12254	>	if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12255		ac_cpu_pentium=yes
12256		else
12257		ac_cpu_pentium=no
#	Line 5475 | Line 12268 | else
12268		:
12269
12270
12271	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12272	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12271	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12272	>	echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12273		if test "${ac_pentium+set}" = set; then
12274		echo $ECHO_N "(cached) $ECHO_C" >&6
12275		else
12276		echo 'void f(){}' > conftest.c
12277	<	if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12277	>	if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12278		ac_pentium=yes
12279		else
12280		ac_pentium=no
#	Line 5504 | Line 12297 | fi
12297		;;
12298		i686*)
12299
12300	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12301	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12300	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12301	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12302		if test "${ac_cpu_pentiumpro+set}" = set; then
12303		echo $ECHO_N "(cached) $ECHO_C" >&6
12304		else
12305		echo 'void f(){}' > conftest.c
12306	<	if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12306	>	if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12307		ac_cpu_pentiumpro=yes
12308		else
12309		ac_cpu_pentiumpro=no
#	Line 5527 | Line 12320 | else
12320		:
12321
12322
12323	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12324	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12323	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12324	>	echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12325		if test "${ac_pentiumpro+set}" = set; then
12326		echo $ECHO_N "(cached) $ECHO_C" >&6
12327		else
12328		echo 'void f(){}' > conftest.c
12329	<	if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12329	>	if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12330		ac_pentiumpro=yes
12331		else
12332		ac_pentiumpro=no
#	Line 5560 | Line 12353 | fi
12353		if test -n "$is60x"; then
12354
12355
12356	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12357	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12356	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12357	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12358		if test "${ac_m_cpu_60x+set}" = set; then
12359		echo $ECHO_N "(cached) $ECHO_C" >&6
12360		else
12361		echo 'void f(){}' > conftest.c
12362	<	if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12362	>	if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12363		ac_m_cpu_60x=yes
12364		else
12365		ac_m_cpu_60x=no
#	Line 5618 | Line 12411 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12411		:
12412
12413
12414	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12415	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12414	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12415	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12416		if test "${ac_m_cpu_750+set}" = set; then
12417		echo $ECHO_N "(cached) $ECHO_C" >&6
12418		else
12419		echo 'void f(){}' > conftest.c
12420	<	if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12420	>	if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12421		ac_m_cpu_750=yes
12422		else
12423		ac_m_cpu_750=no
#	Line 5651 | Line 12444 | fi
12444		if test -z "$CPU_FLAGS"; then
12445
12446
12447	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12448	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12447	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12448	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12449		if test "${ac_m_cpu_powerpc+set}" = set; then
12450		echo $ECHO_N "(cached) $ECHO_C" >&6
12451		else
12452		echo 'void f(){}' > conftest.c
12453	<	if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12453	>	if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12454		ac_m_cpu_powerpc=yes
12455		else
12456		ac_m_cpu_powerpc=no
#	Line 5679 | Line 12472 | fi
12472		if test -z "$CPU_FLAGS"; then
12473
12474
12475	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12476	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12475	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12476	>	echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12477		if test "${ac_m_powerpc+set}" = set; then
12478		echo $ECHO_N "(cached) $ECHO_C" >&6
12479		else
12480		echo 'void f(){}' > conftest.c
12481	<	if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12481	>	if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12482		ac_m_powerpc=yes
12483		else
12484		ac_m_powerpc=no
#	Line 5724 | Line 12517 | fi
12517
12518
12519
12520	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12521	<	echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12520	>	echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12521	>	echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12522		if test "${ac_guessed_cflags+set}" = set; then
12523		echo $ECHO_N "(cached) $ECHO_C" >&6
12524		else
12525		echo 'void f(){}' > conftest.c
12526	<	if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12526	>	if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12527		ac_guessed_cflags=yes
12528		else
12529		ac_guessed_cflags=no
#	Line 5774 | Line 12567 | cat > conftest.cpp <<EOF
12567
12568		cat > conftest.cpp <<EOF
12569		#ifdef __GNUC__
12570	<	#ifndef __INTEL_COMPILER
12570	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12571	>	no;
12572	>	#else
12573		yes;
12574		#endif
12575		#endif
#	Line 5812 | Line 12607 | if test "$ac_test_CXXFLAGS" != "set"; then
12607		CXXFLAGS="-O"
12608		fi;;
12609		sparc-solaris2*) if test "$CXX" = CC; then
12610	<	CXXFLAGS="-native -fast -xO5 -dalign"
12610	>	CXXFLAGS="-features=extensions -O -dalign"
12611		fi;;
12612		rs6000*-aix*)  if test "$CXX" = xlC; then
12613		CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
#	Line 5831 | Line 12626 | if test "$ac_test_CXXFLAGS" != "set"; then
12626		echo "*******************************************************"
12627		fi;;
12628		*darwin*)
12629	<	if test "$CXX" = xlc++; then
12629	>	if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12630		CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12631	+	fi
12632	+	if test "$CXX" = icpc; then
12633	+	CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12634		fi;;
12635		esac
12636
#	Line 5846 | Line 12644 | if test "$ac_test_CXXFLAGS" != "set"; then
12644		# -malign-double for x86 systems
12645
12646
12647	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12648	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12647	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12648	>	echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12649		if test "${ac_align_double+set}" = set; then
12650		echo $ECHO_N "(cached) $ECHO_C" >&6
12651		else
12652		echo 'void f(){}' > conftest.cpp
12653	<	if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12653	>	if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12654		ac_align_double=yes
12655		else
12656		ac_align_double=no
#	Line 5873 | Line 12671 | fi
12671		# -fstrict-aliasing for gcc-2.95+
12672
12673
12674	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12675	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12674	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12675	>	echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12676		if test "${ac_fstrict_aliasing+set}" = set; then
12677		echo $ECHO_N "(cached) $ECHO_C" >&6
12678		else
12679		echo 'void f(){}' > conftest.cpp
12680	<	if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12680	>	if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12681		ac_fstrict_aliasing=yes
12682		else
12683		ac_fstrict_aliasing=no
#	Line 5904 | Line 12702 | fi
12702		case "${host_cpu}" in
12703		i586*)
12704
12705	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12706	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12705	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12706	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12707		if test "${ac_cpu_pentium+set}" = set; then
12708		echo $ECHO_N "(cached) $ECHO_C" >&6
12709		else
12710		echo 'void f(){}' > conftest.cpp
12711	<	if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12711	>	if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12712		ac_cpu_pentium=yes
12713		else
12714		ac_cpu_pentium=no
#	Line 5927 | Line 12725 | else
12725		:
12726
12727
12728	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12729	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12728	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12729	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12730		if test "${ac_pentium+set}" = set; then
12731		echo $ECHO_N "(cached) $ECHO_C" >&6
12732		else
12733		echo 'void f(){}' > conftest.cpp
12734	<	if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12734	>	if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12735		ac_pentium=yes
12736		else
12737		ac_pentium=no
#	Line 5956 | Line 12754 | fi
12754		;;
12755		i686*)
12756
12757	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12758	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12757	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12758	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12759		if test "${ac_cpu_pentiumpro+set}" = set; then
12760		echo $ECHO_N "(cached) $ECHO_C" >&6
12761		else
12762		echo 'void f(){}' > conftest.cpp
12763	<	if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12763	>	if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12764		ac_cpu_pentiumpro=yes
12765		else
12766		ac_cpu_pentiumpro=no
#	Line 5979 | Line 12777 | else
12777		:
12778
12779
12780	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12781	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12780	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12781	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12782		if test "${ac_pentiumpro+set}" = set; then
12783		echo $ECHO_N "(cached) $ECHO_C" >&6
12784		else
12785		echo 'void f(){}' > conftest.cpp
12786	<	if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12786	>	if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12787		ac_pentiumpro=yes
12788		else
12789		ac_pentiumpro=no
#	Line 6012 | Line 12810 | fi
12810		if test -n "$is60x"; then
12811
12812
12813	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12814	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12813	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12814	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12815		if test "${ac_m_cpu_60x+set}" = set; then
12816		echo $ECHO_N "(cached) $ECHO_C" >&6
12817		else
12818		echo 'void f(){}' > conftest.cpp
12819	<	if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12819	>	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12820		ac_m_cpu_60x=yes
12821		else
12822		ac_m_cpu_60x=no
#	Line 6070 | Line 12868 | if test "$ac_cv_prog_gxx_2_95" = yes; then
12868		:
12869
12870
12871	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12872	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12871	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12872	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12873		if test "${ac_m_cpu_750+set}" = set; then
12874		echo $ECHO_N "(cached) $ECHO_C" >&6
12875		else
12876		echo 'void f(){}' > conftest.cpp
12877	<	if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12877	>	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12878		ac_m_cpu_750=yes
12879		else
12880		ac_m_cpu_750=no
#	Line 6103 | Line 12901 | fi
12901		if test -z "$CPU_FLAGS"; then
12902
12903
12904	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12905	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12904	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12905	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12906		if test "${ac_m_cpu_powerpc+set}" = set; then
12907		echo $ECHO_N "(cached) $ECHO_C" >&6
12908		else
12909		echo 'void f(){}' > conftest.cpp
12910	<	if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12910	>	if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12911		ac_m_cpu_powerpc=yes
12912		else
12913		ac_m_cpu_powerpc=no
#	Line 6131 | Line 12929 | fi
12929		if test -z "$CPU_FLAGS"; then
12930
12931
12932	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12933	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12932	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12933	>	echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12934		if test "${ac_m_powerpc+set}" = set; then
12935		echo $ECHO_N "(cached) $ECHO_C" >&6
12936		else
12937		echo 'void f(){}' > conftest.cpp
12938	<	if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12938	>	if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12939		ac_m_powerpc=yes
12940		else
12941		ac_m_powerpc=no
#	Line 6176 | Line 12974 | fi
12974
12975
12976
12977	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12978	<	echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12977	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12978	>	echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12979		if test "${ac_guessed_cxxflags+set}" = set; then
12980		echo $ECHO_N "(cached) $ECHO_C" >&6
12981		else
12982		echo 'void f(){}' > conftest.cpp
12983	<	if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12983	>	if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12984		ac_guessed_cxxflags=yes
12985		else
12986		ac_guessed_cxxflags=no
#	Line 6206 | Line 13004 | else
13004		echo "**********************************************************"
13005		echo ""
13006		CXXFLAGS=""
6209	–
6210	–	fi
6211	–
6212	–
6213	–	fi
6214	–
6215	–
6216	–
6217	–
6218	–
6219	–	# Try to determine "good" native compiler flags if none specified on command
6220	–	# line
6221	–
6222	–	if test x"$F90FLAGS" = x ; then
6223	–	F90FLAGS=""
6224	–	case "${host_cpu}-${host_os}" in
6225	–
6226	–	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6227	–	F90FLAGS="-O"
6228	–	fi;;
6229	–	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6230	–	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6231	–	fi;;
6232	–	powerpc*-aix*)
6233	–	if test "$F90" = f90 -o "$F90" = xlf90; then
6234	–	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6235	–	echo "*******************************************************"
6236	–	echo "*  You have AIX on an unknown powerpc system.  It is  *"
6237	–	echo "*  recommended that you use                           *"
6238	–	echo "*                                                     *"
6239	–	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6240	–	echo "*                                 ^^^                 *"
6241	–	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6242	–	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6243	–	echo "*******************************************************"
6244	–	fi;;
6245	–	*darwin*)
6246	–	if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6247	–	F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6248	–	fi;;
6249	–	esac
6250	–
6251	–	if test -n "$CPU_FLAGS"; then
6252	–	F90FLAGS="$F90FLAGS $CPU_FLAGS"
6253	–	fi
6254	–
6255	–	if test -z "$F90FLAGS"; then
6256	–	echo ""
6257	–	echo "**********************************************************"
6258	–	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6259	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6260	–	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6261	–	echo "**********************************************************"
6262	–	echo ""
6263	–	F90FLAGS="-O3"
6264	–	fi
6265	–
6266	–
6267	–	echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6268	–	echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6269	–	if test "${ac_guessed_f90flags+set}" = set; then
6270	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6271	–	else
6272	–
6273	–
6274	–
6275	–	ac_ext=f90
6276	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6277	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6278	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6279	–
6280	–	echo 'program main' > conftest.$ac_ext
6281	–	echo 'end program main' >> conftest.$ac_ext
6282	–	ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6283	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6284	–	(eval $ac_compile) 2>&5
6285	–	ac_status=$?
6286	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6287	–	(exit $ac_status); }; then
6288	–	ac_guessed_f90flags=yes
6289	–	else
6290	–	ac_guessed_f90flags=no
6291	–	fi
6292	–	rm -f conftest*
6293	–	ac_ext=c
6294	–	ac_cpp='$CPP $CPPFLAGS'
6295	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6296	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6297	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6298	–
6299	–
6300	–	fi
6301	–	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6302	–	echo "${ECHO_T}$ac_guessed_f90flags" >&6
6303	–	if test "$ac_guessed_f90flags" = yes; then
6304	–	:
13007
6306	–	else
6307	–	:
6308	–
6309	–	echo ""
6310	–	echo "**********************************************************"
6311	–	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6312	–	echo "* your compiler.                                         *"
6313	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6314	–	echo "**********************************************************"
6315	–	echo ""
6316	–	F90FLAGS=""
6317	–
13008		fi
13009
13010
#	Line 6323 | Line 13013 | esac
13013		;;
13014		esac
13015
6326	–	# Find a good install program.  We prefer a C program (faster),
6327	–	# so one script is as good as another.  But avoid the broken or
6328	–	# incompatible versions:
6329	–	# SysV /etc/install, /usr/sbin/install
6330	–	# SunOS /usr/etc/install
6331	–	# IRIX /sbin/install
6332	–	# AIX /bin/install
6333	–	# AmigaOS /C/install, which installs bootblocks on floppy discs
6334	–	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6335	–	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
6336	–	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6337	–	# OS/2's system install, which has a completely different semantic
6338	–	# ./install, which can be erroneously created by make from ./install.sh.
6339	–	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6340	–	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6341	–	if test -z "$INSTALL"; then
6342	–	if test "${ac_cv_path_install+set}" = set; then
6343	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6344	–	else
6345	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6346	–	for as_dir in $PATH
6347	–	do
6348	–	IFS=$as_save_IFS
6349	–	test -z "$as_dir" && as_dir=.
6350	–	# Account for people who put trailing slashes in PATH elements.
6351	–	case $as_dir/ in
6352	–	./ | .// | /cC/* | \
6353	–	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6354	–	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6355	–	/usr/ucb/* ) ;;
6356	–	*)
6357	–	# OSF1 and SCO ODT 3.0 have their own names for install.
6358	–	# Don't use installbsd from OSF since it installs stuff as root
6359	–	# by default.
6360	–	for ac_prog in ginstall scoinst install; do
6361	–	for ac_exec_ext in '' $ac_executable_extensions; do
6362	–	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6363	–	if test $ac_prog = install &&
6364	–	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6365	–	# AIX install.  It has an incompatible calling convention.
6366	–	:
6367	–	elif test $ac_prog = install &&
6368	–	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6369	–	# program-specific install script used by HP pwplus--don't use.
6370	–	:
6371	–	else
6372	–	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6373	–	break 3
6374	–	fi
6375	–	fi
6376	–	done
6377	–	done
6378	–	;;
6379	–	esac
6380	–	done
13016
6382	–
6383	–	fi
6384	–	if test "${ac_cv_path_install+set}" = set; then
6385	–	INSTALL=$ac_cv_path_install
6386	–	else
6387	–	# As a last resort, use the slow shell script.  We don't cache a
6388	–	# path for INSTALL within a source directory, because that will
6389	–	# break other packages using the cache if that directory is
6390	–	# removed, or if the path is relative.
6391	–	INSTALL=$ac_install_sh
6392	–	fi
6393	–	fi
6394	–	echo "$as_me:$LINENO: result: $INSTALL" >&5
6395	–	echo "${ECHO_T}$INSTALL" >&6
6396	–
6397	–	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6398	–	# It thinks the first close brace ends the variable substitution.
6399	–	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6400	–
6401	–	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6402	–
6403	–	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6404	–
6405	–	echo "$as_me:$LINENO: checking whether ln -s works" >&5
6406	–	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6407	–	LN_S=$as_ln_s
6408	–	if test "$LN_S" = "ln -s"; then
6409	–	echo "$as_me:$LINENO: result: yes" >&5
6410	–	echo "${ECHO_T}yes" >&6
6411	–	else
6412	–	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6413	–	echo "${ECHO_T}no, using $LN_S" >&6
6414	–	fi
6415	–
6416	–	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6417	–	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6418	–	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6419	–	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6420	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6421	–	else
6422	–	cat >conftest.make <<\_ACEOF
6423	–	all:
6424	–	@echo 'ac_maketemp="$(MAKE)"'
6425	–	_ACEOF
6426	–	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6427	–	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6428	–	if test -n "$ac_maketemp"; then
6429	–	eval ac_cv_prog_make_${ac_make}_set=yes
6430	–	else
6431	–	eval ac_cv_prog_make_${ac_make}_set=no
6432	–	fi
6433	–	rm -f conftest.make
6434	–	fi
6435	–	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6436	–	echo "$as_me:$LINENO: result: yes" >&5
6437	–	echo "${ECHO_T}yes" >&6
6438	–	SET_MAKE=
6439	–	else
6440	–	echo "$as_me:$LINENO: result: no" >&5
6441	–	echo "${ECHO_T}no" >&6
6442	–	SET_MAKE="MAKE=${MAKE-make}"
6443	–	fi
6444	–
6445	–	if test -n "$ac_tool_prefix"; then
6446	–	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6447	–	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6448	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6449	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6450	–	if test "${ac_cv_prog_RANLIB+set}" = set; then
6451	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6452	–	else
6453	–	if test -n "$RANLIB"; then
6454	–	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6455	–	else
6456	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6457	–	for as_dir in $PATH
6458	–	do
6459	–	IFS=$as_save_IFS
6460	–	test -z "$as_dir" && as_dir=.
6461	–	for ac_exec_ext in '' $ac_executable_extensions; do
6462	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6463	–	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6464	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6465	–	break 2
6466	–	fi
6467	–	done
6468	–	done
6469	–
6470	–	fi
6471	–	fi
6472	–	RANLIB=$ac_cv_prog_RANLIB
6473	–	if test -n "$RANLIB"; then
6474	–	echo "$as_me:$LINENO: result: $RANLIB" >&5
6475	–	echo "${ECHO_T}$RANLIB" >&6
6476	–	else
6477	–	echo "$as_me:$LINENO: result: no" >&5
6478	–	echo "${ECHO_T}no" >&6
6479	–	fi
6480	–
6481	–	fi
6482	–	if test -z "$ac_cv_prog_RANLIB"; then
6483	–	ac_ct_RANLIB=$RANLIB
6484	–	# Extract the first word of "ranlib", so it can be a program name with args.
6485	–	set dummy ranlib; ac_word=$2
6486	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6487	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6488	–	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6489	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6490	–	else
6491	–	if test -n "$ac_ct_RANLIB"; then
6492	–	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6493	–	else
6494	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6495	–	for as_dir in $PATH
6496	–	do
6497	–	IFS=$as_save_IFS
6498	–	test -z "$as_dir" && as_dir=.
6499	–	for ac_exec_ext in '' $ac_executable_extensions; do
6500	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6501	–	ac_cv_prog_ac_ct_RANLIB="ranlib"
6502	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6503	–	break 2
6504	–	fi
6505	–	done
6506	–	done
6507	–
6508	–	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6509	–	fi
6510	–	fi
6511	–	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6512	–	if test -n "$ac_ct_RANLIB"; then
6513	–	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6514	–	echo "${ECHO_T}$ac_ct_RANLIB" >&6
6515	–	else
6516	–	echo "$as_me:$LINENO: result: no" >&5
6517	–	echo "${ECHO_T}no" >&6
6518	–	fi
6519	–
6520	–	RANLIB=$ac_ct_RANLIB
6521	–	else
6522	–	RANLIB="$ac_cv_prog_RANLIB"
6523	–	fi
6524	–
6525	–	for ac_prog in 'bison -y' byacc
6526	–	do
6527	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6528	–	set dummy $ac_prog; ac_word=$2
6529	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6530	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6531	–	if test "${ac_cv_prog_YACC+set}" = set; then
6532	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6533	–	else
6534	–	if test -n "$YACC"; then
6535	–	ac_cv_prog_YACC="$YACC" # Let the user override the test.
6536	–	else
6537	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6538	–	for as_dir in $PATH
6539	–	do
6540	–	IFS=$as_save_IFS
6541	–	test -z "$as_dir" && as_dir=.
6542	–	for ac_exec_ext in '' $ac_executable_extensions; do
6543	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6544	–	ac_cv_prog_YACC="$ac_prog"
6545	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6546	–	break 2
6547	–	fi
6548	–	done
6549	–	done
6550	–
6551	–	fi
6552	–	fi
6553	–	YACC=$ac_cv_prog_YACC
6554	–	if test -n "$YACC"; then
6555	–	echo "$as_me:$LINENO: result: $YACC" >&5
6556	–	echo "${ECHO_T}$YACC" >&6
6557	–	else
6558	–	echo "$as_me:$LINENO: result: no" >&5
6559	–	echo "${ECHO_T}no" >&6
6560	–	fi
6561	–
6562	–	test -n "$YACC" && break
6563	–	done
6564	–	test -n "$YACC" || YACC="yacc"
6565	–
6566	–	for ac_prog in flex lex
6567	–	do
6568	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6569	–	set dummy $ac_prog; ac_word=$2
6570	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6571	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6572	–	if test "${ac_cv_prog_LEX+set}" = set; then
6573	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6574	–	else
6575	–	if test -n "$LEX"; then
6576	–	ac_cv_prog_LEX="$LEX" # Let the user override the test.
6577	–	else
6578	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6579	–	for as_dir in $PATH
6580	–	do
6581	–	IFS=$as_save_IFS
6582	–	test -z "$as_dir" && as_dir=.
6583	–	for ac_exec_ext in '' $ac_executable_extensions; do
6584	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6585	–	ac_cv_prog_LEX="$ac_prog"
6586	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6587	–	break 2
6588	–	fi
6589	–	done
6590	–	done
6591	–
6592	–	fi
6593	–	fi
6594	–	LEX=$ac_cv_prog_LEX
6595	–	if test -n "$LEX"; then
6596	–	echo "$as_me:$LINENO: result: $LEX" >&5
6597	–	echo "${ECHO_T}$LEX" >&6
6598	–	else
6599	–	echo "$as_me:$LINENO: result: no" >&5
6600	–	echo "${ECHO_T}no" >&6
6601	–	fi
6602	–
6603	–	test -n "$LEX" && break
6604	–	done
6605	–	test -n "$LEX" || LEX=":"
6606	–
6607	–	if test -z "$LEXLIB"
6608	–	then
6609	–	echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6610	–	echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6611	–	if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6612	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6613	–	else
6614	–	ac_check_lib_save_LIBS=$LIBS
6615	–	LIBS="-lfl  $LIBS"
6616	–	cat >conftest.$ac_ext <<_ACEOF
6617	–	/* confdefs.h.  */
6618	–	_ACEOF
6619	–	cat confdefs.h >>conftest.$ac_ext
6620	–	cat >>conftest.$ac_ext <<_ACEOF
6621	–	/* end confdefs.h.  */
6622	–
6623	–	/* Override any gcc2 internal prototype to avoid an error.  */
6624	–	#ifdef __cplusplus
6625	–	extern "C"
6626	–	#endif
6627	–	/* We use char because int might match the return type of a gcc2
6628	–	builtin and then its argument prototype would still apply.  */
6629	–	char yywrap ();
6630	–	int
6631	–	main ()
6632	–	{
6633	–	yywrap ();
6634	–	;
6635	–	return 0;
6636	–	}
6637	–	_ACEOF
6638	–	rm -f conftest.$ac_objext conftest$ac_exeext
6639	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6640	–	(eval $ac_link) 2>conftest.er1
6641	–	ac_status=$?
6642	–	grep -v '^ *+' conftest.er1 >conftest.err
6643	–	rm -f conftest.er1
6644	–	cat conftest.err >&5
6645	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6646	–	(exit $ac_status); } &&
6647	–	{ ac_try='test -z "$ac_c_werror_flag"
6648	–	|| test ! -s conftest.err'
6649	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650	–	(eval $ac_try) 2>&5
6651	–	ac_status=$?
6652	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653	–	(exit $ac_status); }; } &&
6654	–	{ ac_try='test -s conftest$ac_exeext'
6655	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6656	–	(eval $ac_try) 2>&5
6657	–	ac_status=$?
6658	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6659	–	(exit $ac_status); }; }; then
6660	–	ac_cv_lib_fl_yywrap=yes
6661	–	else
6662	–	echo "$as_me: failed program was:" >&5
6663	–	sed 's/^/| /' conftest.$ac_ext >&5
6664	–
6665	–	ac_cv_lib_fl_yywrap=no
6666	–	fi
6667	–	rm -f conftest.err conftest.$ac_objext \
6668	–	conftest$ac_exeext conftest.$ac_ext
6669	–	LIBS=$ac_check_lib_save_LIBS
6670	–	fi
6671	–	echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6672	–	echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6673	–	if test $ac_cv_lib_fl_yywrap = yes; then
6674	–	LEXLIB="-lfl"
6675	–	else
6676	–	echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6677	–	echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6678	–	if test "${ac_cv_lib_l_yywrap+set}" = set; then
6679	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6680	–	else
6681	–	ac_check_lib_save_LIBS=$LIBS
6682	–	LIBS="-ll  $LIBS"
6683	–	cat >conftest.$ac_ext <<_ACEOF
6684	–	/* confdefs.h.  */
6685	–	_ACEOF
6686	–	cat confdefs.h >>conftest.$ac_ext
6687	–	cat >>conftest.$ac_ext <<_ACEOF
6688	–	/* end confdefs.h.  */
6689	–
6690	–	/* Override any gcc2 internal prototype to avoid an error.  */
6691	–	#ifdef __cplusplus
6692	–	extern "C"
6693	–	#endif
6694	–	/* We use char because int might match the return type of a gcc2
6695	–	builtin and then its argument prototype would still apply.  */
6696	–	char yywrap ();
6697	–	int
6698	–	main ()
6699	–	{
6700	–	yywrap ();
6701	–	;
6702	–	return 0;
6703	–	}
6704	–	_ACEOF
6705	–	rm -f conftest.$ac_objext conftest$ac_exeext
6706	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6707	–	(eval $ac_link) 2>conftest.er1
6708	–	ac_status=$?
6709	–	grep -v '^ *+' conftest.er1 >conftest.err
6710	–	rm -f conftest.er1
6711	–	cat conftest.err >&5
6712	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6713	–	(exit $ac_status); } &&
6714	–	{ ac_try='test -z "$ac_c_werror_flag"
6715	–	|| test ! -s conftest.err'
6716	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6717	–	(eval $ac_try) 2>&5
6718	–	ac_status=$?
6719	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6720	–	(exit $ac_status); }; } &&
6721	–	{ ac_try='test -s conftest$ac_exeext'
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); }; }; then
6727	–	ac_cv_lib_l_yywrap=yes
6728	–	else
6729	–	echo "$as_me: failed program was:" >&5
6730	–	sed 's/^/| /' conftest.$ac_ext >&5
6731	–
6732	–	ac_cv_lib_l_yywrap=no
6733	–	fi
6734	–	rm -f conftest.err conftest.$ac_objext \
6735	–	conftest$ac_exeext conftest.$ac_ext
6736	–	LIBS=$ac_check_lib_save_LIBS
6737	–	fi
6738	–	echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6739	–	echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6740	–	if test $ac_cv_lib_l_yywrap = yes; then
6741	–	LEXLIB="-ll"
6742	–	fi
6743	–
6744	–	fi
6745	–
6746	–	fi
6747	–
6748	–	if test "x$LEX" != "x:"; then
6749	–	echo "$as_me:$LINENO: checking lex output file root" >&5
6750	–	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6751	–	if test "${ac_cv_prog_lex_root+set}" = set; then
6752	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6753	–	else
6754	–	# The minimal lex program is just a single line: %%.  But some broken lexes
6755	–	# (Solaris, I think it was) want two %% lines, so accommodate them.
6756	–	cat >conftest.l <<_ACEOF
6757	–	%%
6758	–	%%
6759	–	_ACEOF
6760	–	{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6761	–	(eval $LEX conftest.l) 2>&5
6762	–	ac_status=$?
6763	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6764	–	(exit $ac_status); }
6765	–	if test -f lex.yy.c; then
6766	–	ac_cv_prog_lex_root=lex.yy
6767	–	elif test -f lexyy.c; then
6768	–	ac_cv_prog_lex_root=lexyy
6769	–	else
6770	–	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6771	–	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6772	–	{ (exit 1); exit 1; }; }
6773	–	fi
6774	–	fi
6775	–	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6776	–	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6777	–	rm -f conftest.l
6778	–	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6779	–
6780	–	echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6781	–	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6782	–	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6783	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6784	–	else
6785	–	# POSIX says lex can declare yytext either as a pointer or an array; the
6786	–	# default is implementation-dependent. Figure out which it is, since
6787	–	# not all implementations provide the %pointer and %array declarations.
6788	–	ac_cv_prog_lex_yytext_pointer=no
6789	–	echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6790	–	ac_save_LIBS=$LIBS
6791	–	LIBS="$LIBS $LEXLIB"
6792	–	cat >conftest.$ac_ext <<_ACEOF
6793	–	`cat $LEX_OUTPUT_ROOT.c`
6794	–	_ACEOF
6795	–	rm -f conftest.$ac_objext conftest$ac_exeext
6796	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6797	–	(eval $ac_link) 2>conftest.er1
6798	–	ac_status=$?
6799	–	grep -v '^ *+' conftest.er1 >conftest.err
6800	–	rm -f conftest.er1
6801	–	cat conftest.err >&5
6802	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6803	–	(exit $ac_status); } &&
6804	–	{ ac_try='test -z "$ac_c_werror_flag"
6805	–	|| test ! -s conftest.err'
6806	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807	–	(eval $ac_try) 2>&5
6808	–	ac_status=$?
6809	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810	–	(exit $ac_status); }; } &&
6811	–	{ ac_try='test -s conftest$ac_exeext'
6812	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6813	–	(eval $ac_try) 2>&5
6814	–	ac_status=$?
6815	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6816	–	(exit $ac_status); }; }; then
6817	–	ac_cv_prog_lex_yytext_pointer=yes
6818	–	else
6819	–	echo "$as_me: failed program was:" >&5
6820	–	sed 's/^/| /' conftest.$ac_ext >&5
6821	–
6822	–	fi
6823	–	rm -f conftest.err conftest.$ac_objext \
6824	–	conftest$ac_exeext conftest.$ac_ext
6825	–	LIBS=$ac_save_LIBS
6826	–	rm -f "${LEX_OUTPUT_ROOT}.c"
6827	–
6828	–	fi
6829	–	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6830	–	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6831	–	if test $ac_cv_prog_lex_yytext_pointer = yes; then
6832	–
13017		cat >>confdefs.h <<\_ACEOF
13018	<	#define YYTEXT_POINTER 1
13018	>	#define OBAPI
13019		_ACEOF
13020
6837	–	fi
13021
6839	–	fi
6840	–	# Extract the first word of "ar", so it can be a program name with args.
6841	–	set dummy ar; ac_word=$2
6842	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6843	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6844	–	if test "${ac_cv_prog_AR+set}" = set; then
6845	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6846	–	else
6847	–	if test -n "$AR"; then
6848	–	ac_cv_prog_AR="$AR" # Let the user override the test.
6849	–	else
6850	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6851	–	for as_dir in $PATH
6852	–	do
6853	–	IFS=$as_save_IFS
6854	–	test -z "$as_dir" && as_dir=.
6855	–	for ac_exec_ext in '' $ac_executable_extensions; do
6856	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6857	–	ac_cv_prog_AR="ar"
6858	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6859	–	break 2
6860	–	fi
6861	–	done
6862	–	done
13022
6864	–	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
6865	–	fi
6866	–	fi
6867	–	AR=$ac_cv_prog_AR
6868	–	if test -n "$AR"; then
6869	–	echo "$as_me:$LINENO: result: $AR" >&5
6870	–	echo "${ECHO_T}$AR" >&6
6871	–	else
6872	–	echo "$as_me:$LINENO: result: no" >&5
6873	–	echo "${ECHO_T}no" >&6
6874	–	fi
13023
6876	–	if test "$AR" = "NONE"; then
6877	–	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6878	–	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6879	–	{ (exit 1); exit 1; }; }
6880	–	cat >confcache <<\_ACEOF
6881	–	# This file is a shell script that caches the results of configure
6882	–	# tests run on this system so they can be shared between configure
6883	–	# scripts and configure runs, see configure's option --config-cache.
6884	–	# It is not useful on other systems.  If it contains results you don't
6885	–	# want to keep, you may remove or edit it.
6886	–	#
6887	–	# config.status only pays attention to the cache file if you give it
6888	–	# the --recheck option to rerun configure.
6889	–	#
6890	–	# `ac_cv_env_foo' variables (set or unset) will be overridden when
6891	–	# loading this file, other *unset* `ac_cv_foo' will be assigned the
6892	–	# following values.
6893	–
6894	–	_ACEOF
6895	–
6896	–	# The following way of writing the cache mishandles newlines in values,
6897	–	# but we know of no workaround that is simple, portable, and efficient.
6898	–	# So, don't put newlines in cache variables' values.
6899	–	# Ultrix sh set writes to stderr and can't be redirected directly,
6900	–	# and sets the high bit in the cache file unless we assign to the vars.
6901	–	{
6902	–	(set) 2>&1 |
6903	–	case `(ac_space=' '; set | grep ac_space) 2>&1` in
6904	–	*ac_space=\ *)
6905	–	# `set' does not quote correctly, so add quotes (double-quote
6906	–	# substitution turns \\\\ into \\, and sed turns \\ into \).
6907	–	sed -n \
6908	–	"s/'/'\\\\''/g;
6909	–	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6910	–	;;
6911	–	*)
6912	–	# `set' quotes correctly as required by POSIX, so do not add quotes.
6913	–	sed -n \
6914	–	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6915	–	;;
6916	–	esac;
6917	–	} |
6918	–	sed '
6919	–	t clear
6920	–	: clear
6921	–	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6922	–	t end
6923	–	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6924	–	: end' >>confcache
6925	–	if diff $cache_file confcache >/dev/null 2>&1; then :; else
6926	–	if test -w $cache_file; then
6927	–	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6928	–	cat confcache >$cache_file
6929	–	else
6930	–	echo "not updating unwritable cache $cache_file"
6931	–	fi
6932	–	fi
6933	–	rm -f confcache
6934	–	exit 1
6935	–	fi
6936	–
6937	–
6938	–
13024		# Check whether --with-mpi or --without-mpi was given.
13025		if test "${with_mpi+set}" = set; then
13026		withval="$with_mpi"
#	Line 6961 | Line 13046 | MPI_INC_DIR="$MPI/include"
13046
13047
13048
13049	+	ac_ext=c
13050	+	ac_cpp='$CPP $CPPFLAGS'
13051	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13052	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13053	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13054	+
13055		echo "$as_me:$LINENO: checking for mpi.h" >&5
13056		echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13057		have_mpi_h=0
13058	<	echo '#include <mpi.h>' > conftest.cc
13059	<	if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13058	>	rm -f conftest*
13059	>	echo '#include <mpi.h>' > conftest.c
13060	>	if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13061		echo "$as_me:$LINENO: result: yes" >&5
13062		echo "${ECHO_T}yes" >&6
13063		have_mpi_h=1
13064		else
13065	+	if test -s conftest.out ; then
13066	+	cat conftest.out >> config.log
13067	+	fi
13068		echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13069		echo "${ECHO_T}no! Check MPI include paths" >&6
13070		USE_MPI="no"
#	Line 6985 | Line 13080 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13080
13081		echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13082		echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13083	+
13084	+
13085	+	ac_ext=${FC_SRCEXT-f}
13086	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13087	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13088	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13089	+
13090	+	ac_save_ext=$ac_ext
13091	+	ac_ext=F90
13092	+	ac_save_FCFLAGS=$FCFLAGS
13093		have_mpif_h=0
13094		rm -f conftest*
13095	<	cat >conftest.f90 <<EOF
13095	>	cat >conftest.$ac_ext <<EOF
13096		program main
13097		include 'mpif.h'
13098		end
13099		EOF
13100	<	if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13100	>	if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13101		echo "$as_me:$LINENO: result: yes" >&5
13102		echo "${ECHO_T}yes" >&6
13103		MPI_F90_INC="$MPI_INC_DIR"
#	Line 7014 | Line 13119 | fi
13119		_ACEOF
13120
13121		fi
13122	+	FCFLAGS=$ac_save_FCFLAGS
13123	+	ac_ext=$ac_save_ext
13124	+	ac_ext=c
13125	+	ac_cpp='$CPP $CPPFLAGS'
13126	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13127	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13128	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13129
13130	+
13131		ac_ext=c
13132		ac_cpp='$CPP $CPPFLAGS'
13133		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 7022 | Line 13135 | ac_save_LDFLAGS=$LDFLAGS
13135		ac_compiler_gnu=$ac_cv_c_compiler_gnu
13136
13137		ac_save_LDFLAGS=$LDFLAGS
13138	<	LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13138	>	LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13139
13140		if test x = x"$MPI_LIB"; then
13141		echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
#	Line 7046 | Line 13159 | char MPI_Init ();
13159		/* We use char because int might match the return type of a gcc2
13160		builtin and then its argument prototype would still apply.  */
13161		char MPI_Init ();
13162	+	#ifdef FC_DUMMY_MAIN
13163	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13164	+	#  ifdef __cplusplus
13165	+	extern "C"
13166	+	#  endif
13167	+	int FC_DUMMY_MAIN() { return 1; }
13168	+	#endif
13169	+	#endif
13170		int
13171		main ()
13172		{
#	Line 7094 | Line 13215 | fi
13215		fi
13216
13217		fi
13218	+	$as_unset ac_cv_lib_mpich_MPI_Init
13219		if test x = x"$MPI_LIB"; then
13220	<	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13221	<	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13222	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13220	>	echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13221	>	echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13222	>	if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13223		echo $ECHO_N "(cached) $ECHO_C" >&6
13224		else
13225		ac_check_lib_save_LIBS=$LIBS
13226	<	LIBS="-lmpi  $LIBS"
13226	>	LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13227		cat >conftest.$ac_ext <<_ACEOF
13228		/* confdefs.h.  */
13229		_ACEOF
#	Line 7116 | Line 13238 | char MPI_Init ();
13238		/* We use char because int might match the return type of a gcc2
13239		builtin and then its argument prototype would still apply.  */
13240		char MPI_Init ();
13241	+	#ifdef FC_DUMMY_MAIN
13242	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13243	+	#  ifdef __cplusplus
13244	+	extern "C"
13245	+	#  endif
13246	+	int FC_DUMMY_MAIN() { return 1; }
13247	+	#endif
13248	+	#endif
13249		int
13250		main ()
13251		{
#	Line 7146 | Line 13276 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13276		ac_status=$?
13277		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278		(exit $ac_status); }; }; then
13279	<	ac_cv_lib_mpi_MPI_Init=yes
13279	>	ac_cv_lib_pmpich_MPI_Init=yes
13280		else
13281		echo "$as_me: failed program was:" >&5
13282		sed 's/^/| /' conftest.$ac_ext >&5
13283
13284	<	ac_cv_lib_mpi_MPI_Init=no
13284	>	ac_cv_lib_pmpich_MPI_Init=no
13285		fi
13286		rm -f conftest.err conftest.$ac_objext \
13287		conftest$ac_exeext conftest.$ac_ext
13288		LIBS=$ac_check_lib_save_LIBS
13289		fi
13290	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13291	<	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13292	<	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13293	<	MPI_LIB="-lmpi"
13290	>	echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13291	>	echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13292	>	if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13293	>	MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13294		fi
13295
13296		fi
7167	–	$as_unset ac_cv_lib_mpi_MPI_Init
13297		if test x = x"$MPI_LIB"; then
13298		echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13299		echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
#	Line 7172 | Line 13301 | else
13301		echo $ECHO_N "(cached) $ECHO_C" >&6
13302		else
13303		ac_check_lib_save_LIBS=$LIBS
13304	<	LIBS="-lmpi "-llam" $LIBS"
13304	>	LIBS="-lmpi  $LIBS"
13305		cat >conftest.$ac_ext <<_ACEOF
13306		/* confdefs.h.  */
13307		_ACEOF
#	Line 7187 | Line 13316 | char MPI_Init ();
13316		/* We use char because int might match the return type of a gcc2
13317		builtin and then its argument prototype would still apply.  */
13318		char MPI_Init ();
13319	+	#ifdef FC_DUMMY_MAIN
13320	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13321	+	#  ifdef __cplusplus
13322	+	extern "C"
13323	+	#  endif
13324	+	int FC_DUMMY_MAIN() { return 1; }
13325	+	#endif
13326	+	#endif
13327		int
13328		main ()
13329		{
#	Line 7231 | Line 13368 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13368		echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13369		echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13370		if test $ac_cv_lib_mpi_MPI_Init = yes; then
13371	<	MPI_LIB="-lmpi -llam"
13371	>	MPI_LIB="-lmpi"
13372		fi
13373
13374		fi
13375	<	$as_unset ac_cv_lib_mpich_MPI_Init
13375	>	$as_unset ac_cv_lib_mpi_MPI_Init
13376		if test x = x"$MPI_LIB"; then
13377	<	echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13378	<	echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13379	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13377	>	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13378	>	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13379	>	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13380		echo $ECHO_N "(cached) $ECHO_C" >&6
13381		else
13382		ac_check_lib_save_LIBS=$LIBS
13383	<	LIBS="-lmpich "-lpmpich" $LIBS"
13383	>	LIBS="-lmpi -llam $LIBS"
13384		cat >conftest.$ac_ext <<_ACEOF
13385		/* confdefs.h.  */
13386		_ACEOF
#	Line 7258 | Line 13395 | char MPI_Init ();
13395		/* We use char because int might match the return type of a gcc2
13396		builtin and then its argument prototype would still apply.  */
13397		char MPI_Init ();
13398	+	#ifdef FC_DUMMY_MAIN
13399	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13400	+	#  ifdef __cplusplus
13401	+	extern "C"
13402	+	#  endif
13403	+	int FC_DUMMY_MAIN() { return 1; }
13404	+	#endif
13405	+	#endif
13406		int
13407		main ()
13408		{
#	Line 7288 | Line 13433 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13433		ac_status=$?
13434		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13435		(exit $ac_status); }; }; then
13436	<	ac_cv_lib_mpich_MPI_Init=yes
13436	>	ac_cv_lib_mpi_MPI_Init=yes
13437		else
13438		echo "$as_me: failed program was:" >&5
13439		sed 's/^/| /' conftest.$ac_ext >&5
13440
13441	<	ac_cv_lib_mpich_MPI_Init=no
13441	>	ac_cv_lib_mpi_MPI_Init=no
13442		fi
13443		rm -f conftest.err conftest.$ac_objext \
13444		conftest$ac_exeext conftest.$ac_ext
13445		LIBS=$ac_check_lib_save_LIBS
13446		fi
13447	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13448	<	echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13449	<	if test $ac_cv_lib_mpich_MPI_Init = yes; then
13450	<	MPI_LIB="-lmpich -lpmpich"
13447	>	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13448	>	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13449	>	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13450	>	MPI_LIB="-lmpi -llam"
13451		fi
13452
13453		fi
7309	–
13454		$as_unset ac_cv_lib_mpi_MPI_Init
13455		if test x = x"$MPI_LIB"; then
13456		echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
#	Line 7330 | Line 13474 | char MPI_Init ();
13474		/* We use char because int might match the return type of a gcc2
13475		builtin and then its argument prototype would still apply.  */
13476		char MPI_Init ();
13477	+	#ifdef FC_DUMMY_MAIN
13478	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13479	+	#  ifdef __cplusplus
13480	+	extern "C"
13481	+	#  endif
13482	+	int FC_DUMMY_MAIN() { return 1; }
13483	+	#endif
13484	+	#endif
13485		int
13486		main ()
13487		{
#	Line 7406 | Line 13558 | fi
13558
13559
13560
13561	<	# Check whether --with-sprng or --without-sprng was given.
7410	<	if test "${with_sprng+set}" = set; then
7411	<	withval="$with_sprng"
7412	<	with_sprng=$withval
7413	<	else
7414	<	with_sprng="/usr/local"
7415	<	fi;
13561	>	acx_cgal_found=no
13562
13563	<	case "x$with_sprng" in
13564	<	xyes | "x")  USE_SPRNG=yes;;
13565	<	xno) USE_SPRNG=no ;;
7420	<	*) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7421	<	esac
7422	<	if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7423	<	SPRNG="/usr/local"
7424	<	fi
7425	<	if test "$USE_SPRNG" = "yes"; then
7426	<
7427	<
7428	<	# Set variables...
7429	<	SPRNG_LIB_DIR="$SPRNG/lib"
7430	<	SPRNG_INC_DIR="$SPRNG/include"
13563	>	# Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13564	>	if test "${with_cgalmakefile+set}" = set; then
13565	>	withval="$with_cgalmakefile"
13566
13567	+	fi;
13568	+	case $with_cgalmakefile in
13569	+	yes | "") ;;
13570	+	no) acx_cgal_found=disable ;;
13571	+	-* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13572	+	*) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13573	+	esac
13574
13575	+	if test "$acx_cgal_found" == no; then
13576	+	echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
13577	+	echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6
13578
13579	<	echo "$as_me:$LINENO: checking for sprng.h" >&5
13580	<	echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
13581	<	have_sprng_h=0
13582	<	echo '#include <sprng.h>' > conftest.cc
13583	<	if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
13584	<	echo "$as_me:$LINENO: result: yes" >&5
13579	>	if test \! -z "$CGAL_MAKEFILE"; then
13580	>
13581	>	if test -e "$CGAL_MAKEFILE"; then
13582	>	tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13583	>
13584	>	cat > $tname << _ACEOF
13585	>	include $CGAL_MAKEFILE
13586	>
13587	>	cppflags:
13588	>	@echo \$(CGAL_CXXFLAGS)
13589	>
13590	>	cxxflags:
13591	>	@echo
13592	>	ldflags:
13593	>	@echo \$(CGAL_LDFLAGS)
13594	>	_ACEOF
13595	>	CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
13596	>	CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
13597	>	CGAL_LDFLAGST="`make -s -f $tname ldflags`"
13598	>	for i in $CGAL_LDFLAGST; do
13599	>	if test `echo $i| grep -c ^-l`; then
13600	>	CGAL_LIBS="$CGAL_LIBS $i"
13601	>	else
13602	>	CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
13603	>	fi
13604	>	done
13605	>	rm -f $tname
13606	>	echo "$as_me:$LINENO: result: yes" >&5
13607		echo "${ECHO_T}yes" >&6
13608	<	have_sprng_h=1
13609	<	else
13610	<	echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
13611	<	echo "${ECHO_T}no! Check SPRNG include path!" >&6
13612	<	USE_SPRNG="no"
13608	>	acx_cgal_found=yes
13609	>	else
13610	>	echo "$as_me:$LINENO: result: invalid" >&5
13611	>	echo "${ECHO_T}invalid" >&6
13612	>	{ { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
13613	>	echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
13614	>	{ (exit 1); exit 1; }; }
13615	>	fi
13616	>	else
13617	>	echo "$as_me:$LINENO: result: not defined" >&5
13618	>	echo "${ECHO_T}not defined" >&6
13619	>	fi
13620		fi
7447	–	rm -f conftest*
7448	–	if test "$have_sprng_h" = 1; then
13621
13622	<	cat >>confdefs.h <<\_ACEOF
13623	<	#define HAVE_SPRNG_H 1
13622	>	if test "$acx_cgal_found" == no; then
13623	>	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13624	>	echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13625	>	echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13626	>	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13627	>	echo $ECHO_N "(cached) $ECHO_C" >&6
13628	>	fi
13629	>	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13630	>	echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13631	>	else
13632	>	# Is the header compilable?
13633	>	echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
13634	>	echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6
13635	>	cat >conftest.$ac_ext <<_ACEOF
13636	>	/* confdefs.h.  */
13637		_ACEOF
13638	+	cat confdefs.h >>conftest.$ac_ext
13639	+	cat >>conftest.$ac_ext <<_ACEOF
13640	+	/* end confdefs.h.  */
13641	+	$ac_includes_default
13642	+	#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13643	+	_ACEOF
13644	+	rm -f conftest.$ac_objext
13645	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13646	+	(eval $ac_compile) 2>conftest.er1
13647	+	ac_status=$?
13648	+	grep -v '^ *+' conftest.er1 >conftest.err
13649	+	rm -f conftest.er1
13650	+	cat conftest.err >&5
13651	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13652	+	(exit $ac_status); } &&
13653	+	{ ac_try='test -z "$ac_c_werror_flag"
13654	+	|| test ! -s conftest.err'
13655	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13656	+	(eval $ac_try) 2>&5
13657	+	ac_status=$?
13658	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13659	+	(exit $ac_status); }; } &&
13660	+	{ ac_try='test -s conftest.$ac_objext'
13661	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13662	+	(eval $ac_try) 2>&5
13663	+	ac_status=$?
13664	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13665	+	(exit $ac_status); }; }; then
13666	+	ac_header_compiler=yes
13667	+	else
13668	+	echo "$as_me: failed program was:" >&5
13669	+	sed 's/^/| /' conftest.$ac_ext >&5
13670
13671	+	ac_header_compiler=no
13672		fi
13673	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13674	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13675	+	echo "${ECHO_T}$ac_header_compiler" >&6
13676
13677	<	ac_ext=c
13678	<	ac_cpp='$CPP $CPPFLAGS'
13679	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13680	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13681	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13682	<
13683	<	ac_save_LDFLAGS=$LDFLAGS
13684	<	LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
13677	>	# Is the header present?
13678	>	echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
13679	>	echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6
13680	>	cat >conftest.$ac_ext <<_ACEOF
13681	>	/* confdefs.h.  */
13682	>	_ACEOF
13683	>	cat confdefs.h >>conftest.$ac_ext
13684	>	cat >>conftest.$ac_ext <<_ACEOF
13685	>	/* end confdefs.h.  */
13686	>	#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13687	>	_ACEOF
13688	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13689	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
13690	>	ac_status=$?
13691	>	grep -v '^ *+' conftest.er1 >conftest.err
13692	>	rm -f conftest.er1
13693	>	cat conftest.err >&5
13694	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13695	>	(exit $ac_status); } >/dev/null; then
13696	>	if test -s conftest.err; then
13697	>	ac_cpp_err=$ac_c_preproc_warn_flag
13698	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13699	>	else
13700	>	ac_cpp_err=
13701	>	fi
13702	>	else
13703	>	ac_cpp_err=yes
13704	>	fi
13705	>	if test -z "$ac_cpp_err"; then
13706	>	ac_header_preproc=yes
13707	>	else
13708	>	echo "$as_me: failed program was:" >&5
13709	>	sed 's/^/| /' conftest.$ac_ext >&5
13710
13711	<	echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
13712	<	echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
13713	<	if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
13711	>	ac_header_preproc=no
13712	>	fi
13713	>	rm -f conftest.err conftest.$ac_ext
13714	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13715	>	echo "${ECHO_T}$ac_header_preproc" >&6
13716	>
13717	>	# So?  What about this header?
13718	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13719	>	yes:no: )
13720	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
13721	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13722	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
13723	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
13724	>	ac_header_preproc=yes
13725	>	;;
13726	>	no:yes:* )
13727	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
13728	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
13729	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
13730	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
13731	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
13732	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
13733	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
13734	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13735	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
13736	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
13737	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
13738	>	echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
13739	>	(
13740	>	cat <<\_ASBOX
13741	>	## ------------------------------ ##
13742	>	## Report this to gezelter@nd.edu ##
13743	>	## ------------------------------ ##
13744	>	_ASBOX
13745	>	) |
13746	>	sed "s/^/$as_me: WARNING:     /" >&2
13747	>	;;
13748	>	esac
13749	>	echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13750	>	echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13751	>	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13752		echo $ECHO_N "(cached) $ECHO_C" >&6
13753		else
13754	+	ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
13755	+	fi
13756	+	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13757	+	echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13758	+
13759	+	fi
13760	+	if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
13761	+	cgal_have_header=yes
13762	+	else
13763	+	cgal_have_header=no
13764	+	fi
13765	+
13766	+
13767	+	if test "$cgal_have_header" == yes; then
13768	+	echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13769	+	echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13770	+	if test "${ac_cv_lib_CGAL_main+set}" = set; then
13771	+	echo $ECHO_N "(cached) $ECHO_C" >&6
13772	+	else
13773		ac_check_lib_save_LIBS=$LIBS
13774	<	LIBS="-lsprng  $LIBS"
13774	>	LIBS="-lCGAL  $LIBS"
13775		cat >conftest.$ac_ext <<_ACEOF
13776		/* confdefs.h.  */
13777		_ACEOF
#	Line 7476 | Line 13779 | cat >>conftest.$ac_ext <<_ACEOF
13779		cat >>conftest.$ac_ext <<_ACEOF
13780		/* end confdefs.h.  */
13781
13782	<	/* Override any gcc2 internal prototype to avoid an error.  */
13783	<	#ifdef __cplusplus
13784	<	extern "C"
13782	>
13783	>	#ifdef FC_DUMMY_MAIN
13784	>	#ifndef FC_DUMMY_MAIN_EQ_F77
13785	>	#  ifdef __cplusplus
13786	>	extern "C"
13787	>	#  endif
13788	>	int FC_DUMMY_MAIN() { return 1; }
13789		#endif
13790	<	/* We use char because int might match the return type of a gcc2
7484	<	builtin and then its argument prototype would still apply.  */
7485	<	char init_rng ();
13790	>	#endif
13791		int
13792		main ()
13793		{
13794	<	init_rng ();
13794	>	main ();
13795		;
13796		return 0;
13797		}
#	Line 7513 | Line 13818 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13818		ac_status=$?
13819		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13820		(exit $ac_status); }; }; then
13821	<	ac_cv_lib_sprng_init_rng=yes
13821	>	ac_cv_lib_CGAL_main=yes
13822		else
13823		echo "$as_me: failed program was:" >&5
13824		sed 's/^/| /' conftest.$ac_ext >&5
13825
13826	<	ac_cv_lib_sprng_init_rng=no
13826	>	ac_cv_lib_CGAL_main=no
13827		fi
13828		rm -f conftest.err conftest.$ac_objext \
13829		conftest$ac_exeext conftest.$ac_ext
13830		LIBS=$ac_check_lib_save_LIBS
13831		fi
13832	<	echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
13833	<	echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
13834	<	if test $ac_cv_lib_sprng_init_rng = yes; then
13835	<	SPRNG_LIB="-lsprng"
13832	>	echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13833	>	echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13834	>	if test $ac_cv_lib_CGAL_main = yes; then
13835	>	cgal_have_lib=yes
13836		else
13837	<
7533	<	{ { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
7534	<	echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
7535	<	{ (exit 1); exit 1; }; }
7536	<	USE_SPRNG="no"
7537	<
13837	>	cgal_have_lib=no
13838		fi
13839
13840	+	if test "$cgal_have_lib" == no; then
13841	+	save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
13842	+	echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13843	+	echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13844	+	if test "${ac_cv_lib_CGAL_main+set}" = set; then
13845	+	echo $ECHO_N "(cached) $ECHO_C" >&6
13846	+	else
13847	+	ac_check_lib_save_LIBS=$LIBS
13848	+	LIBS="-lCGAL  $LIBS"
13849	+	cat >conftest.$ac_ext <<_ACEOF
13850	+	/* confdefs.h.  */
13851	+	_ACEOF
13852	+	cat confdefs.h >>conftest.$ac_ext
13853	+	cat >>conftest.$ac_ext <<_ACEOF
13854	+	/* end confdefs.h.  */
13855
7541	–	if test "$USE_SPRNG" = "no"; then
7542	–	{ { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
7543	–	echo "$as_me: error: No working SPRNG library found" >&2;}
7544	–	{ (exit 1); exit 1; }; }
7545	–	fi
13856
13857	+	#ifdef FC_DUMMY_MAIN
13858	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13859	+	#  ifdef __cplusplus
13860	+	extern "C"
13861	+	#  endif
13862	+	int FC_DUMMY_MAIN() { return 1; }
13863	+	#endif
13864	+	#endif
13865	+	int
13866	+	main ()
13867	+	{
13868	+	main ();
13869	+	;
13870	+	return 0;
13871	+	}
13872	+	_ACEOF
13873	+	rm -f conftest.$ac_objext conftest$ac_exeext
13874	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13875	+	(eval $ac_link) 2>conftest.er1
13876	+	ac_status=$?
13877	+	grep -v '^ *+' conftest.er1 >conftest.err
13878	+	rm -f conftest.er1
13879	+	cat conftest.err >&5
13880	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13881	+	(exit $ac_status); } &&
13882	+	{ ac_try='test -z "$ac_c_werror_flag"
13883	+	|| test ! -s conftest.err'
13884	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13885	+	(eval $ac_try) 2>&5
13886	+	ac_status=$?
13887	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13888	+	(exit $ac_status); }; } &&
13889	+	{ ac_try='test -s conftest$ac_exeext'
13890	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13891	+	(eval $ac_try) 2>&5
13892	+	ac_status=$?
13893	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13894	+	(exit $ac_status); }; }; then
13895	+	ac_cv_lib_CGAL_main=yes
13896	+	else
13897	+	echo "$as_me: failed program was:" >&5
13898	+	sed 's/^/| /' conftest.$ac_ext >&5
13899
13900	+	ac_cv_lib_CGAL_main=no
13901		fi
13902	+	rm -f conftest.err conftest.$ac_objext \
13903	+	conftest$ac_exeext conftest.$ac_ext
13904	+	LIBS=$ac_check_lib_save_LIBS
13905	+	fi
13906	+	echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13907	+	echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13908	+	if test $ac_cv_lib_CGAL_main = yes; then
13909	+	CGAL_LIBS="-lCGAL -lgmp -lmpfr"
13910	+	cgal_have_lib=yes
13911	+	else
13912	+	cgal_have_lib=no
13913	+	fi
13914
13915	<
13916	<
13917	<	echo "$as_me:$LINENO: checking if MKL is wanted" >&5
13918	<	echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13919	<
13920	<	# Check whether --with-mkl or --without-mkl was given.
13921	<	if test "${with_mkl+set}" = set; then
13922	<	withval="$with_mkl"
13923	<	echo "$as_me:$LINENO: result: yes" >&5
13924	<	echo "${ECHO_T}yes" >&6
13925	<	for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
13926	<	mkldir="$dir"
13927	<	if test -f "$dir/include/mkl.h"; then
13928	<	found_mkl="yes";
13929	<	break;
13930	<	fi
7566	<	done
7567	<	if test x_$found_mkl != x_yes; then
7568	<	{ { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7569	<	echo "$as_me: error: Cannot find MKL includes" >&2;}
7570	<	{ (exit 1); exit 1; }; }
7571	<	else
7572	<	printf "MKL includes found in $mkldir/include\n";
7573	<	fi
13915	>	LIBS="$save_LIBS"
13916	>	else
13917	>	CGAL_LIBS="-lCGAL"
13918	>	echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
13919	>	echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6
13920	>	if test "${ac_cv_lib_mpfr_main+set}" = set; then
13921	>	echo $ECHO_N "(cached) $ECHO_C" >&6
13922	>	else
13923	>	ac_check_lib_save_LIBS=$LIBS
13924	>	LIBS="-lmpfr  $LIBS"
13925	>	cat >conftest.$ac_ext <<_ACEOF
13926	>	/* confdefs.h.  */
13927	>	_ACEOF
13928	>	cat confdefs.h >>conftest.$ac_ext
13929	>	cat >>conftest.$ac_ext <<_ACEOF
13930	>	/* end confdefs.h.  */
13931
13932
13933	+	#ifdef FC_DUMMY_MAIN
13934	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13935	+	#  ifdef __cplusplus
13936	+	extern "C"
13937	+	#  endif
13938	+	int FC_DUMMY_MAIN() { return 1; }
13939	+	#endif
13940	+	#endif
13941	+	int
13942	+	main ()
13943	+	{
13944	+	main ();
13945	+	;
13946	+	return 0;
13947	+	}
13948	+	_ACEOF
13949	+	rm -f conftest.$ac_objext conftest$ac_exeext
13950	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13951	+	(eval $ac_link) 2>conftest.er1
13952	+	ac_status=$?
13953	+	grep -v '^ *+' conftest.er1 >conftest.err
13954	+	rm -f conftest.er1
13955	+	cat conftest.err >&5
13956	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13957	+	(exit $ac_status); } &&
13958	+	{ ac_try='test -z "$ac_c_werror_flag"
13959	+	|| test ! -s conftest.err'
13960	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13961	+	(eval $ac_try) 2>&5
13962	+	ac_status=$?
13963	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13964	+	(exit $ac_status); }; } &&
13965	+	{ ac_try='test -s conftest$ac_exeext'
13966	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13967	+	(eval $ac_try) 2>&5
13968	+	ac_status=$?
13969	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13970	+	(exit $ac_status); }; }; then
13971	+	ac_cv_lib_mpfr_main=yes
13972	+	else
13973	+	echo "$as_me: failed program was:" >&5
13974	+	sed 's/^/| /' conftest.$ac_ext >&5
13975
13976	<	ac_ext=c
13977	<	ac_cpp='$CPP $CPPFLAGS'
13978	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13979	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13980	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13976	>	ac_cv_lib_mpfr_main=no
13977	>	fi
13978	>	rm -f conftest.err conftest.$ac_objext \
13979	>	conftest$ac_exeext conftest.$ac_ext
13980	>	LIBS=$ac_check_lib_save_LIBS
13981	>	fi
13982	>	echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
13983	>	echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6
13984	>	if test $ac_cv_lib_mpfr_main = yes; then
13985	>	CGAL_LIBS="$CGAL_LIBS -lmpfr"
13986	>	fi
13987
13988	<	ac_save_CPPFLAGS=$CPPFLAGS
13989	<	CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
13990	<	ac_save_LDFLAGS=$LDFLAGS
7586	<	LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
7587	<	if test "${ac_cv_header_mkl_h+set}" = set; then
7588	<	echo "$as_me:$LINENO: checking for mkl.h" >&5
7589	<	echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7590	<	if test "${ac_cv_header_mkl_h+set}" = set; then
13988	>	echo "$as_me:$LINENO: checking for main in -lgmp" >&5
13989	>	echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6
13990	>	if test "${ac_cv_lib_gmp_main+set}" = set; then
13991		echo $ECHO_N "(cached) $ECHO_C" >&6
7592	–	fi
7593	–	echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
7594	–	echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13992		else
13993	<	# Is the header compilable?
13994	<	echo "$as_me:$LINENO: checking mkl.h usability" >&5
7598	<	echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13993	>	ac_check_lib_save_LIBS=$LIBS
13994	>	LIBS="-lgmp  $LIBS"
13995		cat >conftest.$ac_ext <<_ACEOF
13996		/* confdefs.h.  */
13997		_ACEOF
13998		cat confdefs.h >>conftest.$ac_ext
13999		cat >>conftest.$ac_ext <<_ACEOF
14000		/* end confdefs.h.  */
14001	<	$ac_includes_default
14002	<	#include <mkl.h>
14001	>
14002	>
14003	>	#ifdef FC_DUMMY_MAIN
14004	>	#ifndef FC_DUMMY_MAIN_EQ_F77
14005	>	#  ifdef __cplusplus
14006	>	extern "C"
14007	>	#  endif
14008	>	int FC_DUMMY_MAIN() { return 1; }
14009	>	#endif
14010	>	#endif
14011	>	int
14012	>	main ()
14013	>	{
14014	>	main ();
14015	>	;
14016	>	return 0;
14017	>	}
14018		_ACEOF
14019	<	rm -f conftest.$ac_objext
14020	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
14021	<	(eval $ac_compile) 2>conftest.er1
14019	>	rm -f conftest.$ac_objext conftest$ac_exeext
14020	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14021	>	(eval $ac_link) 2>conftest.er1
14022		ac_status=$?
14023		grep -v '^ *+' conftest.er1 >conftest.err
14024		rm -f conftest.er1
#	Line 7621 | Line 14032 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
14032		ac_status=$?
14033		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14034		(exit $ac_status); }; } &&
14035	<	{ ac_try='test -s conftest.$ac_objext'
14035	>	{ ac_try='test -s conftest$ac_exeext'
14036		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14037		(eval $ac_try) 2>&5
14038		ac_status=$?
14039		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14040		(exit $ac_status); }; }; then
14041	<	ac_header_compiler=yes
14041	>	ac_cv_lib_gmp_main=yes
14042		else
14043		echo "$as_me: failed program was:" >&5
14044		sed 's/^/| /' conftest.$ac_ext >&5
14045
14046	<	ac_header_compiler=no
14046	>	ac_cv_lib_gmp_main=no
14047		fi
14048	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
14049	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
14050	<	echo "${ECHO_T}$ac_header_compiler" >&6
14048	>	rm -f conftest.err conftest.$ac_objext \
14049	>	conftest$ac_exeext conftest.$ac_ext
14050	>	LIBS=$ac_check_lib_save_LIBS
14051	>	fi
14052	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
14053	>	echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6
14054	>	if test $ac_cv_lib_gmp_main = yes; then
14055	>	CGAL_LIBS="$CGAL_LIBS -lgmp"
14056	>	fi
14057
14058	<	# Is the header present?
14059	<	echo "$as_me:$LINENO: checking mkl.h presence" >&5
14060	<	echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
14058	>	echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
14059	>	echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6
14060	>	if test "${ac_cv_lib_gmpxx_main+set}" = set; then
14061	>	echo $ECHO_N "(cached) $ECHO_C" >&6
14062	>	else
14063	>	ac_check_lib_save_LIBS=$LIBS
14064	>	LIBS="-lgmpxx  $LIBS"
14065		cat >conftest.$ac_ext <<_ACEOF
14066		/* confdefs.h.  */
14067		_ACEOF
14068		cat confdefs.h >>conftest.$ac_ext
14069		cat >>conftest.$ac_ext <<_ACEOF
14070		/* end confdefs.h.  */
14071	<	#include <mkl.h>
14071	>
14072	>
14073	>	#ifdef FC_DUMMY_MAIN
14074	>	#ifndef FC_DUMMY_MAIN_EQ_F77
14075	>	#  ifdef __cplusplus
14076	>	extern "C"
14077	>	#  endif
14078	>	int FC_DUMMY_MAIN() { return 1; }
14079	>	#endif
14080	>	#endif
14081	>	int
14082	>	main ()
14083	>	{
14084	>	main ();
14085	>	;
14086	>	return 0;
14087	>	}
14088		_ACEOF
14089	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
14090	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
14089	>	rm -f conftest.$ac_objext conftest$ac_exeext
14090	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14091	>	(eval $ac_link) 2>conftest.er1
14092		ac_status=$?
14093		grep -v '^ *+' conftest.er1 >conftest.err
14094		rm -f conftest.er1
14095		cat conftest.err >&5
14096		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14097	<	(exit $ac_status); } >/dev/null; then
14098	<	if test -s conftest.err; then
14099	<	ac_cpp_err=$ac_c_preproc_warn_flag
14100	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
14101	<	else
14102	<	ac_cpp_err=
14103	<	fi
14097	>	(exit $ac_status); } &&
14098	>	{ ac_try='test -z "$ac_c_werror_flag"
14099	>	|| test ! -s conftest.err'
14100	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14101	>	(eval $ac_try) 2>&5
14102	>	ac_status=$?
14103	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14104	>	(exit $ac_status); }; } &&
14105	>	{ ac_try='test -s conftest$ac_exeext'
14106	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14107	>	(eval $ac_try) 2>&5
14108	>	ac_status=$?
14109	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14110	>	(exit $ac_status); }; }; then
14111	>	ac_cv_lib_gmpxx_main=yes
14112		else
7667	–	ac_cpp_err=yes
7668	–	fi
7669	–	if test -z "$ac_cpp_err"; then
7670	–	ac_header_preproc=yes
7671	–	else
14113		echo "$as_me: failed program was:" >&5
14114		sed 's/^/| /' conftest.$ac_ext >&5
14115
14116	<	ac_header_preproc=no
14116	>	ac_cv_lib_gmpxx_main=no
14117		fi
14118	<	rm -f conftest.err conftest.$ac_ext
14119	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
14120	<	echo "${ECHO_T}$ac_header_preproc" >&6
7680	<
7681	<	# So?  What about this header?
7682	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7683	<	yes:no: )
7684	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
7685	<	echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7686	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
7687	<	echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
7688	<	ac_header_preproc=yes
7689	<	;;
7690	<	no:yes:* )
7691	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
7692	<	echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
7693	<	{ echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
7694	<	echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
7695	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
7696	<	echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
7697	<	{ echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
7698	<	echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7699	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
7700	<	echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
7701	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
7702	<	echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
7703	<	(
7704	<	cat <<\_ASBOX
7705	<	## ------------------------------ ##
7706	<	## Report this to gezelter@nd.edu ##
7707	<	## ------------------------------ ##
7708	<	_ASBOX
7709	<	) |
7710	<	sed "s/^/$as_me: WARNING:     /" >&2
7711	<	;;
7712	<	esac
7713	<	echo "$as_me:$LINENO: checking for mkl.h" >&5
7714	<	echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7715	<	if test "${ac_cv_header_mkl_h+set}" = set; then
7716	<	echo $ECHO_N "(cached) $ECHO_C" >&6
7717	<	else
7718	<	ac_cv_header_mkl_h=$ac_header_preproc
14118	>	rm -f conftest.err conftest.$ac_objext \
14119	>	conftest$ac_exeext conftest.$ac_ext
14120	>	LIBS=$ac_check_lib_save_LIBS
14121		fi
14122	<	echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
14123	<	echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
14124	<
14122	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
14123	>	echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6
14124	>	if test $ac_cv_lib_gmpxx_main = yes; then
14125	>	CGAL_LIBS="$CGAL_LIBS -lgmpxx"
14126		fi
7724	–	if test $ac_cv_header_mkl_h = yes; then
14127
14128	<	echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
14129	<	echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
14130	<	if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
14128	>	fi
14129	>
14130	>	if test "$cgal_have_lib" == yes; then
14131	>	acx_cgal_found=yes
14132	>	fi
14133	>	fi
14134	>	if test "$acx_cgal_found" == yes; then
14135	>	echo "$as_me:$LINENO: checking for main in -lCore" >&5
14136	>	echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6
14137	>	if test "${ac_cv_lib_Core_main+set}" = set; then
14138		echo $ECHO_N "(cached) $ECHO_C" >&6
14139		else
14140		ac_check_lib_save_LIBS=$LIBS
14141	<	LIBS="-lmkl  $LIBS"
14141	>	LIBS="-lCore  $LIBS"
14142		cat >conftest.$ac_ext <<_ACEOF
14143		/* confdefs.h.  */
14144		_ACEOF
#	Line 7737 | Line 14146 | cat >>conftest.$ac_ext <<_ACEOF
14146		cat >>conftest.$ac_ext <<_ACEOF
14147		/* end confdefs.h.  */
14148
14149	<	/* Override any gcc2 internal prototype to avoid an error.  */
14150	<	#ifdef __cplusplus
14151	<	extern "C"
14149	>
14150	>	#ifdef FC_DUMMY_MAIN
14151	>	#ifndef FC_DUMMY_MAIN_EQ_F77
14152	>	#  ifdef __cplusplus
14153	>	extern "C"
14154	>	#  endif
14155	>	int FC_DUMMY_MAIN() { return 1; }
14156		#endif
14157	<	/* We use char because int might match the return type of a gcc2
7745	<	builtin and then its argument prototype would still apply.  */
7746	<	char vslNewStream ();
14157	>	#endif
14158		int
14159		main ()
14160		{
14161	<	vslNewStream ();
14161	>	main ();
14162		;
14163		return 0;
14164		}
#	Line 7774 | Line 14185 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14185		ac_status=$?
14186		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14187		(exit $ac_status); }; }; then
14188	<	ac_cv_lib_mkl_vslNewStream=yes
14188	>	ac_cv_lib_Core_main=yes
14189		else
14190		echo "$as_me: failed program was:" >&5
14191		sed 's/^/| /' conftest.$ac_ext >&5
14192
14193	<	ac_cv_lib_mkl_vslNewStream=no
14193	>	ac_cv_lib_Core_main=no
14194		fi
14195		rm -f conftest.err conftest.$ac_objext \
14196		conftest$ac_exeext conftest.$ac_ext
14197		LIBS=$ac_check_lib_save_LIBS
14198		fi
14199	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
14200	<	echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
14201	<	if test $ac_cv_lib_mkl_vslNewStream = yes; then
14202	<	MKL_LIBDIR="${mkldir}/lib/32",
7792	<	MKL_LIB="-lmkl -lvml -lguide",
7793	<	HAVE_MKL="yes"
14199	>	echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
14200	>	echo "${ECHO_T}$ac_cv_lib_Core_main" >&6
14201	>	if test $ac_cv_lib_Core_main = yes; then
14202	>	CGAL_LIBS="$CGAL_LIBS -lCore"
14203		fi
14204
14205	+	fi
14206	+	fi
14207
14208	+
14209	+
14210	+	echo "$as_me:$LINENO: checking CGAL" >&5
14211	+	echo $ECHO_N "checking CGAL... $ECHO_C" >&6
14212	+	if test "$acx_cgal_found" == yes; then
14213	+	echo "$as_me:$LINENO: result: yes" >&5
14214	+	echo "${ECHO_T}yes" >&6;
14215	+
14216		else
14217	<	MKL_INC="-I${mkldir}/include"
14217	>	echo "$as_me:$LINENO: result: no" >&5
14218	>	echo "${ECHO_T}no" >&6
14219	>
14220		fi
14221
14222	+	if test "$acx_cgal_found" == yes; then
14223	+	USE_CGAL=yes
14224
14225	<	CPPFLAGS=$ac_save_CPPFLAGS
14226	<	LDFLAGS=$ac_save_LDFLAGS
14227	<	ac_ext=c
7805	<	ac_cpp='$CPP $CPPFLAGS'
7806	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7807	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7808	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
14225	>	cat >>confdefs.h <<\_ACEOF
14226	>	#define HAVE_CGAL 1
14227	>	_ACEOF
14228
14229
7811	–	if test x_$HAVE_MKL != x_yes; then
7812	–	{ { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7813	–	echo "$as_me: error: Can't build with MKL" >&2;}
7814	–	{ (exit 1); exit 1; }; }
7815	–	fi
14230
14231
14232
14233
14234	+	fi
14235
7821	–	else
14236
7823	–	echo "$as_me:$LINENO: result: no" >&5
7824	–	echo "${ECHO_T}no" >&6
14237
7826	–	fi;
7827	–
7828	–
7829	–
14238		# Check whether --enable-doxygen or --disable-doxygen was given.
14239		if test "${enable_doxygen+set}" = set; then
14240		enableval="$enable_doxygen"
#	Line 7968 | Line 14376 | fi
14376
14377
14378
7971	–	OBJEXT=".$OBJEXT"
14379
7973	–	OOPSE=oopse
14380
7975	–	if test "x${prefix}" = "xNONE"
7976	–	then
7977	–	OOPSE_HOME=${ac_default_prefix}/oopse
7978	–	else
7979	–	OOPSE_HOME=${prefix}/oopse
7980	–	fi
7981	–	# Check whether --enable-oopse-home or --disable-oopse-home was given.
7982	–	if test "${enable_oopse_home+set}" = set; then
7983	–	enableval="$enable_oopse_home"
7984	–	OOPSE_HOME="${enableval}"
7985	–	fi;
14381
7987	–	case "x$INSTALL" in
7988	–	x/*) ;;
7989	–	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
7990	–	esac
14382
7992	–	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14383
7994	–	CFLAGS=${CFLAGS-""}
7995	–	CXXFLAGS=${CXXFLAGS-""}
7996	–	CPPFLAGS=${CPPFLAGS-""}
7997	–	FFLAGS=${FFLAGS-""}
7998	–	F90FLAGS=${F90FLAGS-""}
7999	–	LDFLAGS=${LDFLAGS-""}
8000	–	DEBUG=${DEBUG-"-g"}
14384
8002	–	case $debug in
8003	–	1)
8004	–	FFLAGS="$DEBUG $FFLAGS"
8005	–	F90FLAGS="$DEBUG $F90FLAGS"
8006	–	;;
8007	–	*)
8008	–	;;
8009	–	esac
14385
14386
14387
14388
14389
14390
14391	<
8017	<
8018	<
8019	<
8020	<
8021	<
8022	<
8023	<
8024	<
8025	<
8026	<
8027	<
8028	<	ac_config_headers="$ac_config_headers src/config.h"
8029	<
8030	<	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
14391	>	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/applications/staticProps/Makefile scripts/filepp"
14392
14393
14394		cat >confcache <<\_ACEOF
#	Line 8392 | Line 14753 | cat >&5 <<_CSEOF
14753		} >&5
14754		cat >&5 <<_CSEOF
14755
14756	<	This file was extended by OOPSE $as_me 2.0, which was
14756	>	This file was extended by OOPSE $as_me 4.0, which was
14757		generated by GNU Autoconf 2.59.  Invocation command line was
14758
14759		CONFIG_FILES    = $CONFIG_FILES
#	Line 8455 | Line 14816 | ac_cs_version="\\
14816
14817		cat >>$CONFIG_STATUS <<_ACEOF
14818		ac_cs_version="\\
14819	<	OOPSE config.status 2.0
14819	>	OOPSE config.status 4.0
14820		configured by $0, generated by GNU Autoconf 2.59,
14821		with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14822
#	Line 8560 | Line 14921 | do
14921		# Handling of arguments.
14922		"make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14923		"src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14924	<	"src/utils/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/utils/getopt.h:src/utils/gnugetopt.h" ;;
14924	>	"src/math/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
14925	>	"src/applications/staticProps/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/staticProps/Makefile" ;;
14926	>	"scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14927	>	"src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14928		"src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14929		*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
14930		echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
#	Line 8647 | Line 15011 | s,@LIBS@,$LIBS,;t t
15011		s,@ECHO_N@,$ECHO_N,;t t
15012		s,@ECHO_T@,$ECHO_T,;t t
15013		s,@LIBS@,$LIBS,;t t
8650	–	s,@PROGNAME@,$PROGNAME,;t t
8651	–	s,@debug@,$debug,;t t
15014		s,@build@,$build,;t t
15015		s,@build_cpu@,$build_cpu,;t t
15016		s,@build_vendor@,$build_vendor,;t t
#	Line 8657 | Line 15019 | s,@host_os@,$host_os,;t t
15019		s,@host_cpu@,$host_cpu,;t t
15020		s,@host_vendor@,$host_vendor,;t t
15021		s,@host_os@,$host_os,;t t
15022	<	s,@CC@,$CC,;t t
15023	<	s,@CFLAGS@,$CFLAGS,;t t
15022	>	s,@PROGNAME@,$PROGNAME,;t t
15023	>	s,@debug@,$debug,;t t
15024	>	s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
15025	>	s,@CXX@,$CXX,;t t
15026	>	s,@CXXFLAGS@,$CXXFLAGS,;t t
15027		s,@LDFLAGS@,$LDFLAGS,;t t
15028		s,@CPPFLAGS@,$CPPFLAGS,;t t
15029	<	s,@ac_ct_CC@,$ac_ct_CC,;t t
15029	>	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15030		s,@EXEEXT@,$EXEEXT,;t t
15031		s,@OBJEXT@,$OBJEXT,;t t
15032	<	s,@CXX@,$CXX,;t t
15033	<	s,@CXXFLAGS@,$CXXFLAGS,;t t
15034	<	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15035	<	s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15036	<	s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15037	<	s,@F90@,$F90,;t t
8673	<	s,@F90FLAGS@,$F90FLAGS,;t t
8674	<	s,@ac_ct_F90@,$ac_ct_F90,;t t
8675	<	s,@PREPFLAG@,$PREPFLAG,;t t
8676	<	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8677	<	s,@F90LIBS@,$F90LIBS,;t t
8678	<	s,@F90_FUNC@,$F90_FUNC,;t t
8679	<	s,@F90_FUNC_@,$F90_FUNC_,;t t
8680	<	s,@MOD@,$MOD,;t t
8681	<	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8682	<	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8683	<	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
8684	<	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15032	>	s,@CC@,$CC,;t t
15033	>	s,@CFLAGS@,$CFLAGS,;t t
15034	>	s,@ac_ct_CC@,$ac_ct_CC,;t t
15035	>	s,@FC@,$FC,;t t
15036	>	s,@FCFLAGS@,$FCFLAGS,;t t
15037	>	s,@ac_ct_FC@,$ac_ct_FC,;t t
15038		s,@CPP@,$CPP,;t t
15039		s,@EGREP@,$EGREP,;t t
8687	–	s,@LIBOBJS@,$LIBOBJS,;t t
8688	–	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8689	–	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8690	–	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15040		s,@LN_S@,$LN_S,;t t
15041		s,@SET_MAKE@,$SET_MAKE,;t t
15042		s,@RANLIB@,$RANLIB,;t t
15043		s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15044	<	s,@YACC@,$YACC,;t t
15045	<	s,@LEX@,$LEX,;t t
15046	<	s,@LEXLIB@,$LEXLIB,;t t
15047	<	s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15044	>	s,@PERLINTERP@,$PERLINTERP,;t t
15045	>	s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15046	>	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15047	>	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15048	>	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15049		s,@AR@,$AR,;t t
15050	+	s,@PS@,$PS,;t t
15051	+	s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15052	+	s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15053	+	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15054	+	s,@FCLIBS@,$FCLIBS,;t t
15055	+	s,@FC_FUNC@,$FC_FUNC,;t t
15056	+	s,@FC_FUNC_@,$FC_FUNC_,;t t
15057	+	s,@MOD@,$MOD,;t t
15058	+	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15059	+	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15060	+	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15061	+	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15062	+	s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
15063	+	s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
15064	+	s,@ZLIB@,$ZLIB,;t t
15065	+	s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
15066	+	s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
15067	+	s,@FFTW_LIBS@,$FFTW_LIBS,;t t
15068	+	s,@LIBOBJS@,$LIBOBJS,;t t
15069	+	s,@POW_LIB@,$POW_LIB,;t t
15070	+	s,@CXXCPP@,$CXXCPP,;t t
15071	+	s,@__func__@,$__func__,;t t
15072		s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15073		s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15074		s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15075		s,@MPI_LIB@,$MPI_LIB,;t t
15076		s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15077		s,@USE_MPI@,$USE_MPI,;t t
15078	<	s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
15079	<	s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
15080	<	s,@SPRNG_LIB@,$SPRNG_LIB,;t t
15081	<	s,@USE_SPRNG@,$USE_SPRNG,;t t
15082	<	s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
8711	<	s,@MKL_LIB@,$MKL_LIB,;t t
8712	<	s,@MKL_INC@,$MKL_INC,;t t
8713	<	s,@HAVE_MKL@,$HAVE_MKL,;t t
15078	>	s,@USE_CGAL@,$USE_CGAL,;t t
15079	>	s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080	>	s,@CGAL_LDFLAGS@,$CGAL_LDFLAGS,;t t
15081	>	s,@CGAL_CPPFLAGS@,$CGAL_CPPFLAGS,;t t
15082	>	s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15083		s,@DOXYGEN@,$DOXYGEN,;t t
15084		s,@DOT@,$DOT,;t t
15085		s,@DOC@,$DOC,;t t
#	Line 8722 | Line 15091 | s,@SUBDIRS@,$SUBDIRS,;t t
15091		s,@OOPSE@,$OOPSE,;t t
15092		s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15093		s,@SUBDIRS@,$SUBDIRS,;t t
8725	–	s,@FFLAGS@,$FFLAGS,;t t
15094		s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15095		CEOF
15096
#	Line 8960 | Line 15328 | s,@INSTALL@,$ac_INSTALL,;t t
15328		rm -f $tmp/out
15329		fi
15330
15331	+	# Run the commands associated with the file.
15332	+	case $ac_file in
15333	+	make/Makefile ) chmod 0755 scripts/* ;;
15334	+	src/utils/Makefile ) chmod 0755 scripts/* ;;
15335	+	src/math/Makefile ) chmod 0755 scripts/* ;;
15336	+	src/applications/staticProps/Makefile ) chmod 0755 scripts/* ;;
15337	+	scripts/filepp ) chmod 0755 scripts/* ;;
15338	+	esac
15339		done
15340		_ACEOF
15341		cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

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