ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 956 by gezelter, Tue May 16 02:06:37 2006 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.59 for OOPSE 1.0.
3	>	# Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4		#
5		# Report bugs to <gezelter@nd.edu>.
6		#
#	Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269		# Identity of this package.
270		PACKAGE_NAME='OOPSE'
271		PACKAGE_TARNAME='oopse'
272	<	PACKAGE_VERSION='1.0'
273	<	PACKAGE_STRING='OOPSE 1.0'
272	>	PACKAGE_VERSION='3.0'
273	>	PACKAGE_STRING='OOPSE 3.0'
274		PACKAGE_BUGREPORT='gezelter@nd.edu'
275
276	<	ac_unique_file="src/oopse.cpp"
276	>	ac_unique_file="src/applications/oopse/oopse.cpp"
277		ac_default_prefix="/usr/local"
278		# Factoring default headers for most tests.
279		ac_includes_default="\
#	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 CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315	>	ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316		ac_subst_files=''
317
318		# Initialize some variables set by options.
#	Line 753 | Line 753 | ac_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 1.0 to adapt to many kinds of systems.
804	>	\`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805
806		Usage: $0 [OPTION]... [VAR=VALUE]...
807
#	Line 858 | Line 862 | if test -n "$ac_init_help"; then
862
863		if test -n "$ac_init_help"; then
864		case $ac_init_help in
865	<	short | recursive ) echo "Configuration of OOPSE 1.0:";;
865	>	short | recursive ) echo "Configuration of OOPSE 3.0:";;
866		esac
867		cat <<\_ACEOF
868
869		Optional Features:
870		--disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871		--enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
868	–	--enable-debug          Compile OOPSE in debug mode
872		--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873	+	--enable-debug          Compile OOPSE in debug mode
874	+	--enable-doxygen        enable documentation generation with doxygen (auto)
875	+	--enable-dot            use 'dot' to generate graphs in doxygen (auto)
876	+	--enable-html-docs      enable HTML generation with doxygen (yes)
877	+	--enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
878
879		Optional Packages:
880		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882	+	--with-perl-shebang     override what perl thinks is the way for the kernel
883	+	to start it (seldom needed)
884	+	--with-zlib=DIR root directory path of zlib installation defaults to
885	+	/usr/local or /usr if not found in /usr/local
886	+	--without-zlib to disable zlib usage completely
887	+	--without-fftw          if you turn this off you cannot compute undulation spectra
888		--with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889	<	--with-sprng=<prefix>   compile with SPRNG installed in <prefix>
876	<	[default=/usr/local]
877	<	--with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
889	>	--with-cgal-makefile=FILE  CGAL makefile that should be used
890
891		Some influential environment variables:
892	<	CC          C compiler command
893	<	CFLAGS      C compiler flags
892	>	CXX         C++ compiler command
893	>	CXXFLAGS    C++ compiler flags
894		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895		nonstandard directory <lib dir>
896		CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897		headers in a nonstandard directory <include dir>
898	<	CXX         C++ compiler command
899	<	CXXFLAGS    C++ compiler flags
900	<	F90         Fortran 90 compiler command
901	<	F90FLAGS    Fortran 90 compiler flags
898	>	CC          C compiler command
899	>	CFLAGS      C compiler flags
900	>	FC          Fortran compiler command
901	>	FCFLAGS     Fortran compiler flags
902		CPP         C preprocessor
903	+	CXXCPP      C++ preprocessor
904
905		Use these variables to override the choices made by `configure' or to help
906		it to find libraries and programs with nonstandard names/locations.
#	Line 988 | Line 1001 | if $ac_init_version; then
1001		test -n "$ac_init_help" && exit 0
1002		if $ac_init_version; then
1003		cat <<\_ACEOF
1004	<	OOPSE configure 1.0
1004	>	OOPSE configure 3.0
1005		generated by GNU Autoconf 2.59
1006
1007		Copyright (C) 2003 Free Software Foundation, Inc.
#	Line 1002 | Line 1015 | running configure, to aid debugging if configure makes
1015		This file contains any messages produced by compilers while
1016		running configure, to aid debugging if configure makes a mistake.
1017
1018	<	It was created by OOPSE $as_me 1.0, which was
1018	>	It was created by OOPSE $as_me 3.0, which was
1019		generated by GNU Autoconf 2.59.  Invocation command line was
1020
1021		$ $0 $@
#	Line 1362 | Line 1375 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1375		ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1376		ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1377		ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1365	–
1366	–
1367	–	# This file is part of Autoconf.                       -*- Autoconf -*-
1368	–	# Programming languages support.
1369	–	# Copyright 2000, 2001
1370	–	# Free Software Foundation, Inc.
1371	–	#
1372	–	# This program is free software; you can redistribute it and/or modify
1373	–	# it under the terms of the GNU General Public License as published by
1374	–	# the Free Software Foundation; either version 2, or (at your option)
1375	–	# any later version.
1376	–	#
1377	–	# This program is distributed in the hope that it will be useful,
1378	–	# but WITHOUT ANY WARRANTY; without even the implied warranty of
1379	–	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1380	–	# GNU General Public License for more details.
1381	–	#
1382	–	# You should have received a copy of the GNU General Public License
1383	–	# along with this program; if not, write to the Free Software
1384	–	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1385	–	# 02111-1307, USA.
1386	–	#
1387	–	# As a special exception, the Free Software Foundation gives unlimited
1388	–	# permission to copy, distribute and modify the configure scripts that
1389	–	# are the output of Autoconf.  You need not follow the terms of the GNU
1390	–	# General Public License when using or distributing such scripts, even
1391	–	# though portions of the text of Autoconf appear in them.  The GNU
1392	–	# General Public License (GPL) does govern all other use of the material
1393	–	# that constitutes the Autoconf program.
1394	–	#
1395	–	# Certain portions of the Autoconf source text are designed to be copied
1396	–	# (in certain cases, depending on the input) into the output of
1397	–	# Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1398	–	# source text consists of comments plus executable code that decides which
1399	–	# of the data portions to output in any given case.  We call these
1400	–	# comments and executable code the "non-data" portions.  Autoconf never
1401	–	# copies any of the non-data portions into its output.
1402	–	#
1403	–	# This special exception to the GPL applies to versions of Autoconf
1404	–	# released by the Free Software Foundation.  When you make and
1405	–	# distribute a modified version of Autoconf, you may extend this special
1406	–	# exception to the GPL to apply to your modified version as well, *unless*
1407	–	# your modified version has the potential to copy into its output some
1408	–	# of the text that was the non-data portion of the version that you started
1409	–	# with.  (In other words, unless your change moves or copies text from
1410	–	# the non-data portions to the data portions.)  If your modification has
1411	–	# such potential, you must delete any notice of this special exception
1412	–	# to the GPL from your modified version.
1413	–	#
1414	–	# Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1415	–	# many others).
1378
1379
1380	<	# Table of Contents:
1419	<	#
1420	<	# 1. Language selection
1421	<	#    and routines to produce programs in a given language.
1422	<	#  a. Fortran 77 (to be moved from aclang.m4)
1423	<	#  b. Fortran 90
1424	<	#  c. Fortran 95
1425	<	#
1426	<	# 2. Producing programs in a given language.
1427	<	#  a. Fortran 77 (to be moved from aclang.m4)
1428	<	#  b. Fortran 90
1429	<	#  c. Fortran 95
1430	<	#
1431	<	# 3. Looking for a compiler
1432	<	#    And possibly the associated preprocessor.
1433	<	#  a. Fortran 77 (to be moved from aclang.m4)
1434	<	#  b. Fortran 90
1435	<	#  c. Fortran 95
1436	<	#
1437	<	# 4. Compilers' characteristics.
1438	<	#  a. Fortran 77 (to be moved from aclang.m4)
1439	<	#  b. Fortran 90
1440	<	#  c. Fortran 95
1441	<
1442	<	# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1443	<	# ---------------------------------------------------------------------------
1444	<	#
1445	<	# Processing the elements of a list is tedious in shell programming,
1446	<	# as lists tend to be implemented as space delimited strings.
1447	<	#
1448	<	# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1449	<	# if ELEMENT is a member of LIST, otherwise it executes
1450	<	# ACTION-IF-NOT-FOUND.
1451	<	# _AC_LIST_MEMBER_IF
1452	<
1453	<
1454	<
1455	<	# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1456	<	# -------------------------------------------------
1457	<	#
1458	<	# Specifying options to the compiler (whether it be the C, C++ or
1459	<	# Fortran 77 compiler) that are meant for the linker is compiler
1460	<	# dependent.  This macro lets you give options to the compiler that
1461	<	# are meant for the linker in a portable, compiler-independent way.
1462	<	#
1463	<	# This macro take two arguments, a list of linker options that the
1464	<	# compiler should pass to the linker (LINKER-OPTIONS) and the name of
1465	<	# a shell variable (SHELL-VARIABLE).  The list of linker options are
1466	<	# appended to the shell variable in a compiler-dependent way.
1467	<	#
1468	<	# For example, if the selected language is C, then this:
1469	<	#
1470	<	#   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1471	<	#
1472	<	# will expand into this if the selected C compiler is gcc:
1473	<	#
1474	<	#   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1475	<	#
1476	<	# otherwise, it will expand into this:
1477	<	#
1478	<	#   foo_LDFLAGS"-R /usr/local/lib/foo"
1479	<	#
1480	<	# You are encouraged to add support for compilers that this macro
1481	<	# doesn't currently support.
1482	<	# FIXME: Get rid of this macro.
1483	<	# _AC_LINKER_OPTION
1484	<
1485	<
1486	<
1487	<	## ----------------------- ##
1488	<	## 1. Language selection.  ##
1489	<	## ----------------------- ##
1490	<
1491	<	# ----------------------------- #
1492	<	# 1b. The Fortran 90 language.  #
1493	<	# ----------------------------- #
1494	<
1495	<	# AC_LANG(Fortran 90)
1496	<	# -------------------
1497	<
1498	<
1499	<
1500	<	# _AC_LANG_ABBREV(Fortran 90)
1501	<	# ---------------------------
1502	<
1503	<
1504	<
1505	<	# ----------------------------- #
1506	<	# 1c. The Fortran 95 language.  #
1507	<	# ----------------------------- #
1508	<
1509	<	# AC_LANG(Fortran 95)
1510	<	# -------------------
1511	<
1512	<
1513	<
1514	<	# _AC_LANG_ABBREV(Fortran 95)
1515	<	# ---------------------------
1516	<
1517	<
1518	<
1519	<	## ---------------------- ##
1520	<	## 2.Producing programs.  ##
1521	<	## ---------------------- ##
1522	<
1523	<	# ------------------------ #
1524	<	# 2b. Fortran 90 sources.  #
1525	<	# ------------------------ #
1526	<
1527	<	# AC_LANG_SOURCE(Fortran 90)(BODY)
1528	<	# --------------------------------
1529	<
1530	<
1531	<
1532	<	# AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1533	<	# -----------------------------------------------
1380	>	ac_config_headers="$ac_config_headers src/config.h"
1381
1382
1536	–	# AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1537	–	# --------------------------------------------
1383
1384
1385
1541	–	# ------------------------ #
1542	–	# 2c. Fortran 95 sources.  #
1543	–	# ------------------------ #
1386
1545	–	# AC_LANG_SOURCE(Fortran 95)(BODY)
1546	–	# --------------------------------
1387
1388
1549	–	# AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1550	–	# -----------------------------------------------
1389
1390
1553	–	# AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1554	–	# --------------------------------------------
1391
1392
1393
1558	–	## -------------------------------------------- ##
1559	–	## 3. Looking for Compilers and Preprocessors.  ##
1560	–	## -------------------------------------------- ##
1394
1562	–	# ----------------------------- #
1563	–	# 3b. The Fortran 90 compiler.  #
1564	–	# ----------------------------- #
1395
1396
1567	–	# AC_LANG_PREPROC(Fortran 90)
1568	–	# ---------------------------
1569	–	# Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1397
1398
1399
1573	–	# AC_LANG_COMPILER(Fortran 90)
1574	–	# ----------------------------
1575	–	# Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1576	–	# AC_REQUIRE'able.
1400
1401
1402
1580	–	# AC_PROG_F90([COMPILERS...])
1581	–	# ---------------------------
1582	–	# COMPILERS is a space separated list of Fortran 90 compilers to search
1583	–	# for.
1584	–	#
1585	–	# Compilers are ordered by
1586	–	#  1. F90, F95
1587	–	#  2. Good/tested native compilers, bad/untested native compilers
1588	–	#
1589	–	# pgf90 is the Portland Group F90 compilers.
1590	–	# xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1591	–	# lf95 is the Lahey-Fujitsu compiler.
1592	–	# epcf90 is the "Edinburgh Portable Compiler" F90.
1593	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1594	–	# AC_PROG_F90
1403
1404
1597	–	# ----------------------------- #
1598	–	# 3c. The Fortran 95 compiler.  #
1599	–	# ----------------------------- #
1405
1406
1602	–	# AC_LANG_PREPROC(Fortran 95)
1603	–	# ---------------------------
1604	–	# Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1407
1408
1409
1608	–	# AC_LANG_COMPILER(Fortran 95)
1609	–	# ----------------------------
1610	–	# Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1611	–	# AC_REQUIRE'able.
1410
1411
1412
1615	–	# AC_PROG_F95([COMPILERS...])
1616	–	# ---------------------------
1617	–	# COMPILERS is a space separated list of Fortran 95 compilers to search
1618	–	# for.
1619	–	#
1620	–	# Compilers are ordered by
1621	–	#  1. Good/tested native compilers, bad/untested native compilers
1622	–	#
1623	–	# xlf95 is the IBM (AIX) F95 compiler.
1624	–	# lf95 is the Lahey-Fujitsu compiler.
1625	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1626	–	# AC_PROG_F95
1413
1414
1629	–	## ------------------------------- ##
1630	–	## 4. Compilers' characteristics.  ##
1631	–	## ------------------------------- ##
1415
1416
1417	<	# ---------------------------------------- #
1418	<	# 4b. Fortan 90 compiler characteristics.  #
1419	<	# ---------------------------------------- #
1417	>	# ACX_CHECK_FFTW()
1418	>	# ----------------
1419	>	# This macro checks for fftw header files and libraries,
1420	>	# including the possible prefixing with s or d to determine precision.
1421	>	# Arg 1 is the fftw header/library name to check for, without
1422	>	# prefix or anything else (e.g. rfftw_mpi for real MPI transforms)
1423	>	# Arg 2 is the size of the real variable used.
1424
1425
1639	–	# _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1640	–	# -------------------------------------------------
1641	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1642	–	# (which default value, $ac_cv_prog_f90_v, is computed by
1643	–	# _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1644	–	# output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1645	–	# so that any link flags that are echoed by the compiler appear as
1646	–	# space-separated items.
1647	–	# _AC_PROG_F90_V_OUTPUT
1426
1427
1650	–	# _AC_PROG_F90_V
1651	–	# --------------
1652	–	#
1653	–	# Determine the flag that causes the Fortran 90 compiler to print
1654	–	# information of library and object files (normally -v)
1655	–	# Needed for AC_F90_LIBRARY_FLAGS
1656	–	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1657	–	# _AC_PROG_F90_V
1428
1429
1660	–	# AC_F90_LIBRARY_LDFLAGS
1661	–	# ----------------------
1662	–	#
1663	–	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1664	–	# intrinsic and run-time libraries that are required to successfully
1665	–	# link a Fortran 90 program or shared library.  The output variable
1666	–	# F90LIBS is set to these flags.
1667	–	#
1668	–	# This macro is intended to be used in those situations when it is
1669	–	# necessary to mix, e.g. C++ and Fortran 90, source code into a single
1670	–	# program or shared library.
1671	–	#
1672	–	# For example, if object files from a C++ and Fortran 90 compiler must
1673	–	# be linked together, then the C++ compiler/linker must be used for
1674	–	# linking (since special C++-ish things need to happen at link time
1675	–	# like calling global constructors, instantiating templates, enabling
1676	–	# exception support, etc.).
1677	–	#
1678	–	# However, the Fortran 90 intrinsic and run-time libraries must be
1679	–	# linked in as well, but the C++ compiler/linker doesn't know how to
1680	–	# add these Fortran 90 libraries.  Hence, the macro
1681	–	# "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1682	–	# libraries.
1683	–	#
1684	–	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1685	–	# AC_F90_LIBRARY_LDFLAGS
1430
1431
1688	–	# _AC_F90_NAME_MANGLING
1689	–	# ---------------------
1690	–	# Test for the name mangling scheme used by the Fortran 90 compiler.
1691	–	#
1692	–	# Sets ac_cv_f90_mangling. The value contains three fields, separated
1693	–	# by commas:
1694	–	#
1695	–	# lower case / upper case:
1696	–	#    case translation of the Fortan 90 symbols
1697	–	# underscore / no underscore:
1698	–	#    whether the compiler appends "_" to symbol names
1699	–	# extra underscore / no extra underscore:
1700	–	#    whether the compiler appends an extra "_" to symbol names already
1701	–	#    containing at least one underscore
1702	–	#
1703	–	# _AC_F90_NAME_MANGLING
1432
1705	–	# The replacement is empty.
1433
1434
1435
1709	–	# AC_F90_WRAPPERS
1710	–	# ---------------
1711	–	# Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1712	–	# properly mangle the names of C identifiers, and C identifiers with
1713	–	# underscores, respectively, so that they match the name mangling
1714	–	# scheme used by the Fortran 90 compiler.
1715	–	# AC_F90_WRAPPERS
1716	–
1717	–
1718	–	# AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1719	–	# ------------------------------------
1720	–	# For a Fortran subroutine of given NAME, define a shell variable
1721	–	# $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1722	–	# argument is not supplied, it defaults to NAME.
1723	–	# AC_F90_FUNC
1724	–
1725	–
1726	–	# ---------------------------------------- #
1727	–	# 4c. Fortan 95 compiler characteristics.  #
1728	–	# ---------------------------------------- #
1729	–
1730	–
1731	–	# _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1732	–	# -------------------------------------------------
1733	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1734	–	# (which default value, $ac_cv_prog_f95_v, is computed by
1735	–	# _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1736	–	# output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1737	–	# so that any link flags that are echoed by the compiler appear as
1738	–	# space-separated items.
1739	–	# _AC_PROG_F95_V_OUTPUT
1740	–
1741	–
1742	–	# _AC_PROG_F95_V
1743	–	# --------------
1436		#
1745	–	# Determine the flag that causes the Fortran 95 compiler to print
1746	–	# information of library and object files (normally -v)
1747	–	# Needed for AC_F95_LIBRARY_FLAGS
1748	–	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1749	–	# _AC_PROG_F95_V
1750	–
1751	–
1752	–	# AC_F95_LIBRARY_LDFLAGS
1753	–	# ----------------------
1437		#
1755	–	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1756	–	# intrinsic and run-time libraries that are required to successfully
1757	–	# link a Fortran 95 program or shared library.  The output variable
1758	–	# F95LIBS is set to these flags.
1438		#
1760	–	# This macro is intended to be used in those situations when it is
1761	–	# necessary to mix, e.g. C++ and Fortran 95, source code into a single
1762	–	# program or shared library.
1763	–	#
1764	–	# For example, if object files from a C++ and Fortran 95 compiler must
1765	–	# be linked together, then the C++ compiler/linker must be used for
1766	–	# linking (since special C++-ish things need to happen at link time
1767	–	# like calling global constructors, instantiating templates, enabling
1768	–	# exception support, etc.).
1769	–	#
1770	–	# However, the Fortran 95 intrinsic and run-time libraries must be
1771	–	# linked in as well, but the C++ compiler/linker doesn't know how to
1772	–	# add these Fortran 95 libraries.  Hence, the macro
1773	–	# "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1774	–	# libraries.
1775	–	#
1776	–	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1777	–	# AC_F95_LIBRARY_LDFLAGS
1439
1440
1441	<	# _AC_F95_NAME_MANGLING
1442	<	# ---------------------
1782	<	# Test for the name mangling scheme used by the Fortran 95 compiler.
1441	>	# AC_F90_MODULE_NAMES
1442	>	# -------------------
1443		#
1444	<	# Sets ac_cv_f95_mangling. The value contains three fields, separated
1785	<	# by commas:
1444	>	# Figure out how the Fortran 90 compiler constructs module file names
1445		#
1446	<	# lower case / upper case:
1788	<	#    case translation of the Fortan 95 symbols
1789	<	# underscore / no underscore:
1790	<	#    whether the compiler appends "_" to symbol names
1791	<	# extra underscore / no extra underscore:
1792	<	#    whether the compiler appends an extra "_" to symbol names already
1793	<	#    containing at least one underscore
1794	<	#
1795	<	# _AC_F95_NAME_MANGLING
1796	<
1797	<	# The replacement is empty.
1798	<
1799	<
1800	<
1801	<	# AC_F95_WRAPPERS
1802	<	# ---------------
1803	<	# Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1804	<	# properly mangle the names of C identifiers, and C identifiers with
1805	<	# underscores, respectively, so that they match the name mangling
1806	<	# scheme used by the Fortran 95 compiler.
1807	<	# AC_F95_WRAPPERS
1808	<
1809	<
1810	<	# AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1811	<	# ------------------------------------
1812	<	# For a Fortran subroutine of given NAME, define a shell variable
1813	<	# $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1814	<	# argument is not supplied, it defaults to NAME.
1815	<	# AC_F95_FUNC
1816	<
1817	<
1818	<
1819	<
1820	<
1821	<
1822	<
1823	<
1824	<
1825	<
1826	<
1827	<
1828	<
1829	<
1830	<
1831	<
1832	<
1833	<
1834	<
1835	<
1836	<
1837	<
1838	<
1839	<
1446	>	# AC_F90_MODULE_NAMES
1447
1448
1449
#	Line 1868 | Line 1475 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1475
1476
1477
1871	–	# set program name
1872	–	PROGNAME="oopse"
1478
1479
1875	–	# there are two ways to do debugging.  One with the --enable-debug flag
1876	–	# and one using the DEBUG environment variable
1480
1878	–	debug=0
1879	–	# Check whether --enable-debug or --disable-debug was given.
1880	–	if test "${enable_debug+set}" = set; then
1881	–	enableval="$enable_debug"
1882	–	debug=1
1883	–	fi;
1884	–	if test "${DEBUG}"; then
1481
1886	–	cat >>confdefs.h <<\_ACEOF
1887	–	#define debug 1
1888	–	_ACEOF
1482
1890	–	msg="$msg, debug mode"
1891	–	fi
1892	–
1893	–
1483		# who am i
1484		# Make sure we can run config.sub.
1485		$ac_config_sub sun4 >/dev/null 2>&1 ||
#	Line 1947 | Line 1536 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1536
1537
1538
1539	<	ac_ext=c
1540	<	ac_cpp='$CPP $CPPFLAGS'
1541	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1542	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1543	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
1539	>
1540	>
1541	>	# set program name
1542	>	PROGNAME="oopse"
1543	>
1544	>
1545	>
1546	>
1547	>	OBJEXT=".$OBJEXT"
1548	>
1549	>	OOPSE=oopse
1550	>
1551	>	if test "x${prefix}" = "xNONE"
1552	>	then
1553	>	OOPSE_HOME=${ac_default_prefix}/oopse
1554	>	else
1555	>	OOPSE_HOME=${prefix}/oopse
1556	>	fi
1557	>	# Check whether --enable-oopse-home or --disable-oopse-home was given.
1558	>	if test "${enable_oopse_home+set}" = set; then
1559	>	enableval="$enable_oopse_home"
1560	>	OOPSE_HOME="${enableval}"
1561	>	fi;
1562	>
1563	>	# there are two ways to do debugging.  One with the --enable-debug flag
1564	>	# and one using the DEBUG environment variable
1565	>
1566	>	debug=0
1567	>	# Check whether --enable-debug or --disable-debug was given.
1568	>	if test "${enable_debug+set}" = set; then
1569	>	enableval="$enable_debug"
1570	>	debug=1
1571	>	fi;
1572	>	if test "${DEBUG}"; then
1573	>
1574	>	cat >>confdefs.h <<\_ACEOF
1575	>	#define debug 1
1576	>	_ACEOF
1577	>
1578	>	msg="$msg, debug mode"
1579	>	fi
1580	>
1581	>
1582	>	# Checks for programs.
1583	>	ac_ext=cc
1584	>	ac_cpp='$CXXCPP $CPPFLAGS'
1585	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588		if test -n "$ac_tool_prefix"; then
1589	<	for ac_prog in icc xlc gcc cc
1589	>	for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1590		do
1591		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1592		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1593		echo "$as_me:$LINENO: checking for $ac_word" >&5
1594		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1595	<	if test "${ac_cv_prog_CC+set}" = set; then
1595	>	if test "${ac_cv_prog_CXX+set}" = set; then
1596		echo $ECHO_N "(cached) $ECHO_C" >&6
1597		else
1598	<	if test -n "$CC"; then
1599	<	ac_cv_prog_CC="$CC" # Let the user override the test.
1598	>	if test -n "$CXX"; then
1599	>	ac_cv_prog_CXX="$CXX" # Let the user override the test.
1600		else
1601		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1602		for as_dir in $PATH
#	Line 1972 | Line 1605 | do
1605		test -z "$as_dir" && as_dir=.
1606		for ac_exec_ext in '' $ac_executable_extensions; do
1607		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1608	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1608	>	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1609		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1610		break 2
1611		fi
#	Line 1981 | Line 1614 | fi
1614
1615		fi
1616		fi
1617	<	CC=$ac_cv_prog_CC
1618	<	if test -n "$CC"; then
1619	<	echo "$as_me:$LINENO: result: $CC" >&5
1620	<	echo "${ECHO_T}$CC" >&6
1617	>	CXX=$ac_cv_prog_CXX
1618	>	if test -n "$CXX"; then
1619	>	echo "$as_me:$LINENO: result: $CXX" >&5
1620	>	echo "${ECHO_T}$CXX" >&6
1621		else
1622		echo "$as_me:$LINENO: result: no" >&5
1623		echo "${ECHO_T}no" >&6
1624		fi
1625
1626	<	test -n "$CC" && break
1626	>	test -n "$CXX" && break
1627		done
1628		fi
1629	<	if test -z "$CC"; then
1630	<	ac_ct_CC=$CC
1631	<	for ac_prog in icc xlc gcc cc
1629	>	if test -z "$CXX"; then
1630	>	ac_ct_CXX=$CXX
1631	>	for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1632		do
1633		# Extract the first word of "$ac_prog", so it can be a program name with args.
1634		set dummy $ac_prog; ac_word=$2
1635		echo "$as_me:$LINENO: checking for $ac_word" >&5
1636		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1637	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1637	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1638		echo $ECHO_N "(cached) $ECHO_C" >&6
1639		else
1640	<	if test -n "$ac_ct_CC"; then
1641	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1640	>	if test -n "$ac_ct_CXX"; then
1641	>	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1642		else
1643		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644		for as_dir in $PATH
#	Line 2014 | Line 1647 | do
1647		test -z "$as_dir" && as_dir=.
1648		for ac_exec_ext in '' $ac_executable_extensions; do
1649		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1650	<	ac_cv_prog_ac_ct_CC="$ac_prog"
1650	>	ac_cv_prog_ac_ct_CXX="$ac_prog"
1651		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1652		break 2
1653		fi
#	Line 2023 | Line 1656 | fi
1656
1657		fi
1658		fi
1659	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660	<	if test -n "$ac_ct_CC"; then
1661	<	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662	<	echo "${ECHO_T}$ac_ct_CC" >&6
1659	>	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660	>	if test -n "$ac_ct_CXX"; then
1661	>	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662	>	echo "${ECHO_T}$ac_ct_CXX" >&6
1663		else
1664		echo "$as_me:$LINENO: result: no" >&5
1665		echo "${ECHO_T}no" >&6
1666		fi
1667
1668	<	test -n "$ac_ct_CC" && break
1668	>	test -n "$ac_ct_CXX" && break
1669		done
1670	+	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671
1672	<	CC=$ac_ct_CC
1672	>	CXX=$ac_ct_CXX
1673		fi
1674
1675
2042	–	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2043	–	See \`config.log' for more details." >&5
2044	–	echo "$as_me: error: no acceptable C compiler found in \$PATH
2045	–	See \`config.log' for more details." >&2;}
2046	–	{ (exit 1); exit 1; }; }
2047	–
1676		# Provide some information about the compiler.
1677		echo "$as_me:$LINENO:" \
1678	<	"checking for C compiler version" >&5
1678	>	"checking for C++ compiler version" >&5
1679		ac_compiler=`set X $ac_compile; echo $2`
1680		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1681		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2085 | Line 1713 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1713		# Try to create an executable without -o first, disregard a.out.
1714		# It will help us diagnose broken compilers, and finding out an intuition
1715		# of exeext.
1716	<	echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1717	<	echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1716	>	echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717	>	echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718		ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719		if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720		(eval $ac_link_default) 2>&5
#	Line 2129 | Line 1757 | sed 's/^/| /' conftest.$ac_ext >&5
1757		echo "$as_me: failed program was:" >&5
1758		sed 's/^/| /' conftest.$ac_ext >&5
1759
1760	<	{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
1760	>	{ { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1761		See \`config.log' for more details." >&5
1762	<	echo "$as_me: error: C compiler cannot create executables
1762	>	echo "$as_me: error: C++ compiler cannot create executables
1763		See \`config.log' for more details." >&2;}
1764		{ (exit 77); exit 77; }; }
1765		fi
#	Line 2142 | Line 1770 | echo "${ECHO_T}$ac_file" >&6
1770
1771		# Check the compiler produces executables we can run.  If not, either
1772		# the compiler is broken, or we cross compile.
1773	<	echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774	<	echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773	>	echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774	>	echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775		# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776		# If not cross compiling, check that we can run a simple program.
1777		if test "$cross_compiling" != yes; then
#	Line 2158 | Line 1786 | if test "$cross_compiling" != yes; then
1786		if test "$cross_compiling" = maybe; then
1787		cross_compiling=yes
1788		else
1789	<	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1789	>	{ { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1790		If you meant to cross compile, use \`--host'.
1791		See \`config.log' for more details." >&5
1792	<	echo "$as_me: error: cannot run C compiled programs.
1792	>	echo "$as_me: error: cannot run C++ compiled programs.
1793		If you meant to cross compile, use \`--host'.
1794		See \`config.log' for more details." >&2;}
1795		{ (exit 1); exit 1; }; }
#	Line 2266 | Line 1894 | ac_objext=$OBJEXT
1894		echo "${ECHO_T}$ac_cv_objext" >&6
1895		OBJEXT=$ac_cv_objext
1896		ac_objext=$OBJEXT
1897	<	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898	<	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897	>	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898	>	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900		echo $ECHO_N "(cached) $ECHO_C" >&6
1901		else
1902		cat >conftest.$ac_ext <<_ACEOF
#	Line 2298 | Line 1926 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1926		cat conftest.err >&5
1927		echo "$as_me:$LINENO: \$? = $ac_status" >&5
1928		(exit $ac_status); } &&
1929	<	{ ac_try='test -z "$ac_c_werror_flag"
1929	>	{ ac_try='test -z "$ac_cxx_werror_flag"
1930		|| test ! -s conftest.err'
1931		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1932		(eval $ac_try) 2>&5
#	Line 2319 | Line 1947 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
1947		ac_compiler_gnu=no
1948		fi
1949		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
1950	>	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951
1952		fi
1953	<	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954	<	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955	<	GCC=`test $ac_compiler_gnu = yes && echo yes`
1956	<	ac_test_CFLAGS=${CFLAGS+set}
1957	<	ac_save_CFLAGS=$CFLAGS
1958	<	CFLAGS="-g"
1959	<	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960	<	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961	<	if test "${ac_cv_prog_cc_g+set}" = set; then
1953	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954	>	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955	>	GXX=`test $ac_compiler_gnu = yes && echo yes`
1956	>	ac_test_CXXFLAGS=${CXXFLAGS+set}
1957	>	ac_save_CXXFLAGS=$CXXFLAGS
1958	>	CXXFLAGS="-g"
1959	>	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960	>	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961	>	if test "${ac_cv_prog_cxx_g+set}" = set; then
1962		echo $ECHO_N "(cached) $ECHO_C" >&6
1963		else
1964		cat >conftest.$ac_ext <<_ACEOF
#	Line 2357 | Line 1985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1985		cat conftest.err >&5
1986		echo "$as_me:$LINENO: \$? = $ac_status" >&5
1987		(exit $ac_status); } &&
1988	<	{ ac_try='test -z "$ac_c_werror_flag"
1988	>	{ ac_try='test -z "$ac_cxx_werror_flag"
1989		|| test ! -s conftest.err'
1990		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1991		(eval $ac_try) 2>&5
#	Line 2370 | Line 1998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1998		ac_status=$?
1999		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2000		(exit $ac_status); }; }; then
2001	<	ac_cv_prog_cc_g=yes
2001	>	ac_cv_prog_cxx_g=yes
2002		else
2003		echo "$as_me: failed program was:" >&5
2004		sed 's/^/| /' conftest.$ac_ext >&5
2005
2006	<	ac_cv_prog_cc_g=no
2006	>	ac_cv_prog_cxx_g=no
2007		fi
2008		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2009		fi
2010	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2011	<	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2012	<	if test "$ac_test_CFLAGS" = set; then
2013	<	CFLAGS=$ac_save_CFLAGS
2014	<	elif test $ac_cv_prog_cc_g = yes; then
2015	<	if test "$GCC" = yes; then
2016	<	CFLAGS="-g -O2"
2010	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2011	>	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2012	>	if test "$ac_test_CXXFLAGS" = set; then
2013	>	CXXFLAGS=$ac_save_CXXFLAGS
2014	>	elif test $ac_cv_prog_cxx_g = yes; then
2015	>	if test "$GXX" = yes; then
2016	>	CXXFLAGS="-g -O2"
2017		else
2018	<	CFLAGS="-g"
2018	>	CXXFLAGS="-g"
2019		fi
2020		else
2021	<	if test "$GCC" = yes; then
2022	<	CFLAGS="-O2"
2021	>	if test "$GXX" = yes; then
2022	>	CXXFLAGS="-O2"
2023		else
2024	<	CFLAGS=
2024	>	CXXFLAGS=
2025		fi
2026		fi
2027	<	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2400	<	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2401	<	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2402	<	echo $ECHO_N "(cached) $ECHO_C" >&6
2403	<	else
2404	<	ac_cv_prog_cc_stdc=no
2405	<	ac_save_CC=$CC
2406	<	cat >conftest.$ac_ext <<_ACEOF
2407	<	/* confdefs.h.  */
2408	<	_ACEOF
2409	<	cat confdefs.h >>conftest.$ac_ext
2410	<	cat >>conftest.$ac_ext <<_ACEOF
2411	<	/* end confdefs.h.  */
2412	<	#include <stdarg.h>
2413	<	#include <stdio.h>
2414	<	#include <sys/types.h>
2415	<	#include <sys/stat.h>
2416	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2417	<	struct buf { int x; };
2418	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2419	<	static char *e (p, i)
2420	<	char **p;
2421	<	int i;
2422	<	{
2423	<	return p[i];
2424	<	}
2425	<	static char *f (char * (*g) (char **, int), char **p, ...)
2426	<	{
2427	<	char *s;
2428	<	va_list v;
2429	<	va_start (v,p);
2430	<	s = g (p, va_arg (v,int));
2431	<	va_end (v);
2432	<	return s;
2433	<	}
2434	<
2435	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2436	<	function prototypes and stuff, but not '\xHH' hex character constants.
2437	<	These don't provoke an error unfortunately, instead are silently treated
2438	<	as 'x'.  The following induces an error, until -std1 is added to get
2439	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2440	<	array size at least.  It's necessary to write '\x00'==0 to get something
2441	<	that's true only with -std1.  */
2442	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2443	<
2444	<	int test (int i, double x);
2445	<	struct s1 {int (*f) (int a);};
2446	<	struct s2 {int (*f) (double a);};
2447	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2448	<	int argc;
2449	<	char **argv;
2450	<	int
2451	<	main ()
2452	<	{
2453	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2454	<	;
2455	<	return 0;
2456	<	}
2457	<	_ACEOF
2458	<	# Don't try gcc -ansi; that turns off useful extensions and
2459	<	# breaks some systems' header files.
2460	<	# AIX                   -qlanglvl=ansi
2461	<	# Ultrix and OSF/1      -std1
2462	<	# HP-UX 10.20 and later -Ae
2463	<	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2464	<	# SVR4                  -Xc -D__EXTENSIONS__
2465	<	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2466	<	do
2467	<	CC="$ac_save_CC $ac_arg"
2468	<	rm -f conftest.$ac_objext
2469	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2470	<	(eval $ac_compile) 2>conftest.er1
2471	<	ac_status=$?
2472	<	grep -v '^ *+' conftest.er1 >conftest.err
2473	<	rm -f conftest.er1
2474	<	cat conftest.err >&5
2475	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2476	<	(exit $ac_status); } &&
2477	<	{ ac_try='test -z "$ac_c_werror_flag"
2478	<	|| test ! -s conftest.err'
2479	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2480	<	(eval $ac_try) 2>&5
2481	<	ac_status=$?
2482	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2483	<	(exit $ac_status); }; } &&
2484	<	{ ac_try='test -s conftest.$ac_objext'
2485	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2486	<	(eval $ac_try) 2>&5
2487	<	ac_status=$?
2488	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2489	<	(exit $ac_status); }; }; then
2490	<	ac_cv_prog_cc_stdc=$ac_arg
2491	<	break
2492	<	else
2493	<	echo "$as_me: failed program was:" >&5
2494	<	sed 's/^/| /' conftest.$ac_ext >&5
2495	<
2496	<	fi
2497	<	rm -f conftest.err conftest.$ac_objext
2498	<	done
2499	<	rm -f conftest.$ac_ext conftest.$ac_objext
2500	<	CC=$ac_save_CC
2501	<
2502	<	fi
2503	<
2504	<	case "x$ac_cv_prog_cc_stdc" in
2505	<	x|xno)
2506	<	echo "$as_me:$LINENO: result: none needed" >&5
2507	<	echo "${ECHO_T}none needed" >&6 ;;
2508	<	*)
2509	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2510	<	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2511	<	CC="$CC $ac_cv_prog_cc_stdc" ;;
2512	<	esac
2513	<
2514	<	# Some people use a C++ compiler to compile C.  Since we use `exit',
2515	<	# in C++ we need to declare it.  In case someone uses the same compiler
2516	<	# for both compiling C and C++ we need to have the C++ compiler decide
2517	<	# the declaration of exit, since it's the most demanding environment.
2518	<	cat >conftest.$ac_ext <<_ACEOF
2519	<	#ifndef __cplusplus
2520	<	choke me
2521	<	#endif
2522	<	_ACEOF
2523	<	rm -f conftest.$ac_objext
2524	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2525	<	(eval $ac_compile) 2>conftest.er1
2526	<	ac_status=$?
2527	<	grep -v '^ *+' conftest.er1 >conftest.err
2528	<	rm -f conftest.er1
2529	<	cat conftest.err >&5
2530	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2531	<	(exit $ac_status); } &&
2532	<	{ ac_try='test -z "$ac_c_werror_flag"
2533	<	|| test ! -s conftest.err'
2534	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2535	<	(eval $ac_try) 2>&5
2536	<	ac_status=$?
2537	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2538	<	(exit $ac_status); }; } &&
2539	<	{ ac_try='test -s conftest.$ac_objext'
2540	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2541	<	(eval $ac_try) 2>&5
2542	<	ac_status=$?
2543	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2544	<	(exit $ac_status); }; }; then
2545	<	for ac_declaration in \
2027	>	for ac_declaration in \
2028		'' \
2029		'extern "C" void std::exit (int) throw (); using std::exit;' \
2030		'extern "C" void std::exit (int); using std::exit;' \
#	Line 2575 | Line 2057 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2057		cat conftest.err >&5
2058		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2059		(exit $ac_status); } &&
2060	<	{ ac_try='test -z "$ac_c_werror_flag"
2060	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2061		|| test ! -s conftest.err'
2062		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2063		(eval $ac_try) 2>&5
#	Line 2620 | Line 2102 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2102		cat conftest.err >&5
2103		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104		(exit $ac_status); } &&
2105	<	{ ac_try='test -z "$ac_c_werror_flag"
2105	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2106		|| test ! -s conftest.err'
2107		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108		(eval $ac_try) 2>&5
#	Line 2648 | Line 2130 | fi
2130		echo '#endif'             >>confdefs.h
2131		fi
2132
2651	–	else
2652	–	echo "$as_me: failed program was:" >&5
2653	–	sed 's/^/| /' conftest.$ac_ext >&5
2654	–
2655	–	fi
2656	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2133		ac_ext=c
2134		ac_cpp='$CPP $CPPFLAGS'
2135		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2136		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2137		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2138
2139	<
2140	<	ac_ext=cc
2141	<	ac_cpp='$CXXCPP $CPPFLAGS'
2142	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2143	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2668	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2139	>	ac_ext=c
2140	>	ac_cpp='$CPP $CPPFLAGS'
2141	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2142	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2143	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2144		if test -n "$ac_tool_prefix"; then
2145	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2145	>	for ac_prog in icc pgcc pathcc cc xlc gcc
2146		do
2147		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2148		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2149		echo "$as_me:$LINENO: checking for $ac_word" >&5
2150		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2151	<	if test "${ac_cv_prog_CXX+set}" = set; then
2151	>	if test "${ac_cv_prog_CC+set}" = set; then
2152		echo $ECHO_N "(cached) $ECHO_C" >&6
2153		else
2154	<	if test -n "$CXX"; then
2155	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
2154	>	if test -n "$CC"; then
2155	>	ac_cv_prog_CC="$CC" # Let the user override the test.
2156		else
2157		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2158		for as_dir in $PATH
#	Line 2686 | Line 2161 | do
2161		test -z "$as_dir" && as_dir=.
2162		for ac_exec_ext in '' $ac_executable_extensions; do
2163		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2164	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2164	>	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2165		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2166		break 2
2167		fi
#	Line 2695 | Line 2170 | fi
2170
2171		fi
2172		fi
2173	<	CXX=$ac_cv_prog_CXX
2174	<	if test -n "$CXX"; then
2175	<	echo "$as_me:$LINENO: result: $CXX" >&5
2176	<	echo "${ECHO_T}$CXX" >&6
2173	>	CC=$ac_cv_prog_CC
2174	>	if test -n "$CC"; then
2175	>	echo "$as_me:$LINENO: result: $CC" >&5
2176	>	echo "${ECHO_T}$CC" >&6
2177		else
2178		echo "$as_me:$LINENO: result: no" >&5
2179		echo "${ECHO_T}no" >&6
2180		fi
2181
2182	<	test -n "$CXX" && break
2182	>	test -n "$CC" && break
2183		done
2184		fi
2185	<	if test -z "$CXX"; then
2186	<	ac_ct_CXX=$CXX
2187	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2185	>	if test -z "$CC"; then
2186	>	ac_ct_CC=$CC
2187	>	for ac_prog in icc pgcc pathcc cc xlc gcc
2188		do
2189		# Extract the first word of "$ac_prog", so it can be a program name with args.
2190		set dummy $ac_prog; ac_word=$2
2191		echo "$as_me:$LINENO: checking for $ac_word" >&5
2192		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2193	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2193	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2194		echo $ECHO_N "(cached) $ECHO_C" >&6
2195		else
2196	<	if test -n "$ac_ct_CXX"; then
2197	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2196	>	if test -n "$ac_ct_CC"; then
2197	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2198		else
2199		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2200		for as_dir in $PATH
#	Line 2728 | Line 2203 | do
2203		test -z "$as_dir" && as_dir=.
2204		for ac_exec_ext in '' $ac_executable_extensions; do
2205		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2206	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
2206	>	ac_cv_prog_ac_ct_CC="$ac_prog"
2207		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2208		break 2
2209		fi
#	Line 2737 | Line 2212 | fi
2212
2213		fi
2214		fi
2215	<	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216	<	if test -n "$ac_ct_CXX"; then
2217	<	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218	<	echo "${ECHO_T}$ac_ct_CXX" >&6
2215	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216	>	if test -n "$ac_ct_CC"; then
2217	>	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218	>	echo "${ECHO_T}$ac_ct_CC" >&6
2219		else
2220		echo "$as_me:$LINENO: result: no" >&5
2221		echo "${ECHO_T}no" >&6
2222		fi
2223
2224	<	test -n "$ac_ct_CXX" && break
2224	>	test -n "$ac_ct_CC" && break
2225		done
2751	–	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2226
2227	<	CXX=$ac_ct_CXX
2227	>	CC=$ac_ct_CC
2228		fi
2229
2230
2231	+	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2232	+	See \`config.log' for more details." >&5
2233	+	echo "$as_me: error: no acceptable C compiler found in \$PATH
2234	+	See \`config.log' for more details." >&2;}
2235	+	{ (exit 1); exit 1; }; }
2236	+
2237		# Provide some information about the compiler.
2238		echo "$as_me:$LINENO:" \
2239	<	"checking for C++ compiler version" >&5
2239	>	"checking for C compiler version" >&5
2240		ac_compiler=`set X $ac_compile; echo $2`
2241		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2242		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2774 | Line 2254 | ac_compiler=`set X $ac_compile; echo $2`
2254		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255		(exit $ac_status); }
2256
2257	<	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258	<	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257	>	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258	>	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260		echo $ECHO_N "(cached) $ECHO_C" >&6
2261		else
2262		cat >conftest.$ac_ext <<_ACEOF
#	Line 2806 | Line 2286 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2286		cat conftest.err >&5
2287		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2288		(exit $ac_status); } &&
2289	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2289	>	{ ac_try='test -z "$ac_c_werror_flag"
2290		|| test ! -s conftest.err'
2291		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2292		(eval $ac_try) 2>&5
#	Line 2827 | Line 2307 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2307		ac_compiler_gnu=no
2308		fi
2309		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2310	>	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311
2312		fi
2313	<	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314	<	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315	<	GXX=`test $ac_compiler_gnu = yes && echo yes`
2316	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
2317	<	ac_save_CXXFLAGS=$CXXFLAGS
2318	<	CXXFLAGS="-g"
2319	<	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320	<	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321	<	if test "${ac_cv_prog_cxx_g+set}" = set; then
2313	>	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314	>	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315	>	GCC=`test $ac_compiler_gnu = yes && echo yes`
2316	>	ac_test_CFLAGS=${CFLAGS+set}
2317	>	ac_save_CFLAGS=$CFLAGS
2318	>	CFLAGS="-g"
2319	>	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320	>	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321	>	if test "${ac_cv_prog_cc_g+set}" = set; then
2322		echo $ECHO_N "(cached) $ECHO_C" >&6
2323		else
2324		cat >conftest.$ac_ext <<_ACEOF
#	Line 2865 | Line 2345 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2345		cat conftest.err >&5
2346		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2347		(exit $ac_status); } &&
2348	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2348	>	{ ac_try='test -z "$ac_c_werror_flag"
2349		|| test ! -s conftest.err'
2350		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2351		(eval $ac_try) 2>&5
#	Line 2878 | Line 2358 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2358		ac_status=$?
2359		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2360		(exit $ac_status); }; }; then
2361	<	ac_cv_prog_cxx_g=yes
2361	>	ac_cv_prog_cc_g=yes
2362		else
2363		echo "$as_me: failed program was:" >&5
2364		sed 's/^/| /' conftest.$ac_ext >&5
2365
2366	<	ac_cv_prog_cxx_g=no
2366	>	ac_cv_prog_cc_g=no
2367		fi
2368		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2369		fi
2370	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2371	<	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2372	<	if test "$ac_test_CXXFLAGS" = set; then
2373	<	CXXFLAGS=$ac_save_CXXFLAGS
2374	<	elif test $ac_cv_prog_cxx_g = yes; then
2375	<	if test "$GXX" = yes; then
2376	<	CXXFLAGS="-g -O2"
2370	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2371	>	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2372	>	if test "$ac_test_CFLAGS" = set; then
2373	>	CFLAGS=$ac_save_CFLAGS
2374	>	elif test $ac_cv_prog_cc_g = yes; then
2375	>	if test "$GCC" = yes; then
2376	>	CFLAGS="-g -O2"
2377		else
2378	<	CXXFLAGS="-g"
2378	>	CFLAGS="-g"
2379		fi
2380		else
2381	<	if test "$GXX" = yes; then
2382	<	CXXFLAGS="-O2"
2381	>	if test "$GCC" = yes; then
2382	>	CFLAGS="-O2"
2383		else
2384	<	CXXFLAGS=
2384	>	CFLAGS=
2385		fi
2386		fi
2387	<	for ac_declaration in \
2388	<	'' \
2389	<	'extern "C" void std::exit (int) throw (); using std::exit;' \
2390	<	'extern "C" void std::exit (int); using std::exit;' \
2391	<	'extern "C" void exit (int) throw ();' \
2392	<	'extern "C" void exit (int);' \
2393	<	'void exit (int);'
2394	<	do
2915	<	cat >conftest.$ac_ext <<_ACEOF
2387	>	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2388	>	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2389	>	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2390	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2391	>	else
2392	>	ac_cv_prog_cc_stdc=no
2393	>	ac_save_CC=$CC
2394	>	cat >conftest.$ac_ext <<_ACEOF
2395		/* confdefs.h.  */
2396		_ACEOF
2397		cat confdefs.h >>conftest.$ac_ext
2398		cat >>conftest.$ac_ext <<_ACEOF
2399		/* end confdefs.h.  */
2400	+	#include <stdarg.h>
2401	+	#include <stdio.h>
2402	+	#include <sys/types.h>
2403	+	#include <sys/stat.h>
2404	+	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405	+	struct buf { int x; };
2406	+	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407	+	static char *e (p, i)
2408	+	char **p;
2409	+	int i;
2410	+	{
2411	+	return p[i];
2412	+	}
2413	+	static char *f (char * (*g) (char **, int), char **p, ...)
2414	+	{
2415	+	char *s;
2416	+	va_list v;
2417	+	va_start (v,p);
2418	+	s = g (p, va_arg (v,int));
2419	+	va_end (v);
2420	+	return s;
2421	+	}
2422	+
2423	+	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424	+	function prototypes and stuff, but not '\xHH' hex character constants.
2425	+	These don't provoke an error unfortunately, instead are silently treated
2426	+	as 'x'.  The following induces an error, until -std1 is added to get
2427	+	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428	+	array size at least.  It's necessary to write '\x00'==0 to get something
2429	+	that's true only with -std1.  */
2430	+	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431	+
2432	+	int test (int i, double x);
2433	+	struct s1 {int (*f) (int a);};
2434	+	struct s2 {int (*f) (double a);};
2435	+	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436	+	int argc;
2437	+	char **argv;
2438	+	int
2439	+	main ()
2440	+	{
2441	+	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442	+	;
2443	+	return 0;
2444	+	}
2445	+	_ACEOF
2446	+	# Don't try gcc -ansi; that turns off useful extensions and
2447	+	# breaks some systems' header files.
2448	+	# AIX                   -qlanglvl=ansi
2449	+	# Ultrix and OSF/1      -std1
2450	+	# HP-UX 10.20 and later -Ae
2451	+	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2452	+	# SVR4                  -Xc -D__EXTENSIONS__
2453	+	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454	+	do
2455	+	CC="$ac_save_CC $ac_arg"
2456	+	rm -f conftest.$ac_objext
2457	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458	+	(eval $ac_compile) 2>conftest.er1
2459	+	ac_status=$?
2460	+	grep -v '^ *+' conftest.er1 >conftest.err
2461	+	rm -f conftest.er1
2462	+	cat conftest.err >&5
2463	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464	+	(exit $ac_status); } &&
2465	+	{ ac_try='test -z "$ac_c_werror_flag"
2466	+	|| test ! -s conftest.err'
2467	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468	+	(eval $ac_try) 2>&5
2469	+	ac_status=$?
2470	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471	+	(exit $ac_status); }; } &&
2472	+	{ ac_try='test -s conftest.$ac_objext'
2473	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474	+	(eval $ac_try) 2>&5
2475	+	ac_status=$?
2476	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477	+	(exit $ac_status); }; }; then
2478	+	ac_cv_prog_cc_stdc=$ac_arg
2479	+	break
2480	+	else
2481	+	echo "$as_me: failed program was:" >&5
2482	+	sed 's/^/| /' conftest.$ac_ext >&5
2483	+
2484	+	fi
2485	+	rm -f conftest.err conftest.$ac_objext
2486	+	done
2487	+	rm -f conftest.$ac_ext conftest.$ac_objext
2488	+	CC=$ac_save_CC
2489	+
2490	+	fi
2491	+
2492	+	case "x$ac_cv_prog_cc_stdc" in
2493	+	x|xno)
2494	+	echo "$as_me:$LINENO: result: none needed" >&5
2495	+	echo "${ECHO_T}none needed" >&6 ;;
2496	+	*)
2497	+	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498	+	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499	+	CC="$CC $ac_cv_prog_cc_stdc" ;;
2500	+	esac
2501	+
2502	+	# Some people use a C++ compiler to compile C.  Since we use `exit',
2503	+	# in C++ we need to declare it.  In case someone uses the same compiler
2504	+	# for both compiling C and C++ we need to have the C++ compiler decide
2505	+	# the declaration of exit, since it's the most demanding environment.
2506	+	cat >conftest.$ac_ext <<_ACEOF
2507	+	#ifndef __cplusplus
2508	+	choke me
2509	+	#endif
2510	+	_ACEOF
2511	+	rm -f conftest.$ac_objext
2512	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513	+	(eval $ac_compile) 2>conftest.er1
2514	+	ac_status=$?
2515	+	grep -v '^ *+' conftest.er1 >conftest.err
2516	+	rm -f conftest.er1
2517	+	cat conftest.err >&5
2518	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519	+	(exit $ac_status); } &&
2520	+	{ ac_try='test -z "$ac_c_werror_flag"
2521	+	|| test ! -s conftest.err'
2522	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523	+	(eval $ac_try) 2>&5
2524	+	ac_status=$?
2525	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2526	+	(exit $ac_status); }; } &&
2527	+	{ ac_try='test -s conftest.$ac_objext'
2528	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2529	+	(eval $ac_try) 2>&5
2530	+	ac_status=$?
2531	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532	+	(exit $ac_status); }; }; then
2533	+	for ac_declaration in \
2534	+	'' \
2535	+	'extern "C" void std::exit (int) throw (); using std::exit;' \
2536	+	'extern "C" void std::exit (int); using std::exit;' \
2537	+	'extern "C" void exit (int) throw ();' \
2538	+	'extern "C" void exit (int);' \
2539	+	'void exit (int);'
2540	+	do
2541	+	cat >conftest.$ac_ext <<_ACEOF
2542	+	/* confdefs.h.  */
2543	+	_ACEOF
2544	+	cat confdefs.h >>conftest.$ac_ext
2545	+	cat >>conftest.$ac_ext <<_ACEOF
2546	+	/* end confdefs.h.  */
2547		$ac_declaration
2548		#include <stdlib.h>
2549		int
#	Line 2937 | Line 2563 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2563		cat conftest.err >&5
2564		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565		(exit $ac_status); } &&
2566	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2566	>	{ ac_try='test -z "$ac_c_werror_flag"
2567		|| test ! -s conftest.err'
2568		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2569		(eval $ac_try) 2>&5
#	Line 2982 | Line 2608 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2608		cat conftest.err >&5
2609		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610		(exit $ac_status); } &&
2611	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2611	>	{ ac_try='test -z "$ac_c_werror_flag"
2612		|| test ! -s conftest.err'
2613		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2614		(eval $ac_try) 2>&5
#	Line 3010 | Line 2636 | fi
2636		echo '#endif'             >>confdefs.h
2637		fi
2638
2639	+	else
2640	+	echo "$as_me: failed program was:" >&5
2641	+	sed 's/^/| /' conftest.$ac_ext >&5
2642	+
2643	+	fi
2644	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645		ac_ext=c
2646		ac_cpp='$CPP $CPPFLAGS'
2647		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650
2651	<
2652	<	OOPSE_TEMPLATE_FLAGS=""
2653	<	if test $ac_cv_cxx_compiler_gnu = no; then
2654	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3023	<	echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3024	<	echo 'void f(){}' > conftest.cc
3025	<	if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3026	<	echo "$as_me:$LINENO: result: yes" >&5
3027	<	echo "${ECHO_T}yes" >&6
3028	<	OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3029	<	else
3030	<	echo "$as_me:$LINENO: result: no" >&5
3031	<	echo "${ECHO_T}no" >&6
3032	<	fi
3033	<	rm -f conftest*
3034	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3035	<	echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3036	<	echo 'void f(){}' > conftest.cc
3037	<	if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3038	<	echo "$as_me:$LINENO: result: yes" >&5
3039	<	echo "${ECHO_T}yes" >&6
3040	<	OOPSE_TEMPLATE_FLAGS="-instances=static"
3041	<	else
3042	<	echo "$as_me:$LINENO: result: no" >&5
3043	<	echo "${ECHO_T}no" >&6
3044	<	fi
3045	<	rm -f conftest*
3046	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3047	<	echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3048	<	echo 'void f(){}' > conftest.cc
3049	<	if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3050	<	echo "$as_me:$LINENO: result: yes" >&5
3051	<	echo "${ECHO_T}yes" >&6
3052	<	OOPSE_TEMPLATE_FLAGS="-pto"
3053	<	else
3054	<	echo "$as_me:$LINENO: result: no" >&5
3055	<	echo "${ECHO_T}no" >&6
3056	<	fi
3057	<	rm -f conftest*
3058	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3059	<	echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3060	<	echo 'void f(){}' > conftest.cc
3061	<	if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3062	<	echo "$as_me:$LINENO: result: yes" >&5
3063	<	echo "${ECHO_T}yes" >&6
3064	<
3065	<
3066	<	EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3067	<	else
3068	<	echo "$as_me:$LINENO: result: no" >&5
3069	<	echo "${ECHO_T}no" >&6
3070	<	fi
3071	<	fi
3072	<
3073	<
3074	<
3075	<
3076	<	ac_ext=f90
3077	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3078	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3079	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2651	>	ac_ext=${FC_SRCEXT-f}
2652	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655		if test -n "$ac_tool_prefix"; then
2656	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2656	>	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657		do
2658		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660		echo "$as_me:$LINENO: checking for $ac_word" >&5
2661		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662	<	if test "${ac_cv_prog_F90+set}" = set; then
2662	>	if test "${ac_cv_prog_FC+set}" = set; then
2663		echo $ECHO_N "(cached) $ECHO_C" >&6
2664		else
2665	<	if test -n "$F90"; then
2666	<	ac_cv_prog_F90="$F90" # Let the user override the test.
2665	>	if test -n "$FC"; then
2666	>	ac_cv_prog_FC="$FC" # Let the user override the test.
2667		else
2668		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669		for as_dir in $PATH
#	Line 3097 | Line 2672 | do
2672		test -z "$as_dir" && as_dir=.
2673		for ac_exec_ext in '' $ac_executable_extensions; do
2674		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675	<	ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2675	>	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677		break 2
2678		fi
#	Line 3106 | Line 2681 | fi
2681
2682		fi
2683		fi
2684	<	F90=$ac_cv_prog_F90
2685	<	if test -n "$F90"; then
2686	<	echo "$as_me:$LINENO: result: $F90" >&5
2687	<	echo "${ECHO_T}$F90" >&6
2684	>	FC=$ac_cv_prog_FC
2685	>	if test -n "$FC"; then
2686	>	echo "$as_me:$LINENO: result: $FC" >&5
2687	>	echo "${ECHO_T}$FC" >&6
2688		else
2689		echo "$as_me:$LINENO: result: no" >&5
2690		echo "${ECHO_T}no" >&6
2691		fi
2692
2693	<	test -n "$F90" && break
2693	>	test -n "$FC" && break
2694		done
2695		fi
2696	<	if test -z "$F90"; then
2697	<	ac_ct_F90=$F90
2698	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2696	>	if test -z "$FC"; then
2697	>	ac_ct_FC=$FC
2698	>	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699		do
2700		# Extract the first word of "$ac_prog", so it can be a program name with args.
2701		set dummy $ac_prog; ac_word=$2
2702		echo "$as_me:$LINENO: checking for $ac_word" >&5
2703		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704	<	if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2704	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705		echo $ECHO_N "(cached) $ECHO_C" >&6
2706		else
2707	<	if test -n "$ac_ct_F90"; then
2708	<	ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2707	>	if test -n "$ac_ct_FC"; then
2708	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709		else
2710		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711		for as_dir in $PATH
#	Line 3139 | Line 2714 | do
2714		test -z "$as_dir" && as_dir=.
2715		for ac_exec_ext in '' $ac_executable_extensions; do
2716		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717	<	ac_cv_prog_ac_ct_F90="$ac_prog"
2717	>	ac_cv_prog_ac_ct_FC="$ac_prog"
2718		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719		break 2
2720		fi
#	Line 3148 | Line 2723 | fi
2723
2724		fi
2725		fi
2726	<	ac_ct_F90=$ac_cv_prog_ac_ct_F90
2727	<	if test -n "$ac_ct_F90"; then
2728	<	echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2729	<	echo "${ECHO_T}$ac_ct_F90" >&6
2726	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727	>	if test -n "$ac_ct_FC"; then
2728	>	echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729	>	echo "${ECHO_T}$ac_ct_FC" >&6
2730		else
2731		echo "$as_me:$LINENO: result: no" >&5
2732		echo "${ECHO_T}no" >&6
2733		fi
2734
2735	<	test -n "$ac_ct_F90" && break
2735	>	test -n "$ac_ct_FC" && break
2736		done
2737
2738	<	F90=$ac_ct_F90
2738	>	FC=$ac_ct_FC
2739		fi
2740
2741
2742	<	# If we don't use `.F90' as extension, the preprocessor is not run on the
2743	<	# input file.
2742	>	# Provide some information about the compiler.
2743	>	echo "$as_me:2743:" \
2744	>	"checking for Fortran compiler version" >&5
2745	>	ac_compiler=`set X $ac_compile; echo $2`
2746	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747	>	(eval $ac_compiler --version </dev/null >&5) 2>&5
2748	>	ac_status=$?
2749	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750	>	(exit $ac_status); }
2751	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752	>	(eval $ac_compiler -v </dev/null >&5) 2>&5
2753	>	ac_status=$?
2754	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755	>	(exit $ac_status); }
2756	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757	>	(eval $ac_compiler -V </dev/null >&5) 2>&5
2758	>	ac_status=$?
2759	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760	>	(exit $ac_status); }
2761	>	rm -f a.out
2762	>
2763	>	# If we don't use `.F' as extension, the preprocessor is not run on the
2764	>	# input file.  (Note that this only needs to work for GNU compilers.)
2765		ac_save_ext=$ac_ext
2766	<	ac_ext=F90
2767	<	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2768	<	echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2769	<	if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2766	>	ac_ext=F
2767	>	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768	>	echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770		echo $ECHO_N "(cached) $ECHO_C" >&6
2771		else
2772		cat >conftest.$ac_ext <<_ACEOF
2773	<
3178	<	program main
3179	<
2773	>	program main
2774		#ifndef __GNUC__
2775		choke me
2776		#endif
2777
2778	<	end program main
3185	<
2778	>	end
2779		_ACEOF
2780		rm -f conftest.$ac_objext
2781		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3193 | Line 2786 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2786		cat conftest.err >&5
2787		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788		(exit $ac_status); } &&
2789	<	{ ac_try='test -z "$ac_f90_werror_flag"
2789	>	{ ac_try='test -z "$ac_fc_werror_flag"
2790		|| test ! -s conftest.err'
2791		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792		(eval $ac_try) 2>&5
#	Line 3214 | Line 2807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2807		ac_compiler_gnu=no
2808		fi
2809		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810	<	ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2810	>	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811
2812		fi
2813	<	echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2814	<	echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2813	>	echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814	>	echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815		ac_ext=$ac_save_ext
2816	<	G95=`test $ac_compiler_gnu = yes && echo yes`
2817	<	ac_ext=c
2818	<	ac_cpp='$CPP $CPPFLAGS'
2819	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2820	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2821	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2816	>	ac_test_FFLAGS=${FCFLAGS+set}
2817	>	ac_save_FFLAGS=$FCFLAGS
2818	>	FCFLAGS=
2819	>	echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820	>	echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821	>	if test "${ac_cv_prog_fc_g+set}" = set; then
2822	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2823	>	else
2824	>	FCFLAGS=-g
2825	>	cat >conftest.$ac_ext <<_ACEOF
2826	>	program main
2827
2828	<
3231	<
3232	<
3233	<
3234	<	# Try to determine native compiler flags that allow us to use F90 suffix
3235	<	# for preprocessed f90 source.
3236	<
3237	<	if test "$ac_test_PREPFLAG" != "set"; then
3238	<	PREPFLAG=""
3239	<	case "${host_cpu}-${host_os}" in
3240	<
3241	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3242	<	PREPFLAG="-fpp1 "
3243	<	fi;;
3244	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3245	<	PREPFLAG="-qsuffix=cpp=F90 "
3246	<	fi;;
3247	<	*darwin*)
3248	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3249	<	PREPFLAG="-qsuffix=cpp=F90 "
3250	<	fi;;
3251	<	esac
3252	<
3253	<	if test -z "$PREPFLAG"; then
3254	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3255	<	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3256	<	PREPFLAG=""
3257	<	fi
3258	<
3259	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3260	<	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3261	<
3262	<
3263	<	ac_ext=f90
3264	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3265	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3266	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3267	<
3268	<	ac_save_ext=$ac_ext
3269	<	ac_ext=F90
3270	<	ac_save_F90FLAGS=$F90FLAGS
3271	<
3272	<	if test "$PREPFLAG"; then
3273	<	F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3274	<	fi
3275	<
3276	<	cat >conftest.$ac_ext <<_ACEOF
3277	<
3278	<
3279	<	program main
3280	<
3281	<	integer :: i
3282	<	i = 1
3283	<
3284	<
3285	<	end program main
3286	<
2828	>	end
2829		_ACEOF
2830		rm -f conftest.$ac_objext
2831		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3294 | Line 2836 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2836		cat conftest.err >&5
2837		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838		(exit $ac_status); } &&
2839	<	{ ac_try='test -z "$ac_f90_werror_flag"
2839	>	{ ac_try='test -z "$ac_fc_werror_flag"
2840		|| test ! -s conftest.err'
2841		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842		(eval $ac_try) 2>&5
#	Line 3307 | Line 2849 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2849		ac_status=$?
2850		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851		(exit $ac_status); }; }; then
2852	<	prepflagworks=1
2852	>	ac_cv_prog_fc_g=yes
2853		else
2854		echo "$as_me: failed program was:" >&5
2855		sed 's/^/| /' conftest.$ac_ext >&5
2856
2857	<	prepflagworks=0
2857	>	ac_cv_prog_fc_g=no
2858		fi
2859		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860
2861	<	F90FLAGS=$ac_save_F90FLAGS
2862	<	ac_ext=$ac_save_ext
2863	<	ac_ext=c
2861	>	fi
2862	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863	>	echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864	>	if test "$ac_test_FFLAGS" = set; then
2865	>	FCFLAGS=$ac_save_FFLAGS
2866	>	elif test $ac_cv_prog_fc_g = yes; then
2867	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868	>	FCFLAGS="-g -O2"
2869	>	else
2870	>	FCFLAGS="-g"
2871	>	fi
2872	>	else
2873	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874	>	FCFLAGS="-O2"
2875	>	else
2876	>	FCFLAGS=
2877	>	fi
2878	>	fi
2879	>
2880	>	ac_ext=c
2881		ac_cpp='$CPP $CPPFLAGS'
2882		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885
2886	+	ac_ext=c
2887	+	ac_cpp='$CPP $CPPFLAGS'
2888	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891	+	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892	+	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893	+	# On Suns, sometimes $CPP names a directory.
2894	+	if test -n "$CPP" && test -d "$CPP"; then
2895	+	CPP=
2896	+	fi
2897	+	if test -z "$CPP"; then
2898	+	if test "${ac_cv_prog_CPP+set}" = set; then
2899	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2900	+	else
2901	+	# Double quotes because CPP needs to be expanded
2902	+	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2903	+	do
2904	+	ac_preproc_ok=false
2905	+	for ac_c_preproc_warn_flag in '' yes
2906	+	do
2907	+	# Use a header file that comes with gcc, so configuring glibc
2908	+	# with a fresh cross-compiler works.
2909	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2910	+	# <limits.h> exists even on freestanding compilers.
2911	+	# On the NeXT, cc -E runs the code through the compiler's parser,
2912	+	# not just through cpp. "Syntax error" is here to catch this case.
2913	+	cat >conftest.$ac_ext <<_ACEOF
2914	+	/* confdefs.h.  */
2915	+	_ACEOF
2916	+	cat confdefs.h >>conftest.$ac_ext
2917	+	cat >>conftest.$ac_ext <<_ACEOF
2918	+	/* end confdefs.h.  */
2919	+	#ifdef __STDC__
2920	+	# include <limits.h>
2921	+	#else
2922	+	# include <assert.h>
2923	+	#endif
2924	+	Syntax error
2925	+	_ACEOF
2926	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2927	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2928	+	ac_status=$?
2929	+	grep -v '^ *+' conftest.er1 >conftest.err
2930	+	rm -f conftest.er1
2931	+	cat conftest.err >&5
2932	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933	+	(exit $ac_status); } >/dev/null; then
2934	+	if test -s conftest.err; then
2935	+	ac_cpp_err=$ac_c_preproc_warn_flag
2936	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2937	+	else
2938	+	ac_cpp_err=
2939	+	fi
2940	+	else
2941	+	ac_cpp_err=yes
2942	+	fi
2943	+	if test -z "$ac_cpp_err"; then
2944	+	:
2945	+	else
2946	+	echo "$as_me: failed program was:" >&5
2947	+	sed 's/^/| /' conftest.$ac_ext >&5
2948
2949	<	if test "$prepflagworks" = 1; then
2950	<	echo "$as_me:$LINENO: result: yes" >&5
2951	<	echo "${ECHO_T}yes" >&6
2949	>	# Broken: fails on valid input.
2950	>	continue
2951	>	fi
2952	>	rm -f conftest.err conftest.$ac_ext
2953
2954	+	# OK, works on sane cases.  Now check whether non-existent headers
2955	+	# can be detected and how.
2956	+	cat >conftest.$ac_ext <<_ACEOF
2957	+	/* confdefs.h.  */
2958	+	_ACEOF
2959	+	cat confdefs.h >>conftest.$ac_ext
2960	+	cat >>conftest.$ac_ext <<_ACEOF
2961	+	/* end confdefs.h.  */
2962	+	#include <ac_nonexistent.h>
2963	+	_ACEOF
2964	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2965	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2966	+	ac_status=$?
2967	+	grep -v '^ *+' conftest.er1 >conftest.err
2968	+	rm -f conftest.er1
2969	+	cat conftest.err >&5
2970	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2971	+	(exit $ac_status); } >/dev/null; then
2972	+	if test -s conftest.err; then
2973	+	ac_cpp_err=$ac_c_preproc_warn_flag
2974	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2975		else
2976	<	echo "$as_me:$LINENO: result: no" >&5
3334	<	echo "${ECHO_T}no" >&6
3335	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3336	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3337	<	{ (exit 1); exit 1; }; }
2976	>	ac_cpp_err=
2977		fi
2978	+	else
2979	+	ac_cpp_err=yes
2980		fi
2981	+	if test -z "$ac_cpp_err"; then
2982	+	# Broken: success on invalid input.
2983	+	continue
2984	+	else
2985	+	echo "$as_me: failed program was:" >&5
2986	+	sed 's/^/| /' conftest.$ac_ext >&5
2987
2988	+	# Passes both tests.
2989	+	ac_preproc_ok=:
2990	+	break
2991	+	fi
2992	+	rm -f conftest.err conftest.$ac_ext
2993
2994	+	done
2995	+	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2996	+	rm -f conftest.err conftest.$ac_ext
2997	+	if $ac_preproc_ok; then
2998	+	break
2999	+	fi
3000
3001	+	done
3002	+	ac_cv_prog_CPP=$CPP
3003
3344	–
3345	–	# Try to determine native compiler flags that allow us to use F90 suffix
3346	–	# for preprocessed f90 source with -D type defines
3347	–
3348	–	if test "$ac_test_PREPDEFFLAG" != "set"; then
3349	–	PREPDEFFLAG=""
3350	–	case "${host_cpu}-${host_os}" in
3351	–
3352	–	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3353	–	PREPDEFFLAG=" "
3354	–	fi;;
3355	–	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3356	–	PREPDEFFLAG="-WF,"
3357	–	fi;;
3358	–	*darwin*)
3359	–	if test "$F90" = f90 -o "$F90" = xlf90; then
3360	–	PREPDEFFLAG="-WF,"
3361	–	fi;;
3362	–	esac
3363	–
3364	–	if test -z "$PREPDEFFLAG"; then
3365	–	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3366	–	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3367	–	PREPDEFFLAG=" "
3368	–	fi
3369	–
3370	–	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3371	–	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3372	–
3373	–
3374	–	ac_ext=f90
3375	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3376	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3377	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3378	–
3379	–	ac_save_ext=$ac_ext
3380	–	ac_ext=F90
3381	–	ac_save_F90FLAGS=$F90FLAGS
3382	–
3383	–	if test "$PREPDEFFLAG"; then
3384	–	F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3004		fi
3005	<
3006	<	cat >conftest.$ac_ext <<_ACEOF
3007	<
3008	<
3009	<	program main
3010	<
3011	<	integer :: i
3012	<	#ifdef TEST
3013	<	i = 1
3005	>	CPP=$ac_cv_prog_CPP
3006	>	else
3007	>	ac_cv_prog_CPP=$CPP
3008	>	fi
3009	>	echo "$as_me:$LINENO: result: $CPP" >&5
3010	>	echo "${ECHO_T}$CPP" >&6
3011	>	ac_preproc_ok=false
3012	>	for ac_c_preproc_warn_flag in '' yes
3013	>	do
3014	>	# Use a header file that comes with gcc, so configuring glibc
3015	>	# with a fresh cross-compiler works.
3016	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3017	>	# <limits.h> exists even on freestanding compilers.
3018	>	# On the NeXT, cc -E runs the code through the compiler's parser,
3019	>	# not just through cpp. "Syntax error" is here to catch this case.
3020	>	cat >conftest.$ac_ext <<_ACEOF
3021	>	/* confdefs.h.  */
3022	>	_ACEOF
3023	>	cat confdefs.h >>conftest.$ac_ext
3024	>	cat >>conftest.$ac_ext <<_ACEOF
3025	>	/* end confdefs.h.  */
3026	>	#ifdef __STDC__
3027	>	# include <limits.h>
3028		#else
3029	<	choke me
3029	>	# include <assert.h>
3030		#endif
3031	+	Syntax error
3032	+	_ACEOF
3033	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3034	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3035	+	ac_status=$?
3036	+	grep -v '^ *+' conftest.er1 >conftest.err
3037	+	rm -f conftest.er1
3038	+	cat conftest.err >&5
3039	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3040	+	(exit $ac_status); } >/dev/null; then
3041	+	if test -s conftest.err; then
3042	+	ac_cpp_err=$ac_c_preproc_warn_flag
3043	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3044	+	else
3045	+	ac_cpp_err=
3046	+	fi
3047	+	else
3048	+	ac_cpp_err=yes
3049	+	fi
3050	+	if test -z "$ac_cpp_err"; then
3051	+	:
3052	+	else
3053	+	echo "$as_me: failed program was:" >&5
3054	+	sed 's/^/| /' conftest.$ac_ext >&5
3055
3056	+	# Broken: fails on valid input.
3057	+	continue
3058	+	fi
3059	+	rm -f conftest.err conftest.$ac_ext
3060
3061	<	end program main
3062	<
3061	>	# OK, works on sane cases.  Now check whether non-existent headers
3062	>	# can be detected and how.
3063	>	cat >conftest.$ac_ext <<_ACEOF
3064	>	/* confdefs.h.  */
3065		_ACEOF
3066	<	rm -f conftest.$ac_objext
3067	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3068	<	(eval $ac_compile) 2>conftest.er1
3066	>	cat confdefs.h >>conftest.$ac_ext
3067	>	cat >>conftest.$ac_ext <<_ACEOF
3068	>	/* end confdefs.h.  */
3069	>	#include <ac_nonexistent.h>
3070	>	_ACEOF
3071	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3072	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3073		ac_status=$?
3074		grep -v '^ *+' conftest.er1 >conftest.err
3075		rm -f conftest.er1
3076		cat conftest.err >&5
3077		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3078	<	(exit $ac_status); } &&
3079	<	{ ac_try='test -z "$ac_f90_werror_flag"
3080	<	|| test ! -s conftest.err'
3081	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3082	<	(eval $ac_try) 2>&5
3083	<	ac_status=$?
3084	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3418	<	(exit $ac_status); }; } &&
3419	<	{ ac_try='test -s conftest.$ac_objext'
3420	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3421	<	(eval $ac_try) 2>&5
3422	<	ac_status=$?
3423	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3424	<	(exit $ac_status); }; }; then
3425	<	prepdefflagworks=1
3078	>	(exit $ac_status); } >/dev/null; then
3079	>	if test -s conftest.err; then
3080	>	ac_cpp_err=$ac_c_preproc_warn_flag
3081	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3082	>	else
3083	>	ac_cpp_err=
3084	>	fi
3085		else
3086	+	ac_cpp_err=yes
3087	+	fi
3088	+	if test -z "$ac_cpp_err"; then
3089	+	# Broken: success on invalid input.
3090	+	continue
3091	+	else
3092		echo "$as_me: failed program was:" >&5
3093		sed 's/^/| /' conftest.$ac_ext >&5
3094
3095	<	prepdefflagworks=0
3095	>	# Passes both tests.
3096	>	ac_preproc_ok=:
3097	>	break
3098		fi
3099	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3099	>	rm -f conftest.err conftest.$ac_ext
3100
3101	<	F90FLAGS=$ac_save_F90FLAGS
3102	<	ac_ext=$ac_save_ext
3103	<	ac_ext=c
3101	>	done
3102	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3103	>	rm -f conftest.err conftest.$ac_ext
3104	>	if $ac_preproc_ok; then
3105	>	:
3106	>	else
3107	>	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3108	>	See \`config.log' for more details." >&5
3109	>	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3110	>	See \`config.log' for more details." >&2;}
3111	>	{ (exit 1); exit 1; }; }
3112	>	fi
3113	>
3114	>	ac_ext=c
3115		ac_cpp='$CPP $CPPFLAGS'
3116		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3117		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119
3120	+	echo "$as_me:$LINENO: checking for egrep" >&5
3121	+	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122	+	if test "${ac_cv_prog_egrep+set}" = set; then
3123	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3124	+	else
3125	+	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3126	+	then ac_cv_prog_egrep='grep -E'
3127	+	else ac_cv_prog_egrep='egrep'
3128	+	fi
3129	+	fi
3130	+	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3131	+	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132	+	EGREP=$ac_cv_prog_egrep
3133
3134
3135	<	if test "$prepdefflagworks" = 1; then
3136	<	echo "$as_me:$LINENO: result: yes" >&5
3135	>	echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136	>	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137	>	LN_S=$as_ln_s
3138	>	if test "$LN_S" = "ln -s"; then
3139	>	echo "$as_me:$LINENO: result: yes" >&5
3140		echo "${ECHO_T}yes" >&6
3141	+	else
3142	+	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143	+	echo "${ECHO_T}no, using $LN_S" >&6
3144	+	fi
3145
3146	<	else
3147	<	echo "$as_me:$LINENO: result: no" >&5
3146	>	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147	>	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148	>	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149	>	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3151	>	else
3152	>	cat >conftest.make <<\_ACEOF
3153	>	all:
3154	>	@echo 'ac_maketemp="$(MAKE)"'
3155	>	_ACEOF
3156	>	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157	>	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158	>	if test -n "$ac_maketemp"; then
3159	>	eval ac_cv_prog_make_${ac_make}_set=yes
3160	>	else
3161	>	eval ac_cv_prog_make_${ac_make}_set=no
3162	>	fi
3163	>	rm -f conftest.make
3164	>	fi
3165	>	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166	>	echo "$as_me:$LINENO: result: yes" >&5
3167	>	echo "${ECHO_T}yes" >&6
3168	>	SET_MAKE=
3169	>	else
3170	>	echo "$as_me:$LINENO: result: no" >&5
3171		echo "${ECHO_T}no" >&6
3172	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3452	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3453	<	{ (exit 1); exit 1; }; }
3454	<	fi
3172	>	SET_MAKE="MAKE=${MAKE-make}"
3173		fi
3174
3175	<	ac_ext=f90
3176	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3177	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3178	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3179	<
3180	<
3181	<
3182	<	ac_ext=f90
3183	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3184	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3185	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3186	<	echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3187	<	echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3188	<	if test "${ac_cv_prog_f90_v+set}" = set; then
3189	<	echo $ECHO_N "(cached) $ECHO_C" >&6
3175	>	if test -n "$ac_tool_prefix"; then
3176	>	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3177	>	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3178	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3179	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180	>	if test "${ac_cv_prog_RANLIB+set}" = set; then
3181	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3182	>	else
3183	>	if test -n "$RANLIB"; then
3184	>	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3185	>	else
3186	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187	>	for as_dir in $PATH
3188	>	do
3189	>	IFS=$as_save_IFS
3190	>	test -z "$as_dir" && as_dir=.
3191	>	for ac_exec_ext in '' $ac_executable_extensions; do
3192	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193	>	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3194	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195	>	break 2
3196	>	fi
3197	>	done
3198	>	done
3199	>
3200	>	fi
3201	>	fi
3202	>	RANLIB=$ac_cv_prog_RANLIB
3203	>	if test -n "$RANLIB"; then
3204	>	echo "$as_me:$LINENO: result: $RANLIB" >&5
3205	>	echo "${ECHO_T}$RANLIB" >&6
3206		else
3207	<
3208	<	cat >conftest.$ac_ext <<_ACEOF
3475	<
3476	<	program main
3477	<
3478	<
3479	<	end program main
3480	<
3481	<	_ACEOF
3482	<	rm -f conftest.$ac_objext
3483	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3484	<	(eval $ac_compile) 2>conftest.er1
3485	<	ac_status=$?
3486	<	grep -v '^ *+' conftest.er1 >conftest.err
3487	<	rm -f conftest.er1
3488	<	cat conftest.err >&5
3489	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3490	<	(exit $ac_status); } &&
3491	<	{ ac_try='test -z "$ac_f90_werror_flag"
3492	<	|| test ! -s conftest.err'
3493	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3494	<	(eval $ac_try) 2>&5
3495	<	ac_status=$?
3496	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3497	<	(exit $ac_status); }; } &&
3498	<	{ ac_try='test -s conftest.$ac_objext'
3499	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3500	<	(eval $ac_try) 2>&5
3501	<	ac_status=$?
3502	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3503	<	(exit $ac_status); }; }; then
3504	<	ac_cv_prog_f90_v=
3505	<	# Try some options frequently used verbose output
3506	<	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3507	<	ac_ext=f90
3508	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3509	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3510	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3511	<
3512	<	cat >conftest.$ac_ext <<_ACEOF
3513	<
3514	<	program main
3515	<
3516	<
3517	<	end program main
3518	<
3519	<	_ACEOF
3520	<
3521	<	# Compile and link our simple test program by passing a flag (argument
3522	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3523	<	# "verbose" output that we can then parse for the Fortran 90 linker
3524	<	# flags.
3525	<	ac_save_F90FLAGS=$F90FLAGS
3526	<	F90FLAGS="$F90FLAGS $ac_verb"
3527	<
3528	<	(eval echo $as_me:3528: \"$ac_link\") >&5
3529	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3530	<	echo "$ac_f90_v_output" >&5
3531	<	F90FLAGS=$ac_save_F90FLAGS
3532	<
3533	<	rm -f conftest.*
3534	<	ac_ext=f90
3535	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3536	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3537	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3538	<
3539	<	# If we are using xlf then replace all the commas with spaces.
3540	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3541	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3207	>	echo "$as_me:$LINENO: result: no" >&5
3208	>	echo "${ECHO_T}no" >&6
3209		fi
3210
3544	–	# If we are using Cray Fortran then delete quotes.
3545	–	# Use "\"" instead of '"' for font-lock-mode.
3546	–	# FIXME: a more general fix for quoted arguments with spaces?
3547	–	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3548	–	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3211		fi
3212	<	# look for -l* and *.a constructs in the output
3213	<	for ac_arg in $ac_f90_v_output; do
3214	<	case $ac_arg in
3215	<	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3216	<	ac_cv_prog_f90_v=$ac_verb
3217	<	break 2 ;;
3218	<	esac
3219	<	done
3212	>	if test -z "$ac_cv_prog_RANLIB"; then
3213	>	ac_ct_RANLIB=$RANLIB
3214	>	# Extract the first word of "ranlib", so it can be a program name with args.
3215	>	set dummy ranlib; ac_word=$2
3216	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3217	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218	>	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3219	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3220	>	else
3221	>	if test -n "$ac_ct_RANLIB"; then
3222	>	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223	>	else
3224	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225	>	for as_dir in $PATH
3226	>	do
3227	>	IFS=$as_save_IFS
3228	>	test -z "$as_dir" && as_dir=.
3229	>	for ac_exec_ext in '' $ac_executable_extensions; do
3230	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231	>	ac_cv_prog_ac_ct_RANLIB="ranlib"
3232	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233	>	break 2
3234	>	fi
3235		done
3236	<	if test -z "$ac_cv_prog_f90_v"; then
3237	<	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3238	<	echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3236	>	done
3237	>
3238	>	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3239		fi
3240	+	fi
3241	+	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3242	+	if test -n "$ac_ct_RANLIB"; then
3243	+	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3244	+	echo "${ECHO_T}$ac_ct_RANLIB" >&6
3245		else
3246	<	echo "$as_me: failed program was:" >&5
3247	<	sed 's/^/| /' conftest.$ac_ext >&5
3566	<
3567	<	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3568	<	echo "$as_me: WARNING: compilation failed" >&2;}
3246	>	echo "$as_me:$LINENO: result: no" >&5
3247	>	echo "${ECHO_T}no" >&6
3248		fi
3570	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3249
3250	+	RANLIB=$ac_ct_RANLIB
3251	+	else
3252	+	RANLIB="$ac_cv_prog_RANLIB"
3253		fi
3254	<	echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3255	<	echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3256	<	echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3257	<	echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3258	<	if test "${ac_cv_flibs+set}" = set; then
3254	>
3255	>
3256	>	# Extract the first word of "perl", so it can be a program name with args.
3257	>	set dummy perl; ac_word=$2
3258	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3259	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3260	>	if test "${ac_cv_path_PERLINTERP+set}" = set; then
3261		echo $ECHO_N "(cached) $ECHO_C" >&6
3262		else
3263	<	if test "x$F90LIBS" != "x"; then
3264	<	ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3265	<	else
3263	>	case $PERLINTERP in
3264	>	[\\/]* | ?:[\\/]*)
3265	>	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3266	>	;;
3267	>	*)
3268	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3269	>	for as_dir in $PATH
3270	>	do
3271	>	IFS=$as_save_IFS
3272	>	test -z "$as_dir" && as_dir=.
3273	>	for ac_exec_ext in '' $ac_executable_extensions; do
3274	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3275	>	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3276	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3277	>	break 2
3278	>	fi
3279	>	done
3280	>	done
3281
3282	<	ac_ext=f90
3283	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3284	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3587	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3588	<
3589	<	cat >conftest.$ac_ext <<_ACEOF
3590	<
3591	<	program main
3592	<
3593	<
3594	<	end program main
3595	<
3596	<	_ACEOF
3597	<
3598	<	# Compile and link our simple test program by passing a flag (argument
3599	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3600	<	# "verbose" output that we can then parse for the Fortran 90 linker
3601	<	# flags.
3602	<	ac_save_F90FLAGS=$F90FLAGS
3603	<	F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3604	<
3605	<	(eval echo $as_me:3605: \"$ac_link\") >&5
3606	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3607	<	echo "$ac_f90_v_output" >&5
3608	<	F90FLAGS=$ac_save_F90FLAGS
3609	<
3610	<	rm -f conftest.*
3611	<	ac_ext=f90
3612	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3613	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3614	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3615	<
3616	<	# If we are using xlf then replace all the commas with spaces.
3617	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3618	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3282	>	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283	>	;;
3284	>	esac
3285		fi
3286	+	PERLINTERP=$ac_cv_path_PERLINTERP
3287
3288	<	# If we are using Cray Fortran then delete quotes.
3289	<	# Use "\"" instead of '"' for font-lock-mode.
3290	<	# FIXME: a more general fix for quoted arguments with spaces?
3291	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3292	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3288	>	if test -n "$PERLINTERP"; then
3289	>	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290	>	echo "${ECHO_T}$PERLINTERP" >&6
3291	>	else
3292	>	echo "$as_me:$LINENO: result: no" >&5
3293	>	echo "${ECHO_T}no" >&6
3294		fi
3295
3296	<	ac_cv_f90libs=
3296	>	ac_cv_path_perlinterp="$PERLINTERP"
3297	>	_sHpB='#!'
3298
3630	–	# Save positional arguments (if any)
3631	–	ac_save_positional="$@"
3299
3300	<	set X $ac_f90_v_output
3301	<	while test $# != 1; do
3302	<	shift
3303	<	ac_arg=$1
3304	<	case $ac_arg in
3305	<	[\\/]*.a | ?:[\\/]*.a)
3306	<	ac_exists=false
3307	<	for ac_i in $ac_cv_f90libs; do
3308	<	if test x"$ac_arg" = x"$ac_i"; then
3300	>	# Check whether --with-perl-shebang or --without-perl-shebang was given.
3301	>	if test "${with_perl_shebang+set}" = set; then
3302	>	withval="$with_perl_shebang"
3303	>	opt_perl_shebang="$withval"
3304	>	else
3305	>	opt_perl_shebang="not_set"
3306	>	fi;
3307	>	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308	>	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309	>	if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3311	>	else
3312	>	case "$opt_perl_shebang" in
3313	>	not_set  ) ax_cv_opt_perl_shebang=''
3314	>	;;
3315	>	*     )
3316	>	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317	>	esac
3318	>
3319	>	fi
3320	>	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321	>	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322	>	if test "A$ax_cv_opt_perl_shebang" != "A"
3323	>	then
3324	>	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326	>	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327	>	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328	>
3329	>	# Automatic detection of sharpbang formula starts here
3330	>	else
3331	>	_somian_shbangperl=`$PERLINTERP -V:startperl`
3332	>	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333	>	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334	>	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335	>	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3337	>	else
3338	>	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339	>	if test "x$_somian_kspb_perl" == x
3340	>	then _somian_ksbp_warn_empty='durnit'
3341	>	else
3342	>	case "A$_somian_kspb_perl" in
3343	>	A#!*perl* )
3344	>	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345	>	;;
3346	>	A*    )  _somian_ksbp_warn_defau='trouble'
3347	>	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348	>	esac
3349	>	fi
3350	>
3351	>	fi
3352	>	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353	>	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354	>	# The above prints Checking ... result message to user.
3355	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356	>
3357	>	if test A${_somian_ksbp_warn_empty+set} == Aset
3358	>	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359	>	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360	>	fi
3361	>	# Inform user after printing result value
3362	>	if test A${_somian_ksbp_warn_defau+set} == Aset
3363	>	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364	>	echo "$as_me: Maybe Not good -" >&6;}
3365	>	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366	>	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367	>	else { echo "$as_me:$LINENO: OK Good result - " >&5
3368	>	echo "$as_me: OK Good result - " >&6;}
3369	>	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370	>	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371	>	fi
3372	>	fi
3373	>
3374	>	# Find a good install program.  We prefer a C program (faster),
3375	>	# so one script is as good as another.  But avoid the broken or
3376	>	# incompatible versions:
3377	>	# SysV /etc/install, /usr/sbin/install
3378	>	# SunOS /usr/etc/install
3379	>	# IRIX /sbin/install
3380	>	# AIX /bin/install
3381	>	# AmigaOS /C/install, which installs bootblocks on floppy discs
3382	>	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383	>	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384	>	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385	>	# OS/2's system install, which has a completely different semantic
3386	>	# ./install, which can be erroneously created by make from ./install.sh.
3387	>	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388	>	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389	>	if test -z "$INSTALL"; then
3390	>	if test "${ac_cv_path_install+set}" = set; then
3391	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3392	>	else
3393	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394	>	for as_dir in $PATH
3395	>	do
3396	>	IFS=$as_save_IFS
3397	>	test -z "$as_dir" && as_dir=.
3398	>	# Account for people who put trailing slashes in PATH elements.
3399	>	case $as_dir/ in
3400	>	./ | .// | /cC/* | \
3401	>	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402	>	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403	>	/usr/ucb/* ) ;;
3404	>	*)
3405	>	# OSF1 and SCO ODT 3.0 have their own names for install.
3406	>	# Don't use installbsd from OSF since it installs stuff as root
3407	>	# by default.
3408	>	for ac_prog in ginstall scoinst install; do
3409	>	for ac_exec_ext in '' $ac_executable_extensions; do
3410	>	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411	>	if test $ac_prog = install &&
3412	>	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413	>	# AIX install.  It has an incompatible calling convention.
3414	>	:
3415	>	elif test $ac_prog = install &&
3416	>	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417	>	# program-specific install script used by HP pwplus--don't use.
3418	>	:
3419	>	else
3420	>	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421	>	break 3
3422	>	fi
3423	>	fi
3424	>	done
3425	>	done
3426	>	;;
3427	>	esac
3428	>	done
3429	>
3430	>
3431	>	fi
3432	>	if test "${ac_cv_path_install+set}" = set; then
3433	>	INSTALL=$ac_cv_path_install
3434	>	else
3435	>	# As a last resort, use the slow shell script.  We don't cache a
3436	>	# path for INSTALL within a source directory, because that will
3437	>	# break other packages using the cache if that directory is
3438	>	# removed, or if the path is relative.
3439	>	INSTALL=$ac_install_sh
3440	>	fi
3441	>	fi
3442	>	echo "$as_me:$LINENO: result: $INSTALL" >&5
3443	>	echo "${ECHO_T}$INSTALL" >&6
3444	>
3445	>	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446	>	# It thinks the first close brace ends the variable substitution.
3447	>	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448	>
3449	>	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450	>
3451	>	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452	>
3453	>	case "x$INSTALL" in
3454	>	x/*) ;;
3455	>	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456	>	esac
3457	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458	>	# Extract the first word of "ar", so it can be a program name with args.
3459	>	set dummy ar; ac_word=$2
3460	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3461	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462	>	if test "${ac_cv_prog_AR+set}" = set; then
3463	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3464	>	else
3465	>	if test -n "$AR"; then
3466	>	ac_cv_prog_AR="$AR" # Let the user override the test.
3467	>	else
3468	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469	>	for as_dir in $PATH
3470	>	do
3471	>	IFS=$as_save_IFS
3472	>	test -z "$as_dir" && as_dir=.
3473	>	for ac_exec_ext in '' $ac_executable_extensions; do
3474	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475	>	ac_cv_prog_AR="ar"
3476	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477	>	break 2
3478	>	fi
3479	>	done
3480	>	done
3481	>
3482	>	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483	>	fi
3484	>	fi
3485	>	AR=$ac_cv_prog_AR
3486	>	if test -n "$AR"; then
3487	>	echo "$as_me:$LINENO: result: $AR" >&5
3488	>	echo "${ECHO_T}$AR" >&6
3489	>	else
3490	>	echo "$as_me:$LINENO: result: no" >&5
3491	>	echo "${ECHO_T}no" >&6
3492	>	fi
3493	>
3494	>	if test "$AR" = "NONE"; then
3495	>	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496	>	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497	>	{ (exit 1); exit 1; }; }
3498	>	cat >confcache <<\_ACEOF
3499	>	# This file is a shell script that caches the results of configure
3500	>	# tests run on this system so they can be shared between configure
3501	>	# scripts and configure runs, see configure's option --config-cache.
3502	>	# It is not useful on other systems.  If it contains results you don't
3503	>	# want to keep, you may remove or edit it.
3504	>	#
3505	>	# config.status only pays attention to the cache file if you give it
3506	>	# the --recheck option to rerun configure.
3507	>	#
3508	>	# `ac_cv_env_foo' variables (set or unset) will be overridden when
3509	>	# loading this file, other *unset* `ac_cv_foo' will be assigned the
3510	>	# following values.
3511	>
3512	>	_ACEOF
3513	>
3514	>	# The following way of writing the cache mishandles newlines in values,
3515	>	# but we know of no workaround that is simple, portable, and efficient.
3516	>	# So, don't put newlines in cache variables' values.
3517	>	# Ultrix sh set writes to stderr and can't be redirected directly,
3518	>	# and sets the high bit in the cache file unless we assign to the vars.
3519	>	{
3520	>	(set) 2>&1 |
3521	>	case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522	>	*ac_space=\ *)
3523	>	# `set' does not quote correctly, so add quotes (double-quote
3524	>	# substitution turns \\\\ into \\, and sed turns \\ into \).
3525	>	sed -n \
3526	>	"s/'/'\\\\''/g;
3527	>	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528	>	;;
3529	>	*)
3530	>	# `set' quotes correctly as required by POSIX, so do not add quotes.
3531	>	sed -n \
3532	>	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533	>	;;
3534	>	esac;
3535	>	} |
3536	>	sed '
3537	>	t clear
3538	>	: clear
3539	>	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540	>	t end
3541	>	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542	>	: end' >>confcache
3543	>	if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544	>	if test -w $cache_file; then
3545	>	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546	>	cat confcache >$cache_file
3547	>	else
3548	>	echo "not updating unwritable cache $cache_file"
3549	>	fi
3550	>	fi
3551	>	rm -f confcache
3552	>	exit 1
3553	>	fi
3554	>	# Extract the first word of "ps", so it can be a program name with args.
3555	>	set dummy ps; ac_word=$2
3556	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3557	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558	>	if test "${ac_cv_path_PS+set}" = set; then
3559	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3560	>	else
3561	>	case $PS in
3562	>	[\\/]* | ?:[\\/]*)
3563	>	ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564	>	;;
3565	>	*)
3566	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567	>	for as_dir in $PATH
3568	>	do
3569	>	IFS=$as_save_IFS
3570	>	test -z "$as_dir" && as_dir=.
3571	>	for ac_exec_ext in '' $ac_executable_extensions; do
3572	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573	>	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575	>	break 2
3576	>	fi
3577	>	done
3578	>	done
3579	>
3580	>	;;
3581	>	esac
3582	>	fi
3583	>	PS=$ac_cv_path_PS
3584	>
3585	>	if test -n "$PS"; then
3586	>	echo "$as_me:$LINENO: result: $PS" >&5
3587	>	echo "${ECHO_T}$PS" >&6
3588	>	else
3589	>	echo "$as_me:$LINENO: result: no" >&5
3590	>	echo "${ECHO_T}no" >&6
3591	>	fi
3592	>
3593	>	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594	>	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595	>	if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3597	>	else
3598	>
3599	>	if $PS ax -o rss > /dev/null 2>&1; then
3600	>	ac_cv_prog_ps_ax=yes
3601	>	else
3602	>	ac_cv_prog_ps_ax=no
3603	>	fi
3604	>	if $PS -ef -o rss > /dev/null 2>&1; then
3605	>	ac_cv_prog_ps_ef=yes
3606	>	else
3607	>	ac_cv_prog_ps_ef=no
3608	>	fi
3609	>	if test "$ac_cv_prog_ps_ax" = yes; then
3610	>	ac_cv_prog_ps_syntax=BSD
3611	>	else
3612	>	if test "$ac_cv_prog_ps_ef" = yes; then
3613	>	ac_cv_prog_ps_syntax=POSIX
3614	>	else
3615	>	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616	>	echo "$as_me: error: Could not determine ps syntax" >&2;}
3617	>	{ (exit 1); exit 1; }; }
3618	>	fi
3619	>	fi
3620	>
3621	>	fi
3622	>	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623	>	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624	>
3625	>	cat >>confdefs.h <<_ACEOF
3626	>	#define PSCOMMAND $PS
3627	>	_ACEOF
3628	>
3629	>	if test "$ac_cv_prog_ps_syntax" = BSD; then
3630	>
3631	>	cat >>confdefs.h <<\_ACEOF
3632	>	#define PSTYPE_IS_BSD 1
3633	>	_ACEOF
3634	>
3635	>	else
3636	>	if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637	>
3638	>	cat >>confdefs.h <<\_ACEOF
3639	>	#define PSTYPE_IS_POSIX 1
3640	>	_ACEOF
3641	>
3642	>	else
3643	>	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644	>	echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645	>	{ (exit 1); exit 1; }; }
3646	>	fi
3647	>	fi
3648	>
3649	>	ac_ext=${FC_SRCEXT-f}
3650	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653	>
3654	>
3655	>	echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656	>	echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657	>	if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3659	>	else
3660	>	ac_ext=F90
3661	>	ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662	>	FCFLAGS_SRCEXT=""
3663	>	ac_cv_fc_srcext_F90=unknown
3664	>	for ac_flag in none -qsuffix=f=F90 -Tf; do
3665	>	test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666	>	cat >conftest.$ac_ext <<_ACEOF
3667	>	program main
3668	>
3669	>	end
3670	>	_ACEOF
3671	>	rm -f conftest.$ac_objext
3672	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3673	>	(eval $ac_compile) 2>conftest.er1
3674	>	ac_status=$?
3675	>	grep -v '^ *+' conftest.er1 >conftest.err
3676	>	rm -f conftest.er1
3677	>	cat conftest.err >&5
3678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679	>	(exit $ac_status); } &&
3680	>	{ ac_try='test -z "$ac_fc_werror_flag"
3681	>	|| test ! -s conftest.err'
3682	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683	>	(eval $ac_try) 2>&5
3684	>	ac_status=$?
3685	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3686	>	(exit $ac_status); }; } &&
3687	>	{ ac_try='test -s conftest.$ac_objext'
3688	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3689	>	(eval $ac_try) 2>&5
3690	>	ac_status=$?
3691	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692	>	(exit $ac_status); }; }; then
3693	>	ac_cv_fc_srcext_F90=$ac_flag; break
3694	>	else
3695	>	echo "$as_me: failed program was:" >&5
3696	>	sed 's/^/| /' conftest.$ac_ext >&5
3697	>
3698	>	fi
3699	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700	>	done
3701	>	rm -f conftest.$ac_objext conftest.F90
3702	>	FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703	>
3704	>	fi
3705	>	echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706	>	echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707	>	if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708	>	{ { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709	>	echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710	>	{ (exit 1); exit 1; }; }
3711	>	else
3712	>	FC_SRCEXT=F90
3713	>	if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714	>	FCFLAGS_SRCEXT=""
3715	>	FCFLAGS_F90=""
3716	>	else
3717	>	FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718	>	FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719	>	fi
3720	>
3721	>
3722	>	fi
3723	>
3724	>
3725	>
3726	>
3727	>
3728	>	# Try to determine native compiler flags that allow us to use F90 suffix
3729	>	# for preprocessed f90 source.
3730	>
3731	>	if test "$ac_test_PREPFLAG" != "set"; then
3732	>	PREPFLAG=""
3733	>	case "${host_cpu}-${host_os}" in
3734	>
3735	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736	>	PREPFLAG="-fpp1 "
3737	>	fi;;
3738	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739	>	PREPFLAG="-qsuffix=cpp=F90 "
3740	>	fi;;
3741	>	*darwin*)
3742	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743	>	PREPFLAG="-qsuffix=cpp=F90 "
3744	>	fi;;
3745	>	esac
3746	>
3747	>	if test -z "$PREPFLAG"; then
3748	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3749	>	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3750	>	PREPFLAG=""
3751	>	fi
3752	>
3753	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3754	>	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755	>
3756	>
3757	>	ac_ext=${FC_SRCEXT-f}
3758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761	>
3762	>	ac_save_ext=$ac_ext
3763	>	ac_ext=F90
3764	>	ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765	>
3766	>	if test "$PREPFLAG"; then
3767	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3768	>	fi
3769	>
3770	>	cat >conftest.$ac_ext <<_ACEOF
3771	>
3772	>
3773	>	program conftest
3774	>	integer :: i
3775	>	i = 1
3776	>	end program conftest
3777	>
3778	>	_ACEOF
3779	>	rm -f conftest.$ac_objext
3780	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3781	>	(eval $ac_compile) 2>conftest.er1
3782	>	ac_status=$?
3783	>	grep -v '^ *+' conftest.er1 >conftest.err
3784	>	rm -f conftest.er1
3785	>	cat conftest.err >&5
3786	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787	>	(exit $ac_status); } &&
3788	>	{ ac_try='test -z "$ac_fc_werror_flag"
3789	>	|| test ! -s conftest.err'
3790	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791	>	(eval $ac_try) 2>&5
3792	>	ac_status=$?
3793	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794	>	(exit $ac_status); }; } &&
3795	>	{ ac_try='test -s conftest.$ac_objext'
3796	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797	>	(eval $ac_try) 2>&5
3798	>	ac_status=$?
3799	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800	>	(exit $ac_status); }; }; then
3801	>	prepflagworks=1
3802	>	else
3803	>	echo "$as_me: failed program was:" >&5
3804	>	sed 's/^/| /' conftest.$ac_ext >&5
3805	>
3806	>	prepflagworks=0
3807	>	fi
3808	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809	>
3810	>	FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811	>	ac_ext=$ac_save_ext
3812	>	ac_ext=${FC_SRCEXT-f}
3813	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816	>
3817	>
3818	>	if test "$prepflagworks" = 1; then
3819	>	echo "$as_me:$LINENO: result: yes" >&5
3820	>	echo "${ECHO_T}yes" >&6
3821	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3822	>
3823	>	else
3824	>	echo "$as_me:$LINENO: result: no" >&5
3825	>	echo "${ECHO_T}no" >&6
3826	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3827	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3828	>	{ (exit 1); exit 1; }; }
3829	>	fi
3830	>	fi
3831	>
3832	>
3833	>
3834	>
3835	>
3836	>	# Try to determine native compiler flags that allow us to use F90 suffix
3837	>	# for preprocessed f90 source with -D type defines
3838	>
3839	>	if test "$ac_test_PREPDEFFLAG" != "set"; then
3840	>	PREPDEFFLAG=""
3841	>	case "${host_cpu}-${host_os}" in
3842	>
3843	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844	>	PREPDEFFLAG=" "
3845	>	fi;;
3846	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847	>	PREPDEFFLAG="-WF,"
3848	>	fi;;
3849	>	*darwin*)
3850	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851	>	PREPDEFFLAG="-WF,"
3852	>	fi;;
3853	>	esac
3854	>
3855	>	if test -z "$PREPDEFFLAG"; then
3856	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3857	>	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3858	>	PREPDEFFLAG=" "
3859	>	fi
3860	>
3861	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3862	>	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863	>
3864	>
3865	>	ac_ext=${FC_SRCEXT-f}
3866	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869	>
3870	>	ac_save_ext=$ac_ext
3871	>	ac_ext=F90
3872	>	ac_save_FCFLAGS=$FCFLAGS
3873	>
3874	>	if test "$PREPDEFFLAG"; then
3875	>	FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876	>	fi
3877	>
3878	>	cat >conftest.$ac_ext <<_ACEOF
3879	>
3880	>
3881	>	program conftest
3882	>	integer :: i
3883	>	#ifdef TEST
3884	>	i = 1
3885	>	#else
3886	>	choke me
3887	>	#endif
3888	>	end program conftest
3889	>
3890	>	_ACEOF
3891	>	rm -f conftest.$ac_objext
3892	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3893	>	(eval $ac_compile) 2>conftest.er1
3894	>	ac_status=$?
3895	>	grep -v '^ *+' conftest.er1 >conftest.err
3896	>	rm -f conftest.er1
3897	>	cat conftest.err >&5
3898	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899	>	(exit $ac_status); } &&
3900	>	{ ac_try='test -z "$ac_fc_werror_flag"
3901	>	|| test ! -s conftest.err'
3902	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903	>	(eval $ac_try) 2>&5
3904	>	ac_status=$?
3905	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906	>	(exit $ac_status); }; } &&
3907	>	{ ac_try='test -s conftest.$ac_objext'
3908	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3909	>	(eval $ac_try) 2>&5
3910	>	ac_status=$?
3911	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912	>	(exit $ac_status); }; }; then
3913	>	prepdefflagworks=1
3914	>	else
3915	>	echo "$as_me: failed program was:" >&5
3916	>	sed 's/^/| /' conftest.$ac_ext >&5
3917	>
3918	>	prepdefflagworks=0
3919	>	fi
3920	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921	>
3922	>	FCFLAGS=$ac_save_FCFLAGS
3923	>	ac_ext=$ac_save_ext
3924	>	ac_ext=${FC_SRCEXT-f}
3925	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928	>
3929	>
3930	>	if test "$prepdefflagworks" = 1; then
3931	>	echo "$as_me:$LINENO: result: yes" >&5
3932	>	echo "${ECHO_T}yes" >&6
3933	>
3934	>	else
3935	>	echo "$as_me:$LINENO: result: no" >&5
3936	>	echo "${ECHO_T}no" >&6
3937	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3938	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3939	>	{ (exit 1); exit 1; }; }
3940	>	fi
3941	>	fi
3942	>
3943	>	ac_ext=${FC_SRCEXT-f}
3944	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949	>	if test "${ac_cv_prog_fc_v+set}" = set; then
3950	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3951	>	else
3952	>	cat >conftest.$ac_ext <<_ACEOF
3953	>	program main
3954	>
3955	>	end
3956	>	_ACEOF
3957	>	rm -f conftest.$ac_objext
3958	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959	>	(eval $ac_compile) 2>conftest.er1
3960	>	ac_status=$?
3961	>	grep -v '^ *+' conftest.er1 >conftest.err
3962	>	rm -f conftest.er1
3963	>	cat conftest.err >&5
3964	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965	>	(exit $ac_status); } &&
3966	>	{ ac_try='test -z "$ac_fc_werror_flag"
3967	>	|| test ! -s conftest.err'
3968	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969	>	(eval $ac_try) 2>&5
3970	>	ac_status=$?
3971	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972	>	(exit $ac_status); }; } &&
3973	>	{ ac_try='test -s conftest.$ac_objext'
3974	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975	>	(eval $ac_try) 2>&5
3976	>	ac_status=$?
3977	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978	>	(exit $ac_status); }; }; then
3979	>	ac_cv_prog_fc_v=
3980	>	# Try some options frequently used verbose output
3981	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982	>	cat >conftest.$ac_ext <<_ACEOF
3983	>	program main
3984	>
3985	>	end
3986	>	_ACEOF
3987	>
3988	>	# Compile and link our simple test program by passing a flag (argument
3989	>	# 1 to this macro) to the Fortran compiler in order to get
3990	>	# "verbose" output that we can then parse for the Fortran linker
3991	>	# flags.
3992	>	ac_save_FFLAGS=$FCFLAGS
3993	>	FCFLAGS="$FCFLAGS $ac_verb"
3994	>	(eval echo $as_me:3994: \"$ac_link\") >&5
3995	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996	>	echo "$ac_fc_v_output" >&5
3997	>	FCFLAGS=$ac_save_FFLAGS
3998	>
3999	>	rm -f conftest*
4000	>
4001	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4003	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004	>	ac_fc_v_output="`echo $ac_fc_v_output |
4005	>	grep 'LPATH is:' |
4006	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007	>
4008	>	case $ac_fc_v_output in
4009	>	# If we are using xlf then replace all the commas with spaces.
4010	>	*xlfentry*)
4011	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012	>
4013	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4015	>	*mGLOB_options_string*)
4016	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017	>
4018	>	# If we are using Cray Fortran then delete quotes.
4019	>	# Use "\"" instead of '"' for font-lock-mode.
4020	>	# FIXME: a more general fix for quoted arguments with spaces?
4021	>	*cft90*)
4022	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023	>	esac
4024	>
4025	>
4026	>	# look for -l* and *.a constructs in the output
4027	>	for ac_arg in $ac_fc_v_output; do
4028	>	case $ac_arg in
4029	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030	>	ac_cv_prog_fc_v=$ac_verb
4031	>	break 2 ;;
4032	>	esac
4033	>	done
4034	>	done
4035	>	if test -z "$ac_cv_prog_fc_v"; then
4036	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038	>	fi
4039	>	else
4040	>	echo "$as_me: failed program was:" >&5
4041	>	sed 's/^/| /' conftest.$ac_ext >&5
4042	>
4043	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4044	>	echo "$as_me: WARNING: compilation failed" >&2;}
4045	>	fi
4046	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047	>
4048	>	fi
4049	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053	>	if test "${ac_cv_fc_libs+set}" = set; then
4054	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4055	>	else
4056	>	if test "x$FCLIBS" != "x"; then
4057	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058	>	else
4059	>
4060	>	cat >conftest.$ac_ext <<_ACEOF
4061	>	program main
4062	>
4063	>	end
4064	>	_ACEOF
4065	>
4066	>	# Compile and link our simple test program by passing a flag (argument
4067	>	# 1 to this macro) to the Fortran compiler in order to get
4068	>	# "verbose" output that we can then parse for the Fortran linker
4069	>	# flags.
4070	>	ac_save_FFLAGS=$FCFLAGS
4071	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072	>	(eval echo $as_me:4072: \"$ac_link\") >&5
4073	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074	>	echo "$ac_fc_v_output" >&5
4075	>	FCFLAGS=$ac_save_FFLAGS
4076	>
4077	>	rm -f conftest*
4078	>
4079	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4081	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082	>	ac_fc_v_output="`echo $ac_fc_v_output |
4083	>	grep 'LPATH is:' |
4084	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085	>
4086	>	case $ac_fc_v_output in
4087	>	# If we are using xlf then replace all the commas with spaces.
4088	>	*xlfentry*)
4089	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090	>
4091	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4093	>	*mGLOB_options_string*)
4094	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095	>
4096	>	# If we are using Cray Fortran then delete quotes.
4097	>	# Use "\"" instead of '"' for font-lock-mode.
4098	>	# FIXME: a more general fix for quoted arguments with spaces?
4099	>	*cft90*)
4100	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101	>	esac
4102	>
4103	>
4104	>
4105	>	ac_cv_fc_libs=
4106	>
4107	>	# Save positional arguments (if any)
4108	>	ac_save_positional="$@"
4109	>
4110	>	set X $ac_fc_v_output
4111	>	while test $# != 1; do
4112	>	shift
4113	>	ac_arg=$1
4114	>	case $ac_arg in
4115	>	[\\/]*.a | ?:[\\/]*.a)
4116	>	ac_exists=false
4117	>	for ac_i in $ac_cv_fc_libs; do
4118	>	if test x"$ac_arg" = x"$ac_i"; then
4119		ac_exists=true
4120		break
4121		fi
#	Line 3647 | Line 4124 | else
4124		if test x"$ac_exists" = xtrue; then
4125		:
4126		else
4127	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128		fi
4129
4130		;;
4131		-bI:*)
4132		ac_exists=false
4133	<	for ac_i in $ac_cv_f90libs; do
4133	>	for ac_i in $ac_cv_fc_libs; do
4134		if test x"$ac_arg" = x"$ac_i"; then
4135		ac_exists=true
4136		break
#	Line 3665 | Line 4142 | else
4142		else
4143		if test "$ac_compiler_gnu" = yes; then
4144		for ac_link_opt in $ac_arg; do
4145	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146		done
4147		else
4148	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149		fi
4150		fi
4151
4152		;;
4153		# Ignore these flags.
4154	<	-lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155		;;
4156		-lkernel32)
4157	<	test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158		;;
4159		-[LRuY])
4160		# These flags, when seen by themselves, take an argument.
4161		# We remove the space between option and argument and re-iterate
4162		# unless we find an empty arg or a new option (starting with -)
4163		case $2 in
4164	<	"" | -*);;
4165	<	*)
4164	>	"" | -*);;
4165	>	*)
4166		ac_arg="$ac_arg$2"
3690	–
4167		shift; shift
4168		set X $ac_arg "$@"
4169		;;
#	Line 3696 | Line 4172 | fi
4172		-YP,*)
4173		for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174		ac_exists=false
4175	<	for ac_i in $ac_cv_f90libs; do
4175	>	for ac_i in $ac_cv_fc_libs; do
4176		if test x"$ac_j" = x"$ac_i"; then
4177		ac_exists=true
4178		break
#	Line 3707 | Line 4183 | else
4183		:
4184		else
4185		ac_arg="$ac_arg $ac_j"
4186	<	ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187		fi
4188
4189		done
4190		;;
4191		-[lLR]*)
4192		ac_exists=false
4193	<	for ac_i in $ac_cv_f90libs; do
4193	>	for ac_i in $ac_cv_fc_libs; do
4194		if test x"$ac_arg" = x"$ac_i"; then
4195		ac_exists=true
4196		break
#	Line 3724 | Line 4200 | else
4200		if test x"$ac_exists" = xtrue; then
4201		:
4202		else
4203	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204		fi
4205
4206		;;
#	Line 3739 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215		# must begin with a "/").
4216		case `(uname -sr) 2>/dev/null` in
4217		"SunOS 5"*)
4218	<	ac_ld_run_path=`echo $ac_f90_v_output |
4218	>	ac_ld_run_path=`echo $ac_fc_v_output |
4219		sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220		test "x$ac_ld_run_path" != x &&
3745	–
4221		if test "$ac_compiler_gnu" = yes; then
4222		for ac_link_opt in $ac_ld_run_path; do
4223	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224		done
4225		else
4226	<	ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227		fi
4228		;;
4229		esac
4230	<	fi # test "x$F90LIBS" = "x"
4230	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231
4232		fi
4233	<	echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234	<	echo "${ECHO_T}$ac_cv_flibs" >&6
4235	<	F90LIBS="$ac_cv_f90libs"
4233	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235	>	FCLIBS="$ac_cv_fc_libs"
4236
3762	–	ac_ext=f90
3763	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3764	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3765	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4237
4238	+	ac_ext=${FC_SRCEXT-f}
4239	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242
4243	<	echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244	<	echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245	<	if test "${ac_cv_f90_mangling+set}" = set; then
4243	>
4244	>	ac_ext=${FC_SRCEXT-f}
4245	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248	>
4249	>	echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250	>	echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251	>	if test "${ac_cv_fc_dummy_main+set}" = set; then
4252		echo $ECHO_N "(cached) $ECHO_C" >&6
4253		else
4254	<	ac_ext=f90
4255	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4256	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3777	<	cat >conftest.$ac_ext <<_ACEOF
3778	<	subroutine foobar()
3779	<	return
3780	<	end
3781	<	subroutine foo_bar()
3782	<	return
3783	<	end
3784	<	_ACEOF
3785	<	rm -f conftest.$ac_objext
3786	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3787	<	(eval $ac_compile) 2>conftest.er1
3788	<	ac_status=$?
3789	<	grep -v '^ *+' conftest.er1 >conftest.err
3790	<	rm -f conftest.er1
3791	<	cat conftest.err >&5
3792	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3793	<	(exit $ac_status); } &&
3794	<	{ ac_try='test -z "$ac_f90_werror_flag"
3795	<	|| test ! -s conftest.err'
3796	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797	<	(eval $ac_try) 2>&5
3798	<	ac_status=$?
3799	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800	<	(exit $ac_status); }; } &&
3801	<	{ ac_try='test -s conftest.$ac_objext'
3802	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3803	<	(eval $ac_try) 2>&5
3804	<	ac_status=$?
3805	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3806	<	(exit $ac_status); }; }; then
3807	<	mv conftest.$ac_objext cf90_test.$ac_objext
3808	<
3809	<	ac_ext=c
4254	>	ac_fc_dm_save_LIBS=$LIBS
4255	>	LIBS="$LIBS $FCLIBS"
4256	>	ac_fortran_dm_var=FC_DUMMY_MAIN
4257	>	ac_ext=c
4258		ac_cpp='$CPP $CPPFLAGS'
4259		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262
4263	<	ac_save_LIBS=$LIBS
4264	<	LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3817	<
3818	<	ac_success=no
3819	<	for ac_foobar in foobar FOOBAR; do
3820	<	for ac_underscore in "" "_"; do
3821	<	ac_func="$ac_foobar$ac_underscore"
3822	<	cat >conftest.$ac_ext <<_ACEOF
4263	>	# First, try linking without a dummy main:
4264	>	cat >conftest.$ac_ext <<_ACEOF
4265		/* confdefs.h.  */
4266		_ACEOF
4267		cat confdefs.h >>conftest.$ac_ext
4268		cat >>conftest.$ac_ext <<_ACEOF
4269		/* end confdefs.h.  */
4270
4271	<	/* Override any gcc2 internal prototype to avoid an error.  */
4272	<	#ifdef __cplusplus
4273	<	extern "C"
4271	>	#ifdef FC_DUMMY_MAIN
4272	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4273	>	#  ifdef __cplusplus
4274	>	extern "C"
4275	>	#  endif
4276	>	int FC_DUMMY_MAIN() { return 1; }
4277		#endif
4278	<	/* We use char because int might match the return type of a gcc2
3834	<	builtin and then its argument prototype would still apply.  */
3835	<	char $ac_func ();
4278	>	#endif
4279		int
4280		main ()
4281		{
4282	<	$ac_func ();
4282	>
4283		;
4284		return 0;
4285		}
#	Line 3863 | Line 4306 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4306		ac_status=$?
4307		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308		(exit $ac_status); }; }; then
4309	<	ac_success=yes; break 2
4309	>	ac_cv_fortran_dummy_main=none
4310		else
4311		echo "$as_me: failed program was:" >&5
4312		sed 's/^/| /' conftest.$ac_ext >&5
4313
4314	+	ac_cv_fortran_dummy_main=unknown
4315		fi
4316		rm -f conftest.err conftest.$ac_objext \
4317		conftest$ac_exeext conftest.$ac_ext
3874	–	done
3875	–	done
4318
4319	<	if test "$ac_success" = "yes"; then
4320	<	case $ac_foobar in
4321	<	foobar)
3880	<	ac_case=lower
3881	<	ac_foo_bar=foo_bar
3882	<	;;
3883	<	FOOBAR)
3884	<	ac_case=upper
3885	<	ac_foo_bar=FOO_BAR
3886	<	;;
3887	<	esac
3888	<
3889	<	ac_success_extra=no
3890	<	for ac_extra in "" "_"; do
3891	<	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3892	<
3893	<	cat >conftest.$ac_ext <<_ACEOF
4319	>	if test $ac_cv_fortran_dummy_main = unknown; then
4320	>	for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321	>	cat >conftest.$ac_ext <<_ACEOF
4322		/* confdefs.h.  */
4323		_ACEOF
4324		cat confdefs.h >>conftest.$ac_ext
4325		cat >>conftest.$ac_ext <<_ACEOF
4326		/* end confdefs.h.  */
4327	<
4328	<	/* Override any gcc2 internal prototype to avoid an error.  */
4329	<	#ifdef __cplusplus
4330	<	extern "C"
4327	>	#define $ac_fortran_dm_var $ac_func
4328	>	#ifdef FC_DUMMY_MAIN
4329	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4330	>	#  ifdef __cplusplus
4331	>	extern "C"
4332	>	#  endif
4333	>	int FC_DUMMY_MAIN() { return 1; }
4334		#endif
4335	<	/* We use char because int might match the return type of a gcc2
3905	<	builtin and then its argument prototype would still apply.  */
3906	<	char $ac_func ();
4335	>	#endif
4336		int
4337		main ()
4338		{
4339	<	$ac_func ();
4339	>
4340		;
4341		return 0;
4342		}
#	Line 3934 | Line 4363 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4363		ac_status=$?
4364		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365		(exit $ac_status); }; }; then
4366	<	ac_success_extra=yes; break
4366	>	ac_cv_fortran_dummy_main=$ac_func; break
4367		else
4368		echo "$as_me: failed program was:" >&5
4369		sed 's/^/| /' conftest.$ac_ext >&5
#	Line 3942 | Line 4371 | rm -f conftest.err conftest.$ac_objext \
4371		fi
4372		rm -f conftest.err conftest.$ac_objext \
4373		conftest$ac_exeext conftest.$ac_ext
4374	<	done
4374	>	done
4375	>	fi
4376	>	ac_ext=${FC_SRCEXT-f}
4377	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380	>	ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381	>	rm -f conftest*
4382	>	LIBS=$ac_fc_dm_save_LIBS
4383
4384	<	if test "$ac_success_extra" = "yes"; then
4385	<	ac_cv_f90_mangling="$ac_case case"
4386	<	if test -z "$ac_underscore"; then
4387	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4388	<	else
4389	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4384	>	fi
4385	>	echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386	>	echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387	>	FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388	>	if test "$FC_DUMMY_MAIN" != unknown; then
4389	>	if test $FC_DUMMY_MAIN != none; then
4390
4391	<	fi
4392	<	if test -z "$ac_extra"; then
4393	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3957	<	else
3958	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3959	<	fi
3960	<	else
3961	<	ac_cv_f90_mangling="unknown"
3962	<	fi
3963	<	else
3964	<	ac_cv_f90_mangling="unknown"
4391	>	cat >>confdefs.h <<_ACEOF
4392	>	#define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393	>	_ACEOF
4394
4395	<	fi
4396	<
4397	<	LIBS=$ac_save_LIBS
4398	<	ac_ext=f90
4399	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4400	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4401	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4402	<	rm -f cf90_test* conftest*
4403	<	else
4404	<	echo "$as_me: failed program was:" >&5
4405	<	sed 's/^/| /' conftest.$ac_ext >&5
4406	<
4407	<	fi
4408	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4409	<	ac_ext=f90
4410	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4411	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4412	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4413	<
4414	<	fi
4415	<	echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4416	<	echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4417	<
4418	<
4419	<
4420	<	case $ac_cv_f90_mangling in
4421	<	"lower case, no underscore, no extra underscore")
4422	<	cat >>confdefs.h <<\_ACEOF
4423	<	#define F90_FUNC(name,NAME) name
4424	<	_ACEOF
4425	<
4426	<	cat >>confdefs.h <<\_ACEOF
4427	<	#define F90_FUNC_(name,NAME) name
4428	<	_ACEOF
4429	<	;;
4430	<	"lower case, no underscore, extra underscore")
4431	<	cat >>confdefs.h <<\_ACEOF
4432	<	#define F90_FUNC(name,NAME) name
4433	<	_ACEOF
4434	<
4435	<	cat >>confdefs.h <<\_ACEOF
4436	<	#define F90_FUNC_(name,NAME) name ## _
4437	<	_ACEOF
4438	<	;;
4439	<	"lower case, underscore, no extra underscore")
4440	<	cat >>confdefs.h <<\_ACEOF
4441	<	#define F90_FUNC(name,NAME) name ## _
4442	<	_ACEOF
4443	<
4444	<	cat >>confdefs.h <<\_ACEOF
4445	<	#define F90_FUNC_(name,NAME) name ## _
4446	<	_ACEOF
4447	<	;;
4448	<	"lower case, underscore, extra underscore")
4449	<	cat >>confdefs.h <<\_ACEOF
4450	<	#define F90_FUNC(name,NAME) name ## _
4451	<	_ACEOF
4452	<
4453	<	cat >>confdefs.h <<\_ACEOF
4454	<	#define F90_FUNC_(name,NAME) name ## __
4455	<	_ACEOF
4456	<	;;
4457	<	"upper case, no underscore, no extra underscore")
4458	<	cat >>confdefs.h <<\_ACEOF
4459	<	#define F90_FUNC(name,NAME) NAME
4460	<	_ACEOF
4461	<
4462	<	cat >>confdefs.h <<\_ACEOF
4463	<	#define F90_FUNC_(name,NAME) NAME
4464	<	_ACEOF
4465	<	;;
4466	<	"upper case, no underscore, extra underscore")
4467	<	cat >>confdefs.h <<\_ACEOF
4468	<	#define F90_FUNC(name,NAME) NAME
4469	<	_ACEOF
4470	<
4471	<	cat >>confdefs.h <<\_ACEOF
4472	<	#define F90_FUNC_(name,NAME) NAME ## _
4473	<	_ACEOF
4474	<	;;
4475	<	"upper case, underscore, no extra underscore")
4476	<	cat >>confdefs.h <<\_ACEOF
4477	<	#define F90_FUNC(name,NAME) NAME ## _
4478	<	_ACEOF
4479	<
4480	<	cat >>confdefs.h <<\_ACEOF
4481	<	#define F90_FUNC_(name,NAME) NAME ## _
4482	<	_ACEOF
4483	<	;;
4484	<	"upper case, underscore, extra underscore")
4485	<	cat >>confdefs.h <<\_ACEOF
4486	<	#define F90_FUNC(name,NAME) NAME ## _
4487	<	_ACEOF
4488	<
4489	<	cat >>confdefs.h <<\_ACEOF
4490	<	#define F90_FUNC_(name,NAME) NAME ## __
4491	<	_ACEOF
4492	<	;;
4493	<	*)
4494	<	{ echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4495	<	echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4496	<	;;
4497	<	esac
4498	<
4499	<
4500	<
4501	<
4502	<
4503	<	echo "$as_me:$LINENO: checking for module suffix" >&5
4504	<	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4505	<	rm -f conftest*
4506	<	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4507	<	rm -f work*
4508	<	cat >conftest.f90 <<EOF
4509	<	module conftest
4510	<	integer n
4511	<	parameter (n=1)
4512	<	end module conftest
4513	<	EOF
4514	<	# SGI and absoft compilers generates module name in upper case!
4515	<	testname="conftest"
4516	<	modcase="lower"
4517	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4518	<	MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4519	<	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4520	<	if test -z "$MOD" ; then
4521	<	MOD=`ls CONFTEST* 2>/dev/null \
4522	<	| grep -v CONFTEST.f | grep -v CONFTEST.o`
4523	<	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4524	<	if test -n "$MOD" ; then
4525	<	testname="CONFTEST"
4526	<	modcase="upper"
4527	<	fi
4528	<	fi
4529	<	if test -z "$MOD" ; then
4530	<	echo "$as_me:$LINENO: result: unknown" >&5
4531	<	echo "${ECHO_T}unknown" >&6
4532	<	# Use mod if we can't figure it out
4533	<	MOD="mod"
4534	<	else
4535	<	echo "$as_me:$LINENO: result: $MOD" >&5
4536	<	echo "${ECHO_T}$MOD" >&6
4537	<	fi
4538	<	if test -s work.pcl ; then
4539	<	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4540	<	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4541	<	fi
4542	<	else
4543	<	echo "$as_me:$LINENO: result: unknown" >&5
4544	<	echo "${ECHO_T}unknown" >&6
4545	<	fi
4546	<
4547	<
4548	<
4549	<
4550	<
4551	<	# Check for module include path (some use -I, some (Solaris) use -M, some
4552	<	# (absoft) use -p).
4553	<	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4554	<	# specified, work.pcl and work.pc are created.  However, if you specify
4555	<	# a file, it must contain a the name of a file ending in .pc .  Ugh!
4556	<	# Use the module made above
4557	<	echo "$as_me:$LINENO: checking for module directory path flag" >&5
4558	<	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4559	<	rm -f conftest*
4560	<	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4561	<	rm -f work*
4562	<	cat >conftest.f90 <<EOF
4563	<	module conftest
4564	<	integer n
4565	<	parameter (n=1)
4566	<	end module conftest
4567	<	EOF
4568	<	# SGI and absoft compilers generates module name in upper case!
4569	<	testname="conftest"
4570	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4571	<	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4572	<	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4573	<	if test -n "$mod" ; then
4574	<	testname="CONFTEST"
4575	<	fi
4576	<	madedir=0
4577	<	if test ! -d conf ; then mkdir conf ; madedir=1; fi
4578	<	cp $testname.$MOD conf
4579	<	rm -f conftest* CONFTEST*
4580	<	cat >conftest1.f90 <<EOF
4581	<	program main
4582	<	use conftest
4583	<	print *, n
4584	<	end
4585	<	EOF
4586	<	F90_WORK_FILES_ARG=""
4587	<	F90MODINCSPEC=""
4588	<	if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4589	<	MODDIRFLAG="-I"
4590	<	F90MODINCSPEC="-I<dir>"
4591	<	echo "$as_me:$LINENO: result: -I" >&5
4592	<	echo "${ECHO_T}-I" >&6
4593	<	elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4594	<	MODDIRFLAG="-M"
4595	<	F90MODINCSPEC="-M<dir>"
4596	<	echo "$as_me:$LINENO: result: -M" >&5
4597	<	echo "${ECHO_T}-M" >&6
4598	<	elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4599	<	MODDIRFLAG="-p"
4600	<	F90MODINCSPEC="-p<dir>"
4601	<	echo "$as_me:$LINENO: result: -p" >&5
4602	<	echo "${ECHO_T}-p" >&6
4603	<	elif test -s work.pc ; then
4604	<	cp work.pc conf/mpimod.pc
4605	<	echo "mpimod.pc" > conf/mpimod.pcl
4606	<	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4607	<	if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4608	<	MODDIRFLAG='-cl,mpimod.pcl'
4609	<	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4610	<	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4611	<	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4612	<	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4613	<
4614	<	else
4615	<	# The version of the Intel compiler that I have refuses to let
4616	<	# you put the "work catalog" list anywhere but the current
4617	<	# directory. For example, you cannot in
4618	<	:
4619	<	fi
4620	<	fi
4621	<	if test -z "MODDIRFLAG" ; then
4622	<	echo "$as_me:$LINENO: result: unknown" >&5
4623	<	echo "${ECHO_T}unknown" >&6
4624	<	fi
4395	>	if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396	>
4397	>	cat >>confdefs.h <<\_ACEOF
4398	>	#define FC_DUMMY_MAIN_EQ_F77 1
4399	>	_ACEOF
4400	>
4401	>	fi
4402	>	fi
4403	>	else
4404	>	{ { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405	>	See \`config.log' for more details." >&5
4406	>	echo "$as_me: error: linking to Fortran libraries from C fails
4407	>	See \`config.log' for more details." >&2;}
4408	>	{ (exit 1); exit 1; }; }
4409	>	fi
4410	>
4411	>
4412	>	ac_ext=${FC_SRCEXT-f}
4413	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416	>
4417	>	ac_ext=${FC_SRCEXT-f}
4418	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421	>	echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422	>	echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423	>	if test "${ac_cv_fc_mangling+set}" = set; then
4424	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4425	>	else
4426	>	cat >conftest.$ac_ext <<_ACEOF
4427	>	subroutine foobar()
4428	>	return
4429	>	end
4430	>	subroutine foo_bar()
4431	>	return
4432	>	end
4433	>	_ACEOF
4434	>	rm -f conftest.$ac_objext
4435	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436	>	(eval $ac_compile) 2>conftest.er1
4437	>	ac_status=$?
4438	>	grep -v '^ *+' conftest.er1 >conftest.err
4439	>	rm -f conftest.er1
4440	>	cat conftest.err >&5
4441	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442	>	(exit $ac_status); } &&
4443	>	{ ac_try='test -z "$ac_fc_werror_flag"
4444	>	|| test ! -s conftest.err'
4445	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446	>	(eval $ac_try) 2>&5
4447	>	ac_status=$?
4448	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4449	>	(exit $ac_status); }; } &&
4450	>	{ ac_try='test -s conftest.$ac_objext'
4451	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4452	>	(eval $ac_try) 2>&5
4453	>	ac_status=$?
4454	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455	>	(exit $ac_status); }; }; then
4456	>	mv conftest.$ac_objext cfortran_test.$ac_objext
4457	>
4458	>	ac_save_LIBS=$LIBS
4459	>	LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460	>
4461	>	ac_ext=c
4462	>	ac_cpp='$CPP $CPPFLAGS'
4463	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4466	>	ac_success=no
4467	>	for ac_foobar in foobar FOOBAR; do
4468	>	for ac_underscore in "" "_"; do
4469	>	ac_func="$ac_foobar$ac_underscore"
4470	>	cat >conftest.$ac_ext <<_ACEOF
4471	>	/* confdefs.h.  */
4472	>	_ACEOF
4473	>	cat confdefs.h >>conftest.$ac_ext
4474	>	cat >>conftest.$ac_ext <<_ACEOF
4475	>	/* end confdefs.h.  */
4476	>
4477	>	/* Override any gcc2 internal prototype to avoid an error.  */
4478	>	#ifdef __cplusplus
4479	>	extern "C"
4480	>	#endif
4481	>	/* We use char because int might match the return type of a gcc2
4482	>	builtin and then its argument prototype would still apply.  */
4483	>	char $ac_func ();
4484	>	#ifdef FC_DUMMY_MAIN
4485	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4486	>	#  ifdef __cplusplus
4487	>	extern "C"
4488	>	#  endif
4489	>	int FC_DUMMY_MAIN() { return 1; }
4490	>	#endif
4491	>	#endif
4492	>	int
4493	>	main ()
4494	>	{
4495	>	$ac_func ();
4496	>	;
4497	>	return 0;
4498	>	}
4499	>	_ACEOF
4500	>	rm -f conftest.$ac_objext conftest$ac_exeext
4501	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4502	>	(eval $ac_link) 2>conftest.er1
4503	>	ac_status=$?
4504	>	grep -v '^ *+' conftest.er1 >conftest.err
4505	>	rm -f conftest.er1
4506	>	cat conftest.err >&5
4507	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508	>	(exit $ac_status); } &&
4509	>	{ ac_try='test -z "$ac_c_werror_flag"
4510	>	|| test ! -s conftest.err'
4511	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512	>	(eval $ac_try) 2>&5
4513	>	ac_status=$?
4514	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515	>	(exit $ac_status); }; } &&
4516	>	{ ac_try='test -s conftest$ac_exeext'
4517	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518	>	(eval $ac_try) 2>&5
4519	>	ac_status=$?
4520	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521	>	(exit $ac_status); }; }; then
4522	>	ac_success=yes; break 2
4523	>	else
4524	>	echo "$as_me: failed program was:" >&5
4525	>	sed 's/^/| /' conftest.$ac_ext >&5
4526	>
4527	>	fi
4528	>	rm -f conftest.err conftest.$ac_objext \
4529	>	conftest$ac_exeext conftest.$ac_ext
4530	>	done
4531	>	done
4532	>	ac_ext=${FC_SRCEXT-f}
4533	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536	>
4537	>	if test "$ac_success" = "yes"; then
4538	>	case $ac_foobar in
4539	>	foobar)
4540	>	ac_case=lower
4541	>	ac_foo_bar=foo_bar
4542	>	;;
4543	>	FOOBAR)
4544	>	ac_case=upper
4545	>	ac_foo_bar=FOO_BAR
4546	>	;;
4547	>	esac
4548	>
4549	>	ac_ext=c
4550	>	ac_cpp='$CPP $CPPFLAGS'
4551	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554	>	ac_success_extra=no
4555	>	for ac_extra in "" "_"; do
4556	>	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557	>	cat >conftest.$ac_ext <<_ACEOF
4558	>	/* confdefs.h.  */
4559	>	_ACEOF
4560	>	cat confdefs.h >>conftest.$ac_ext
4561	>	cat >>conftest.$ac_ext <<_ACEOF
4562	>	/* end confdefs.h.  */
4563	>
4564	>	/* Override any gcc2 internal prototype to avoid an error.  */
4565	>	#ifdef __cplusplus
4566	>	extern "C"
4567	>	#endif
4568	>	/* We use char because int might match the return type of a gcc2
4569	>	builtin and then its argument prototype would still apply.  */
4570	>	char $ac_func ();
4571	>	#ifdef FC_DUMMY_MAIN
4572	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4573	>	#  ifdef __cplusplus
4574	>	extern "C"
4575	>	#  endif
4576	>	int FC_DUMMY_MAIN() { return 1; }
4577	>	#endif
4578	>	#endif
4579	>	int
4580	>	main ()
4581	>	{
4582	>	$ac_func ();
4583	>	;
4584	>	return 0;
4585	>	}
4586	>	_ACEOF
4587	>	rm -f conftest.$ac_objext conftest$ac_exeext
4588	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4589	>	(eval $ac_link) 2>conftest.er1
4590	>	ac_status=$?
4591	>	grep -v '^ *+' conftest.er1 >conftest.err
4592	>	rm -f conftest.er1
4593	>	cat conftest.err >&5
4594	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595	>	(exit $ac_status); } &&
4596	>	{ ac_try='test -z "$ac_c_werror_flag"
4597	>	|| test ! -s conftest.err'
4598	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4599	>	(eval $ac_try) 2>&5
4600	>	ac_status=$?
4601	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602	>	(exit $ac_status); }; } &&
4603	>	{ ac_try='test -s conftest$ac_exeext'
4604	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4605	>	(eval $ac_try) 2>&5
4606	>	ac_status=$?
4607	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4608	>	(exit $ac_status); }; }; then
4609	>	ac_success_extra=yes; break
4610	>	else
4611	>	echo "$as_me: failed program was:" >&5
4612	>	sed 's/^/| /' conftest.$ac_ext >&5
4613	>
4614	>	fi
4615	>	rm -f conftest.err conftest.$ac_objext \
4616	>	conftest$ac_exeext conftest.$ac_ext
4617	>	done
4618	>	ac_ext=${FC_SRCEXT-f}
4619	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622	>
4623	>	if test "$ac_success_extra" = "yes"; then
4624	>	ac_cv_fc_mangling="$ac_case case"
4625	>	if test -z "$ac_underscore"; then
4626	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627	>	else
4628	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629	>	fi
4630	>	if test -z "$ac_extra"; then
4631	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632	>	else
4633	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634	>	fi
4635	>	else
4636	>	ac_cv_fc_mangling="unknown"
4637	>	fi
4638	>	else
4639	>	ac_cv_fc_mangling="unknown"
4640	>	fi
4641	>
4642	>	LIBS=$ac_save_LIBS
4643	>	rm -f cfortran_test* conftest*
4644	>	else
4645	>	echo "$as_me: failed program was:" >&5
4646	>	sed 's/^/| /' conftest.$ac_ext >&5
4647	>
4648	>	{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649	>	See \`config.log' for more details." >&5
4650	>	echo "$as_me: error: cannot compile a simple Fortran program
4651	>	See \`config.log' for more details." >&2;}
4652	>	{ (exit 1); exit 1; }; }
4653	>	fi
4654	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4655	>
4656	>	fi
4657	>	echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658	>	echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659	>
4660	>	ac_ext=${FC_SRCEXT-f}
4661	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664	>
4665	>	ac_ext=${FC_SRCEXT-f}
4666	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669	>
4670	>
4671	>	case $ac_cv_fc_mangling in
4672	>	"lower case, no underscore, no extra underscore")
4673	>	cat >>confdefs.h <<\_ACEOF
4674	>	#define FC_FUNC(name,NAME) name
4675	>	_ACEOF
4676	>
4677	>	cat >>confdefs.h <<\_ACEOF
4678	>	#define FC_FUNC_(name,NAME) name
4679	>	_ACEOF
4680	>	;;
4681	>	"lower case, no underscore, extra underscore")
4682	>	cat >>confdefs.h <<\_ACEOF
4683	>	#define FC_FUNC(name,NAME) name
4684	>	_ACEOF
4685	>
4686	>	cat >>confdefs.h <<\_ACEOF
4687	>	#define FC_FUNC_(name,NAME) name ## _
4688	>	_ACEOF
4689	>	;;
4690	>	"lower case, underscore, no extra underscore")
4691	>	cat >>confdefs.h <<\_ACEOF
4692	>	#define FC_FUNC(name,NAME) name ## _
4693	>	_ACEOF
4694	>
4695	>	cat >>confdefs.h <<\_ACEOF
4696	>	#define FC_FUNC_(name,NAME) name ## _
4697	>	_ACEOF
4698	>	;;
4699	>	"lower case, underscore, extra underscore")
4700	>	cat >>confdefs.h <<\_ACEOF
4701	>	#define FC_FUNC(name,NAME) name ## _
4702	>	_ACEOF
4703	>
4704	>	cat >>confdefs.h <<\_ACEOF
4705	>	#define FC_FUNC_(name,NAME) name ## __
4706	>	_ACEOF
4707	>	;;
4708	>	"upper case, no underscore, no extra underscore")
4709	>	cat >>confdefs.h <<\_ACEOF
4710	>	#define FC_FUNC(name,NAME) NAME
4711	>	_ACEOF
4712	>
4713	>	cat >>confdefs.h <<\_ACEOF
4714	>	#define FC_FUNC_(name,NAME) NAME
4715	>	_ACEOF
4716	>	;;
4717	>	"upper case, no underscore, extra underscore")
4718	>	cat >>confdefs.h <<\_ACEOF
4719	>	#define FC_FUNC(name,NAME) NAME
4720	>	_ACEOF
4721	>
4722	>	cat >>confdefs.h <<\_ACEOF
4723	>	#define FC_FUNC_(name,NAME) NAME ## _
4724	>	_ACEOF
4725	>	;;
4726	>	"upper case, underscore, no extra underscore")
4727	>	cat >>confdefs.h <<\_ACEOF
4728	>	#define FC_FUNC(name,NAME) NAME ## _
4729	>	_ACEOF
4730	>
4731	>	cat >>confdefs.h <<\_ACEOF
4732	>	#define FC_FUNC_(name,NAME) NAME ## _
4733	>	_ACEOF
4734	>	;;
4735	>	"upper case, underscore, extra underscore")
4736	>	cat >>confdefs.h <<\_ACEOF
4737	>	#define FC_FUNC(name,NAME) NAME ## _
4738	>	_ACEOF
4739	>
4740	>	cat >>confdefs.h <<\_ACEOF
4741	>	#define FC_FUNC_(name,NAME) NAME ## __
4742	>	_ACEOF
4743	>	;;
4744	>	*)
4745	>	{ echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746	>	echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747	>	;;
4748	>	esac
4749	>
4750	>	ac_ext=${FC_SRCEXT-f}
4751	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754	>
4755	>
4756	>
4757	>	ac_ext=${FC_SRCEXT-f}
4758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763	>	if test "${ac_cv_prog_fc_v+set}" = set; then
4764	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4765	>	else
4766	>	cat >conftest.$ac_ext <<_ACEOF
4767	>	program main
4768	>
4769	>	end
4770	>	_ACEOF
4771	>	rm -f conftest.$ac_objext
4772	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773	>	(eval $ac_compile) 2>conftest.er1
4774	>	ac_status=$?
4775	>	grep -v '^ *+' conftest.er1 >conftest.err
4776	>	rm -f conftest.er1
4777	>	cat conftest.err >&5
4778	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779	>	(exit $ac_status); } &&
4780	>	{ ac_try='test -z "$ac_fc_werror_flag"
4781	>	|| test ! -s conftest.err'
4782	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783	>	(eval $ac_try) 2>&5
4784	>	ac_status=$?
4785	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786	>	(exit $ac_status); }; } &&
4787	>	{ ac_try='test -s conftest.$ac_objext'
4788	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789	>	(eval $ac_try) 2>&5
4790	>	ac_status=$?
4791	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792	>	(exit $ac_status); }; }; then
4793	>	ac_cv_prog_fc_v=
4794	>	# Try some options frequently used verbose output
4795	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796	>	cat >conftest.$ac_ext <<_ACEOF
4797	>	program main
4798	>
4799	>	end
4800	>	_ACEOF
4801	>
4802	>	# Compile and link our simple test program by passing a flag (argument
4803	>	# 1 to this macro) to the Fortran compiler in order to get
4804	>	# "verbose" output that we can then parse for the Fortran linker
4805	>	# flags.
4806	>	ac_save_FFLAGS=$FCFLAGS
4807	>	FCFLAGS="$FCFLAGS $ac_verb"
4808	>	(eval echo $as_me:4808: \"$ac_link\") >&5
4809	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810	>	echo "$ac_fc_v_output" >&5
4811	>	FCFLAGS=$ac_save_FFLAGS
4812	>
4813	>	rm -f conftest*
4814	>
4815	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4817	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818	>	ac_fc_v_output="`echo $ac_fc_v_output |
4819	>	grep 'LPATH is:' |
4820	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821	>
4822	>	case $ac_fc_v_output in
4823	>	# If we are using xlf then replace all the commas with spaces.
4824	>	*xlfentry*)
4825	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826	>
4827	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4829	>	*mGLOB_options_string*)
4830	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831	>
4832	>	# If we are using Cray Fortran then delete quotes.
4833	>	# Use "\"" instead of '"' for font-lock-mode.
4834	>	# FIXME: a more general fix for quoted arguments with spaces?
4835	>	*cft90*)
4836	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837	>	esac
4838	>
4839	>
4840	>	# look for -l* and *.a constructs in the output
4841	>	for ac_arg in $ac_fc_v_output; do
4842	>	case $ac_arg in
4843	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844	>	ac_cv_prog_fc_v=$ac_verb
4845	>	break 2 ;;
4846	>	esac
4847	>	done
4848	>	done
4849	>	if test -z "$ac_cv_prog_fc_v"; then
4850	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852	>	fi
4853	>	else
4854	>	echo "$as_me: failed program was:" >&5
4855	>	sed 's/^/| /' conftest.$ac_ext >&5
4856	>
4857	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858	>	echo "$as_me: WARNING: compilation failed" >&2;}
4859	>	fi
4860	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861	>
4862	>	fi
4863	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867	>	if test "${ac_cv_fc_libs+set}" = set; then
4868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4869	>	else
4870	>	if test "x$FCLIBS" != "x"; then
4871	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872	>	else
4873	>
4874	>	cat >conftest.$ac_ext <<_ACEOF
4875	>	program main
4876	>
4877	>	end
4878	>	_ACEOF
4879	>
4880	>	# Compile and link our simple test program by passing a flag (argument
4881	>	# 1 to this macro) to the Fortran compiler in order to get
4882	>	# "verbose" output that we can then parse for the Fortran linker
4883	>	# flags.
4884	>	ac_save_FFLAGS=$FCFLAGS
4885	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886	>	(eval echo $as_me:4886: \"$ac_link\") >&5
4887	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888	>	echo "$ac_fc_v_output" >&5
4889	>	FCFLAGS=$ac_save_FFLAGS
4890	>
4891	>	rm -f conftest*
4892	>
4893	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4895	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896	>	ac_fc_v_output="`echo $ac_fc_v_output |
4897	>	grep 'LPATH is:' |
4898	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899	>
4900	>	case $ac_fc_v_output in
4901	>	# If we are using xlf then replace all the commas with spaces.
4902	>	*xlfentry*)
4903	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904	>
4905	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4907	>	*mGLOB_options_string*)
4908	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909	>
4910	>	# If we are using Cray Fortran then delete quotes.
4911	>	# Use "\"" instead of '"' for font-lock-mode.
4912	>	# FIXME: a more general fix for quoted arguments with spaces?
4913	>	*cft90*)
4914	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915	>	esac
4916	>
4917	>
4918	>
4919	>	ac_cv_fc_libs=
4920	>
4921	>	# Save positional arguments (if any)
4922	>	ac_save_positional="$@"
4923	>
4924	>	set X $ac_fc_v_output
4925	>	while test $# != 1; do
4926	>	shift
4927	>	ac_arg=$1
4928	>	case $ac_arg in
4929	>	[\\/]*.a | ?:[\\/]*.a)
4930	>	ac_exists=false
4931	>	for ac_i in $ac_cv_fc_libs; do
4932	>	if test x"$ac_arg" = x"$ac_i"; then
4933	>	ac_exists=true
4934	>	break
4935	>	fi
4936	>	done
4937	>
4938	>	if test x"$ac_exists" = xtrue; then
4939	>	:
4940	>	else
4941	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942	>	fi
4943	>
4944	>	;;
4945	>	-bI:*)
4946	>	ac_exists=false
4947	>	for ac_i in $ac_cv_fc_libs; do
4948	>	if test x"$ac_arg" = x"$ac_i"; then
4949	>	ac_exists=true
4950	>	break
4951	>	fi
4952	>	done
4953	>
4954	>	if test x"$ac_exists" = xtrue; then
4955	>	:
4956	>	else
4957	>	if test "$ac_compiler_gnu" = yes; then
4958	>	for ac_link_opt in $ac_arg; do
4959	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960	>	done
4961	>	else
4962	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963	>	fi
4964	>	fi
4965	>
4966	>	;;
4967	>	# Ignore these flags.
4968	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969	>	;;
4970	>	-lkernel32)
4971	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972	>	;;
4973	>	-[LRuY])
4974	>	# These flags, when seen by themselves, take an argument.
4975	>	# We remove the space between option and argument and re-iterate
4976	>	# unless we find an empty arg or a new option (starting with -)
4977	>	case $2 in
4978	>	"" | -*);;
4979	>	*)
4980	>	ac_arg="$ac_arg$2"
4981	>	shift; shift
4982	>	set X $ac_arg "$@"
4983	>	;;
4984	>	esac
4985	>	;;
4986	>	-YP,*)
4987	>	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988	>	ac_exists=false
4989	>	for ac_i in $ac_cv_fc_libs; do
4990	>	if test x"$ac_j" = x"$ac_i"; then
4991	>	ac_exists=true
4992	>	break
4993	>	fi
4994	>	done
4995	>
4996	>	if test x"$ac_exists" = xtrue; then
4997	>	:
4998	>	else
4999	>	ac_arg="$ac_arg $ac_j"
5000	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001	>	fi
5002	>
5003	>	done
5004	>	;;
5005	>	-[lLR]*)
5006	>	ac_exists=false
5007	>	for ac_i in $ac_cv_fc_libs; do
5008	>	if test x"$ac_arg" = x"$ac_i"; then
5009	>	ac_exists=true
5010	>	break
5011	>	fi
5012	>	done
5013	>
5014	>	if test x"$ac_exists" = xtrue; then
5015	>	:
5016	>	else
5017	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018	>	fi
5019	>
5020	>	;;
5021	>	# Ignore everything else.
5022	>	esac
5023	>	done
5024	>	# restore positional arguments
5025	>	set X $ac_save_positional; shift
5026	>
5027	>	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028	>	# then we insist that the "run path" must be an absolute path (i.e. it
5029	>	# must begin with a "/").
5030	>	case `(uname -sr) 2>/dev/null` in
5031	>	"SunOS 5"*)
5032	>	ac_ld_run_path=`echo $ac_fc_v_output |
5033	>	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034	>	test "x$ac_ld_run_path" != x &&
5035	>	if test "$ac_compiler_gnu" = yes; then
5036	>	for ac_link_opt in $ac_ld_run_path; do
5037	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038	>	done
5039	>	else
5040	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041	>	fi
5042	>	;;
5043	>	esac
5044	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045	>
5046	>	fi
5047	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049	>	FCLIBS="$ac_cv_fc_libs"
5050	>
5051	>
5052	>	ac_ext=${FC_SRCEXT-f}
5053	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056	>
5057	>
5058	>
5059	>	echo "$as_me:$LINENO: checking for module suffix" >&5
5060	>	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061	>	rm -f conftest*
5062	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063	>	rm -f work*
5064	>	cat >conftest.$ac_ext <<EOF
5065	>	module conftest
5066	>	integer n
5067	>	parameter (n=1)
5068	>	end module conftest
5069	>	EOF
5070	>	# SGI and absoft compilers generates module name in upper case!
5071	>	testname="conftest"
5072	>	modcase="lower"
5073	>	if (eval $ac_compile) 2>/dev/null ; then
5074	>	MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075	>	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076	>	if test -z "$MOD" ; then
5077	>	MOD=`ls CONFTEST* 2>/dev/null \
5078	>	| grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079	>	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080	>	if test -n "$MOD" ; then
5081	>	testname="CONFTEST"
5082	>	modcase="upper"
5083	>	fi
5084	>	fi
5085	>	if test -z "$MOD" ; then
5086	>	echo "$as_me:$LINENO: result: unknown" >&5
5087	>	echo "${ECHO_T}unknown" >&6
5088	>	# Use mod if we can't figure it out
5089	>	MOD="mod"
5090	>	else
5091	>	echo "$as_me:$LINENO: result: $MOD" >&5
5092	>	echo "${ECHO_T}$MOD" >&6
5093	>	fi
5094	>	if test -s work.pcl ; then
5095	>	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5096	>	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5097	>	fi
5098	>	else
5099	>	echo "$as_me:$LINENO: result: unknown" >&5
5100	>	echo "${ECHO_T}unknown" >&6
5101	>	fi
5102	>
5103	>
5104	>
5105	>
5106	>
5107	>	# Check for module include path (some use -I, some (Solaris) use -M, some
5108	>	# (absoft) use -p).
5109	>	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5110	>	# specified, work.pcl and work.pc are created.  However, if you specify
5111	>	# a file, it must contain a the name of a file ending in .pc .  Ugh!
5112	>	# Use the module made above
5113	>	echo "$as_me:$LINENO: checking for module directory path flag" >&5
5114	>	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5115	>	rm -f conftest*
5116	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117	>	rm -f work*
5118	>	cat >conftest.$ac_ext <<EOF
5119	>	module conftest
5120	>	integer n
5121	>	parameter (n=1)
5122	>	end module conftest
5123	>	EOF
5124	>	# SGI and absoft compilers generates module name in upper case!
5125	>	testname="conftest"
5126	>	if (eval $ac_compile) 2>/dev/null ; then
5127	>	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128	>	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129	>	if test -n "$mod" ; then
5130	>	testname="CONFTEST"
5131	>	fi
5132	>	madedir=0
5133	>	if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134	>	cp $testname.$MOD conf
5135	>	rm -f conftest* CONFTEST*
5136	>	cat >conftest1.$ac_ext <<EOF
5137	>	program main
5138	>	use conftest
5139	>	print *, n
5140	>	end
5141	>	EOF
5142	>	F90_WORK_FILES_ARG=""
5143	>	F90MODINCSPEC=""
5144	>	if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145	>	MODDIRFLAG="-I"
5146	>	F90MODINCSPEC="-I<dir>"
5147	>	echo "$as_me:$LINENO: result: -I" >&5
5148	>	echo "${ECHO_T}-I" >&6
5149	>	elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150	>	MODDIRFLAG="-M"
5151	>	F90MODINCSPEC="-M<dir>"
5152	>	echo "$as_me:$LINENO: result: -M" >&5
5153	>	echo "${ECHO_T}-M" >&6
5154	>	elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155	>	MODDIRFLAG="-p"
5156	>	F90MODINCSPEC="-p<dir>"
5157	>	echo "$as_me:$LINENO: result: -p" >&5
5158	>	echo "${ECHO_T}-p" >&6
5159	>	elif test -s work.pc ; then
5160	>	cp work.pc conf/mpimod.pc
5161	>	echo "mpimod.pc" > conf/mpimod.pcl
5162	>	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163	>	if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164	>	MODDIRFLAG='-cl,mpimod.pcl'
5165	>	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166	>	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5167	>	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5168	>	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5169	>
5170	>	else
5171	>	# The version of the Intel compiler that I have refuses to let
5172	>	# you put the "work catalog" list anywhere but the current
5173	>	# directory. For example, you cannot in
5174	>	:
5175	>	fi
5176	>	fi
5177	>	if test -z "MODDIRFLAG" ; then
5178	>	echo "$as_me:$LINENO: result: unknown" >&5
5179	>	echo "${ECHO_T}unknown" >&6
5180	>	fi
5181	>
5182	>
5183	>	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5184	>	if test $madedir = 1 ; then rmdir conf ; fi
5185	>	fi
5186	>
5187	>
5188	>	echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5189	>	echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5190	>	if test "${ac_cv_f90_module_names+set}" = set; then
5191	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5192	>	else
5193	>	ac_ext=${FC_SRCEXT-f}
5194	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197	>
5198	>	# carry out the test in a new directory, so that we don't miss anything
5199	>	mkdir conftest
5200	>	cd conftest
5201	>	cat >conftest.$ac_ext <<_ACEOF
5202	>	MODULE Bar
5203	>	END MODULE Bar
5204	>	_ACEOF
5205	>	rm -f conftest.$ac_objext
5206	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5207	>	(eval $ac_compile) 2>conftest.er1
5208	>	ac_status=$?
5209	>	grep -v '^ *+' conftest.er1 >conftest.err
5210	>	rm -f conftest.er1
5211	>	cat conftest.err >&5
5212	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213	>	(exit $ac_status); } &&
5214	>	{ ac_try='test -z "$ac_fc_werror_flag"
5215	>	|| test ! -s conftest.err'
5216	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217	>	(eval $ac_try) 2>&5
5218	>	ac_status=$?
5219	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5220	>	(exit $ac_status); }; } &&
5221	>	{ ac_try='test -s conftest.$ac_objext'
5222	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5223	>	(eval $ac_try) 2>&5
5224	>	ac_status=$?
5225	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5226	>	(exit $ac_status); }; }; then
5227	>	ac_cv_f90_module_names=
5228	>	ac_file_list=*
5229	>	for ac_file in $ac_file_list; do
5230	>	case $ac_file in
5231	>	# don't care for original source and object files
5232	>	conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5233	>	:
5234	>	;;
5235	>	# look for new files derived from the file name
5236	>	*conftest*)
5237	>	ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5238	>	ac_exists=false
5239	>	for ac_i in $ac_cv_f90_module_names; do
5240	>	if test x"$ac_pat" = x"$ac_i"; then
5241	>	ac_exists=true
5242	>	break
5243	>	fi
5244	>	done
5245	>
5246	>	if test x"$ac_exists" = xtrue; then
5247	>	:
5248	>	else
5249	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5250	>	fi
5251	>
5252	>	;;
5253	>	# look for new files derived from the module name,
5254	>	# with different case translation schemes
5255	>	*Bar*)
5256	>	ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5257	>	ac_exists=false
5258	>	for ac_i in $ac_cv_f90_module_names; do
5259	>	if test x"$ac_pat" = x"$ac_i"; then
5260	>	ac_exists=true
5261	>	break
5262	>	fi
5263	>	done
5264	>
5265	>	if test x"$ac_exists" = xtrue; then
5266	>	:
5267	>	else
5268	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5269	>	fi
5270	>
5271	>	;;
5272	>	*bar*)
5273	>	ac_pat=`echo $ac_file | sed s/bar/%module%/`
5274	>	ac_exists=false
5275	>	for ac_i in $ac_cv_f90_module_names; do
5276	>	if test x"$ac_pat" = x"$ac_i"; then
5277	>	ac_exists=true
5278	>	break
5279	>	fi
5280	>	done
5281	>
5282	>	if test x"$ac_exists" = xtrue; then
5283	>	:
5284	>	else
5285	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5286	>	fi
5287	>
5288	>	;;
5289	>	*BAR*)
5290	>	ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5291	>	ac_exists=false
5292	>	for ac_i in $ac_cv_f90_module_names; do
5293	>	if test x"$ac_pat" = x"$ac_i"; then
5294	>	ac_exists=true
5295	>	break
5296	>	fi
5297	>	done
5298	>
5299	>	if test x"$ac_exists" = xtrue; then
5300	>	:
5301	>	else
5302	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5303	>	fi
5304	>
5305	>	;;
5306	>	# Other files - we have no idea how they are generated
5307	>	*)
5308	>	{ echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5309	>	echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5310	>	;;
5311	>	esac
5312	>	done
5313	>	if test "x$ac_cv_f90_module_names" = "x"; then
5314	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5315	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5316	>	fi
5317	>
5318	>	else
5319	>	echo "$as_me: failed program was:" >&5
5320	>	sed 's/^/| /' conftest.$ac_ext >&5
5321	>
5322	>	ac_cv_f90_module_names=
5323	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5324	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5325	>	fi
5326	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5327	>	cd ..
5328	>	# cleanup
5329	>	rm -rf conftest
5330	>	ac_ext=${FC_SRCEXT-f}
5331	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334	>
5335	>	fi
5336	>	echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5337	>	echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5338	>
5339	>	# We now generate a shell script that will help us to figure out the correct
5340	>	# module file names, using the value of ac_cv_f90_module_names
5341	>
5342	>	echo "Generating shell script modnam"
5343	>
5344	>	cat > scripts/modnam << EOF
5345	>	#! /bin/sh
5346	>	# This script is auto-generated by configure
5347	>	#
5348	>	usage="\\
5349	>	Usage: \$0 [FILES]
5350	>
5351	>	[FILES] are Fortran 90 source files.
5352	>	The output is a list of module file names that the Fortran 90 compiler
5353	>	generates when compiling [FILES]."
5354	>
5355	>	list=
5356	>	empty=
5357	>
5358	>	if test \$# -eq 0; then
5359	>	echo "\$usage"; exit 0
5360	>	fi
5361	>
5362	>	while test \$# != 0; do
5363	>
5364	>	file=\$1
5365	>	shift
5366	>
5367	>	# strip suffix
5368	>	base=\`echo \$file | sed 's/[.][^.]*$//'\`
5369	>
5370	>	test ! -f \$file && continue
5371	>
5372	>	# Look for module definitions and transform them to upper / lower case
5373	>	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/'\`
5374	>	upper=\`echo \$mods | tr a-z A-Z\`
5375	>	lower=\`echo \$mods | tr A-Z a-z\`
5376	>
5377	>	# Here, the patterns for generating module file names were inserted by configure
5378	>	for trans in $ac_cv_f90_module_names; do
5379	>
5380	>	pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5381	>	var=empty
5382	>	case \$pat in
5383	>	%MODULE%)
5384	>	var=upper ;;
5385	>	%Module%)
5386	>	var=mods ;;
5387	>	%module%)
5388	>	var=lower ;;
5389	>	%FILE%)
5390	>	test -n "\$mods" && var=base ;;
5391	>	esac
5392	>	new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5393	>	list="\$list \$new"
5394	>	done
5395	>	done
5396	>
5397	>	echo \$list
5398	>	# end of configure-generated script
5399	>	EOF
5400	>	chmod 755 scripts/modnam
5401	>
5402	>	pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5403	>	F90_MODULE_NAMES=empty
5404	>	case $pat in
5405	>	%MODULE%)
5406	>	F90_MODULE_NAMES=UPPER ;;
5407	>	%Module%)
5408	>	F90_MODULE_NAMES=Mixed ;;
5409	>	%module%)
5410	>	F90_MODULE_NAMES=lower ;;
5411	>	*)
5412	>	F90_MODULE_NAMES=unknown ;;
5413	>	esac
5414	>
5415	>	ac_ext=c
5416	>	ac_cpp='$CPP $CPPFLAGS'
5417	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5418	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5419	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420	>
5421	>
5422	>	ac_ext=c
5423	>	ac_cpp='$CPP $CPPFLAGS'
5424	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427	>
5428	>
5429	>
5430	>	echo "$as_me:$LINENO: checking for asin in -lm" >&5
5431	>	echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5432	>	if test "${ac_cv_lib_m_asin+set}" = set; then
5433	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5434	>	else
5435	>	ac_check_lib_save_LIBS=$LIBS
5436	>	LIBS="-lm  $LIBS"
5437	>	cat >conftest.$ac_ext <<_ACEOF
5438	>	/* confdefs.h.  */
5439	>	_ACEOF
5440	>	cat confdefs.h >>conftest.$ac_ext
5441	>	cat >>conftest.$ac_ext <<_ACEOF
5442	>	/* end confdefs.h.  */
5443	>
5444	>	/* Override any gcc2 internal prototype to avoid an error.  */
5445	>	#ifdef __cplusplus
5446	>	extern "C"
5447	>	#endif
5448	>	/* We use char because int might match the return type of a gcc2
5449	>	builtin and then its argument prototype would still apply.  */
5450	>	char asin ();
5451	>	#ifdef FC_DUMMY_MAIN
5452	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5453	>	#  ifdef __cplusplus
5454	>	extern "C"
5455	>	#  endif
5456	>	int FC_DUMMY_MAIN() { return 1; }
5457	>	#endif
5458	>	#endif
5459	>	int
5460	>	main ()
5461	>	{
5462	>	asin ();
5463	>	;
5464	>	return 0;
5465	>	}
5466	>	_ACEOF
5467	>	rm -f conftest.$ac_objext conftest$ac_exeext
5468	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5469	>	(eval $ac_link) 2>conftest.er1
5470	>	ac_status=$?
5471	>	grep -v '^ *+' conftest.er1 >conftest.err
5472	>	rm -f conftest.er1
5473	>	cat conftest.err >&5
5474	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475	>	(exit $ac_status); } &&
5476	>	{ ac_try='test -z "$ac_c_werror_flag"
5477	>	|| test ! -s conftest.err'
5478	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479	>	(eval $ac_try) 2>&5
5480	>	ac_status=$?
5481	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482	>	(exit $ac_status); }; } &&
5483	>	{ ac_try='test -s conftest$ac_exeext'
5484	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5485	>	(eval $ac_try) 2>&5
5486	>	ac_status=$?
5487	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5488	>	(exit $ac_status); }; }; then
5489	>	ac_cv_lib_m_asin=yes
5490	>	else
5491	>	echo "$as_me: failed program was:" >&5
5492	>	sed 's/^/| /' conftest.$ac_ext >&5
5493	>
5494	>	ac_cv_lib_m_asin=no
5495	>	fi
5496	>	rm -f conftest.err conftest.$ac_objext \
5497	>	conftest$ac_exeext conftest.$ac_ext
5498	>	LIBS=$ac_check_lib_save_LIBS
5499	>	fi
5500	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5501	>	echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5502	>	if test $ac_cv_lib_m_asin = yes; then
5503	>	cat >>confdefs.h <<_ACEOF
5504	>	#define HAVE_LIBM 1
5505	>	_ACEOF
5506	>
5507	>	LIBS="-lm $LIBS"
5508	>
5509	>	else
5510	>	exit
5511	>	fi
5512	>
5513	>
5514	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5515	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5516	>	if test "${ac_cv_header_stdc+set}" = set; then
5517	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5518	>	else
5519	>	cat >conftest.$ac_ext <<_ACEOF
5520	>	/* confdefs.h.  */
5521	>	_ACEOF
5522	>	cat confdefs.h >>conftest.$ac_ext
5523	>	cat >>conftest.$ac_ext <<_ACEOF
5524	>	/* end confdefs.h.  */
5525	>	#include <stdlib.h>
5526	>	#include <stdarg.h>
5527	>	#include <string.h>
5528	>	#include <float.h>
5529	>
5530	>	#ifdef FC_DUMMY_MAIN
5531	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5532	>	#  ifdef __cplusplus
5533	>	extern "C"
5534	>	#  endif
5535	>	int FC_DUMMY_MAIN() { return 1; }
5536	>	#endif
5537	>	#endif
5538	>	int
5539	>	main ()
5540	>	{
5541	>
5542	>	;
5543	>	return 0;
5544	>	}
5545	>	_ACEOF
5546	>	rm -f conftest.$ac_objext
5547	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5548	>	(eval $ac_compile) 2>conftest.er1
5549	>	ac_status=$?
5550	>	grep -v '^ *+' conftest.er1 >conftest.err
5551	>	rm -f conftest.er1
5552	>	cat conftest.err >&5
5553	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554	>	(exit $ac_status); } &&
5555	>	{ ac_try='test -z "$ac_c_werror_flag"
5556	>	|| test ! -s conftest.err'
5557	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5558	>	(eval $ac_try) 2>&5
5559	>	ac_status=$?
5560	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5561	>	(exit $ac_status); }; } &&
5562	>	{ ac_try='test -s conftest.$ac_objext'
5563	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5564	>	(eval $ac_try) 2>&5
5565	>	ac_status=$?
5566	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5567	>	(exit $ac_status); }; }; then
5568	>	ac_cv_header_stdc=yes
5569	>	else
5570	>	echo "$as_me: failed program was:" >&5
5571	>	sed 's/^/| /' conftest.$ac_ext >&5
5572	>
5573	>	ac_cv_header_stdc=no
5574	>	fi
5575	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5576	>
5577	>	if test $ac_cv_header_stdc = yes; then
5578	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5579	>	cat >conftest.$ac_ext <<_ACEOF
5580	>	/* confdefs.h.  */
5581	>	_ACEOF
5582	>	cat confdefs.h >>conftest.$ac_ext
5583	>	cat >>conftest.$ac_ext <<_ACEOF
5584	>	/* end confdefs.h.  */
5585	>	#include <string.h>
5586	>
5587	>	_ACEOF
5588	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5589	>	$EGREP "memchr" >/dev/null 2>&1; then
5590	>	:
5591	>	else
5592	>	ac_cv_header_stdc=no
5593	>	fi
5594	>	rm -f conftest*
5595	>
5596	>	fi
5597	>
5598	>	if test $ac_cv_header_stdc = yes; then
5599	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5600	>	cat >conftest.$ac_ext <<_ACEOF
5601	>	/* confdefs.h.  */
5602	>	_ACEOF
5603	>	cat confdefs.h >>conftest.$ac_ext
5604	>	cat >>conftest.$ac_ext <<_ACEOF
5605	>	/* end confdefs.h.  */
5606	>	#include <stdlib.h>
5607	>
5608	>	_ACEOF
5609	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5610	>	$EGREP "free" >/dev/null 2>&1; then
5611	>	:
5612	>	else
5613	>	ac_cv_header_stdc=no
5614	>	fi
5615	>	rm -f conftest*
5616	>
5617	>	fi
5618	>
5619	>	if test $ac_cv_header_stdc = yes; then
5620	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5621	>	if test "$cross_compiling" = yes; then
5622	>	:
5623	>	else
5624	>	cat >conftest.$ac_ext <<_ACEOF
5625	>	/* confdefs.h.  */
5626	>	_ACEOF
5627	>	cat confdefs.h >>conftest.$ac_ext
5628	>	cat >>conftest.$ac_ext <<_ACEOF
5629	>	/* end confdefs.h.  */
5630	>	#include <ctype.h>
5631	>	#if ((' ' & 0x0FF) == 0x020)
5632	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5633	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5634	>	#else
5635	>	# define ISLOWER(c) \
5636	>	(('a' <= (c) && (c) <= 'i') \
5637	>	|| ('j' <= (c) && (c) <= 'r') \
5638	>	|| ('s' <= (c) && (c) <= 'z'))
5639	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5640	>	#endif
5641	>
5642	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5643	>	int
5644	>	main ()
5645	>	{
5646	>	int i;
5647	>	for (i = 0; i < 256; i++)
5648	>	if (XOR (islower (i), ISLOWER (i))
5649	>	|| toupper (i) != TOUPPER (i))
5650	>	exit(2);
5651	>	exit (0);
5652	>	}
5653	>	_ACEOF
5654	>	rm -f conftest$ac_exeext
5655	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5656	>	(eval $ac_link) 2>&5
5657	>	ac_status=$?
5658	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5659	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5660	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5661	>	(eval $ac_try) 2>&5
5662	>	ac_status=$?
5663	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5664	>	(exit $ac_status); }; }; then
5665	>	:
5666	>	else
5667	>	echo "$as_me: program exited with status $ac_status" >&5
5668	>	echo "$as_me: failed program was:" >&5
5669	>	sed 's/^/| /' conftest.$ac_ext >&5
5670	>
5671	>	( exit $ac_status )
5672	>	ac_cv_header_stdc=no
5673	>	fi
5674	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5675	>	fi
5676	>	fi
5677	>	fi
5678	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5679	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
5680	>	if test $ac_cv_header_stdc = yes; then
5681	>
5682	>	cat >>confdefs.h <<\_ACEOF
5683	>	#define STDC_HEADERS 1
5684	>	_ACEOF
5685	>
5686	>	fi
5687	>
5688	>	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
5689	>
5690	>
5691	>
5692	>
5693	>
5694	>
5695	>
5696	>
5697	>
5698	>	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5699	>	inttypes.h stdint.h unistd.h
5700	>	do
5701	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5702	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
5703	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5704	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5705	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5706	>	else
5707	>	cat >conftest.$ac_ext <<_ACEOF
5708	>	/* confdefs.h.  */
5709	>	_ACEOF
5710	>	cat confdefs.h >>conftest.$ac_ext
5711	>	cat >>conftest.$ac_ext <<_ACEOF
5712	>	/* end confdefs.h.  */
5713	>	$ac_includes_default
5714	>
5715	>	#include <$ac_header>
5716	>	_ACEOF
5717	>	rm -f conftest.$ac_objext
5718	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5719	>	(eval $ac_compile) 2>conftest.er1
5720	>	ac_status=$?
5721	>	grep -v '^ *+' conftest.er1 >conftest.err
5722	>	rm -f conftest.er1
5723	>	cat conftest.err >&5
5724	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725	>	(exit $ac_status); } &&
5726	>	{ ac_try='test -z "$ac_c_werror_flag"
5727	>	|| test ! -s conftest.err'
5728	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5729	>	(eval $ac_try) 2>&5
5730	>	ac_status=$?
5731	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732	>	(exit $ac_status); }; } &&
5733	>	{ ac_try='test -s conftest.$ac_objext'
5734	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5735	>	(eval $ac_try) 2>&5
5736	>	ac_status=$?
5737	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5738	>	(exit $ac_status); }; }; then
5739	>	eval "$as_ac_Header=yes"
5740	>	else
5741	>	echo "$as_me: failed program was:" >&5
5742	>	sed 's/^/| /' conftest.$ac_ext >&5
5743	>
5744	>	eval "$as_ac_Header=no"
5745	>	fi
5746	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5747	>	fi
5748	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5749	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5750	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5751	>	cat >>confdefs.h <<_ACEOF
5752	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5753	>	_ACEOF
5754	>
5755	>	fi
5756	>
5757	>	done
5758	>
5759	>
5760	>	#
5761	>	# Handle user hints
5762	>	#
5763	>	echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5764	>	echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5765	>
5766	>	# Check whether --with-zlib or --without-zlib was given.
5767	>	if test "${with_zlib+set}" = set; then
5768	>	withval="$with_zlib"
5769	>	if test "$withval" != no ; then
5770	>	echo "$as_me:$LINENO: result: yes" >&5
5771	>	echo "${ECHO_T}yes" >&6
5772	>	if test -d "$withval"
5773	>	then
5774	>	ZLIB_HOME="$withval"
5775	>	else
5776	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5777	>	echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5778	>	fi
5779	>	else
5780	>	echo "$as_me:$LINENO: result: no" >&5
5781	>	echo "${ECHO_T}no" >&6
5782	>	fi
5783	>	fi;
5784	>
5785	>	ZLIB_HOME=/usr/local
5786	>	if test ! -f "${ZLIB_HOME}/include/zlib.h"
5787	>	then
5788	>	ZLIB_HOME=/usr
5789	>	fi
5790	>
5791	>	#
5792	>	# Locate zlib, if wanted
5793	>	#
5794	>	if test -n "${ZLIB_HOME}"
5795	>	then
5796	>	ZLIB_OLD_LDFLAGS=$LDFLAGS
5797	>	ZLIB_OLD_CPPFLAGS=$LDFLAGS
5798	>	LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5799	>	CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5800	>
5801	>
5802	>	ac_ext=c
5803	>	ac_cpp='$CPP $CPPFLAGS'
5804	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5805	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5806	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5807	>
5808	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5809	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5810	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5811	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5812	>	else
5813	>	ac_check_lib_save_LIBS=$LIBS
5814	>	LIBS="-lz  $LIBS"
5815	>	cat >conftest.$ac_ext <<_ACEOF
5816	>	/* confdefs.h.  */
5817	>	_ACEOF
5818	>	cat confdefs.h >>conftest.$ac_ext
5819	>	cat >>conftest.$ac_ext <<_ACEOF
5820	>	/* end confdefs.h.  */
5821	>
5822	>	/* Override any gcc2 internal prototype to avoid an error.  */
5823	>	#ifdef __cplusplus
5824	>	extern "C"
5825	>	#endif
5826	>	/* We use char because int might match the return type of a gcc2
5827	>	builtin and then its argument prototype would still apply.  */
5828	>	char inflateEnd ();
5829	>	#ifdef FC_DUMMY_MAIN
5830	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5831	>	#  ifdef __cplusplus
5832	>	extern "C"
5833	>	#  endif
5834	>	int FC_DUMMY_MAIN() { return 1; }
5835	>	#endif
5836	>	#endif
5837	>	int
5838	>	main ()
5839	>	{
5840	>	inflateEnd ();
5841	>	;
5842	>	return 0;
5843	>	}
5844	>	_ACEOF
5845	>	rm -f conftest.$ac_objext conftest$ac_exeext
5846	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847	>	(eval $ac_link) 2>conftest.er1
5848	>	ac_status=$?
5849	>	grep -v '^ *+' conftest.er1 >conftest.err
5850	>	rm -f conftest.er1
5851	>	cat conftest.err >&5
5852	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853	>	(exit $ac_status); } &&
5854	>	{ ac_try='test -z "$ac_c_werror_flag"
5855	>	|| test ! -s conftest.err'
5856	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857	>	(eval $ac_try) 2>&5
5858	>	ac_status=$?
5859	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860	>	(exit $ac_status); }; } &&
5861	>	{ ac_try='test -s conftest$ac_exeext'
5862	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863	>	(eval $ac_try) 2>&5
5864	>	ac_status=$?
5865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866	>	(exit $ac_status); }; }; then
5867	>	ac_cv_lib_z_inflateEnd=yes
5868	>	else
5869	>	echo "$as_me: failed program was:" >&5
5870	>	sed 's/^/| /' conftest.$ac_ext >&5
5871	>
5872	>	ac_cv_lib_z_inflateEnd=no
5873	>	fi
5874	>	rm -f conftest.err conftest.$ac_objext \
5875	>	conftest$ac_exeext conftest.$ac_ext
5876	>	LIBS=$ac_check_lib_save_LIBS
5877	>	fi
5878	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880	>	if test $ac_cv_lib_z_inflateEnd = yes; then
5881	>	zlib_cv_libz=yes
5882	>	else
5883	>	zlib_cv_libz=no
5884	>	fi
5885	>
5886	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5887	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
5888	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5890	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5891	>	fi
5892	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894	>	else
5895	>	# Is the header compilable?
5896	>	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897	>	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898	>	cat >conftest.$ac_ext <<_ACEOF
5899	>	/* confdefs.h.  */
5900	>	_ACEOF
5901	>	cat confdefs.h >>conftest.$ac_ext
5902	>	cat >>conftest.$ac_ext <<_ACEOF
5903	>	/* end confdefs.h.  */
5904	>	$ac_includes_default
5905	>	#include <zlib.h>
5906	>	_ACEOF
5907	>	rm -f conftest.$ac_objext
5908	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5909	>	(eval $ac_compile) 2>conftest.er1
5910	>	ac_status=$?
5911	>	grep -v '^ *+' conftest.er1 >conftest.err
5912	>	rm -f conftest.er1
5913	>	cat conftest.err >&5
5914	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915	>	(exit $ac_status); } &&
5916	>	{ ac_try='test -z "$ac_c_werror_flag"
5917	>	|| test ! -s conftest.err'
5918	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919	>	(eval $ac_try) 2>&5
5920	>	ac_status=$?
5921	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5922	>	(exit $ac_status); }; } &&
5923	>	{ ac_try='test -s conftest.$ac_objext'
5924	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5925	>	(eval $ac_try) 2>&5
5926	>	ac_status=$?
5927	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5928	>	(exit $ac_status); }; }; then
5929	>	ac_header_compiler=yes
5930	>	else
5931	>	echo "$as_me: failed program was:" >&5
5932	>	sed 's/^/| /' conftest.$ac_ext >&5
5933	>
5934	>	ac_header_compiler=no
5935	>	fi
5936	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5937	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5938	>	echo "${ECHO_T}$ac_header_compiler" >&6
5939	>
5940	>	# Is the header present?
5941	>	echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942	>	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943	>	cat >conftest.$ac_ext <<_ACEOF
5944	>	/* confdefs.h.  */
5945	>	_ACEOF
5946	>	cat confdefs.h >>conftest.$ac_ext
5947	>	cat >>conftest.$ac_ext <<_ACEOF
5948	>	/* end confdefs.h.  */
5949	>	#include <zlib.h>
5950	>	_ACEOF
5951	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5953	>	ac_status=$?
5954	>	grep -v '^ *+' conftest.er1 >conftest.err
5955	>	rm -f conftest.er1
5956	>	cat conftest.err >&5
5957	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958	>	(exit $ac_status); } >/dev/null; then
5959	>	if test -s conftest.err; then
5960	>	ac_cpp_err=$ac_c_preproc_warn_flag
5961	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962	>	else
5963	>	ac_cpp_err=
5964	>	fi
5965	>	else
5966	>	ac_cpp_err=yes
5967	>	fi
5968	>	if test -z "$ac_cpp_err"; then
5969	>	ac_header_preproc=yes
5970	>	else
5971	>	echo "$as_me: failed program was:" >&5
5972	>	sed 's/^/| /' conftest.$ac_ext >&5
5973	>
5974	>	ac_header_preproc=no
5975	>	fi
5976	>	rm -f conftest.err conftest.$ac_ext
5977	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5978	>	echo "${ECHO_T}$ac_header_preproc" >&6
5979	>
5980	>	# So?  What about this header?
5981	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982	>	yes:no: )
5983	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984	>	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986	>	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987	>	ac_header_preproc=yes
5988	>	;;
5989	>	no:yes:* )
5990	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991	>	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993	>	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995	>	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997	>	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999	>	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001	>	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002	>	(
6003	>	cat <<\_ASBOX
6004	>	## ------------------------------ ##
6005	>	## Report this to gezelter@nd.edu ##
6006	>	## ------------------------------ ##
6007	>	_ASBOX
6008	>	) |
6009	>	sed "s/^/$as_me: WARNING:     /" >&2
6010	>	;;
6011	>	esac
6012	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6013	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6015	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6016	>	else
6017	>	ac_cv_header_zlib_h=$ac_header_preproc
6018	>	fi
6019	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021	>
6022	>	fi
6023	>	if test $ac_cv_header_zlib_h = yes; then
6024	>	zlib_cv_zlib_h=yes
6025	>	else
6026	>	zlib_cv_zlib_h=no
6027	>	fi
6028	>
6029	>
6030	>	ac_ext=c
6031	>	ac_cpp='$CPP $CPPFLAGS'
6032	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035	>
6036	>	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037	>	then
6038	>	#
6039	>	# If both library and header were found, use them
6040	>	#
6041	>
6042	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6046	>	else
6047	>	ac_check_lib_save_LIBS=$LIBS
6048	>	LIBS="-lz  $LIBS"
6049	>	cat >conftest.$ac_ext <<_ACEOF
6050	>	/* confdefs.h.  */
6051	>	_ACEOF
6052	>	cat confdefs.h >>conftest.$ac_ext
6053	>	cat >>conftest.$ac_ext <<_ACEOF
6054	>	/* end confdefs.h.  */
6055	>
6056	>	/* Override any gcc2 internal prototype to avoid an error.  */
6057	>	#ifdef __cplusplus
6058	>	extern "C"
6059	>	#endif
6060	>	/* We use char because int might match the return type of a gcc2
6061	>	builtin and then its argument prototype would still apply.  */
6062	>	char inflateEnd ();
6063	>	#ifdef FC_DUMMY_MAIN
6064	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6065	>	#  ifdef __cplusplus
6066	>	extern "C"
6067	>	#  endif
6068	>	int FC_DUMMY_MAIN() { return 1; }
6069	>	#endif
6070	>	#endif
6071	>	int
6072	>	main ()
6073	>	{
6074	>	inflateEnd ();
6075	>	;
6076	>	return 0;
6077	>	}
6078	>	_ACEOF
6079	>	rm -f conftest.$ac_objext conftest$ac_exeext
6080	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081	>	(eval $ac_link) 2>conftest.er1
6082	>	ac_status=$?
6083	>	grep -v '^ *+' conftest.er1 >conftest.err
6084	>	rm -f conftest.er1
6085	>	cat conftest.err >&5
6086	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087	>	(exit $ac_status); } &&
6088	>	{ ac_try='test -z "$ac_c_werror_flag"
6089	>	|| test ! -s conftest.err'
6090	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091	>	(eval $ac_try) 2>&5
6092	>	ac_status=$?
6093	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094	>	(exit $ac_status); }; } &&
6095	>	{ ac_try='test -s conftest$ac_exeext'
6096	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097	>	(eval $ac_try) 2>&5
6098	>	ac_status=$?
6099	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100	>	(exit $ac_status); }; }; then
6101	>	ac_cv_lib_z_inflateEnd=yes
6102	>	else
6103	>	echo "$as_me: failed program was:" >&5
6104	>	sed 's/^/| /' conftest.$ac_ext >&5
6105	>
6106	>	ac_cv_lib_z_inflateEnd=no
6107	>	fi
6108	>	rm -f conftest.err conftest.$ac_objext \
6109	>	conftest$ac_exeext conftest.$ac_ext
6110	>	LIBS=$ac_check_lib_save_LIBS
6111	>	fi
6112	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114	>	if test $ac_cv_lib_z_inflateEnd = yes; then
6115	>	cat >>confdefs.h <<_ACEOF
6116	>	#define HAVE_LIBZ 1
6117	>	_ACEOF
6118	>
6119	>	LIBS="-lz $LIBS"
6120	>
6121	>	fi
6122	>
6123	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125	>	echo "$as_me:$LINENO: result: ok" >&5
6126	>	echo "${ECHO_T}ok" >&6
6127	>	else
6128	>	#
6129	>	# If either header or library was not found, revert and bomb
6130	>	#
6131	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133	>	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134	>	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135	>	echo "$as_me:$LINENO: result: failed" >&5
6136	>	echo "${ECHO_T}failed" >&6
6137	>	{ { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138	>	echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139	>	{ (exit 1); exit 1; }; }
6140	>	fi
6141	>	fi
6142	>
6143	>
6144	>
6145	>	# Check whether --with-fftw or --without-fftw was given.
6146	>	if test "${with_fftw+set}" = set; then
6147	>	withval="$with_fftw"
6148	>
6149	>	else
6150	>	with_fftw=yes
6151	>	fi;
6152	>	if test "$with_fftw" = "no"; then
6153	>
6154	>	cat >>confdefs.h <<\_ACEOF
6155	>	#define WITHOUT_FFTW
6156	>	_ACEOF
6157	>
6158	>	fi
6159	>	if test "$with_fftw" = "yes"; then
6160	>	sizeof_real=8
6161	>
6162	>
6163	>	if test -z "$ac_fftw_firstname"; then
6164	>
6165	>	sizeof_real=$sizeof_real
6166	>	if test $sizeof_real = 8; then
6167	>	prec="double"
6168	>	fftwcheckprefix=d
6169	>	else
6170	>	prec="single"
6171	>	fftwcheckprefix=s
6172	>	fi
6173	>
6174	>	xfftwname=${fftwcheckprefix}fftw3
6175	>
6176	>	ok="no"
6177	>	# check header doesn't work, since we must use mpicc to get includes,
6178	>	# we cant trust cpp.
6179	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181	>	cat >conftest.$ac_ext <<_ACEOF
6182	>	/* confdefs.h.  */
6183	>	_ACEOF
6184	>	cat confdefs.h >>conftest.$ac_ext
6185	>	cat >>conftest.$ac_ext <<_ACEOF
6186	>	/* end confdefs.h.  */
6187	>	#include <$xfftwname.h>
6188	>	#ifdef FC_DUMMY_MAIN
6189	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6190	>	#  ifdef __cplusplus
6191	>	extern "C"
6192	>	#  endif
6193	>	int FC_DUMMY_MAIN() { return 1; }
6194	>	#endif
6195	>	#endif
6196	>	int
6197	>	main ()
6198	>	{
6199	>
6200	>	;
6201	>	return 0;
6202	>	}
6203	>	_ACEOF
6204	>	rm -f conftest.$ac_objext
6205	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206	>	(eval $ac_compile) 2>conftest.er1
6207	>	ac_status=$?
6208	>	grep -v '^ *+' conftest.er1 >conftest.err
6209	>	rm -f conftest.er1
6210	>	cat conftest.err >&5
6211	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212	>	(exit $ac_status); } &&
6213	>	{ ac_try='test -z "$ac_c_werror_flag"
6214	>	|| test ! -s conftest.err'
6215	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216	>	(eval $ac_try) 2>&5
6217	>	ac_status=$?
6218	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6219	>	(exit $ac_status); }; } &&
6220	>	{ ac_try='test -s conftest.$ac_objext'
6221	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6222	>	(eval $ac_try) 2>&5
6223	>	ac_status=$?
6224	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225	>	(exit $ac_status); }; }; then
6226	>
6227	>	fftwname=$xfftwname
6228	>	echo "$as_me:$LINENO: result: yes" >&5
6229	>	echo "${ECHO_T}yes" >&6
6230	>
6231	>	else
6232	>	echo "$as_me: failed program was:" >&5
6233	>	sed 's/^/| /' conftest.$ac_ext >&5
6234	>
6235	>	echo "$as_me:$LINENO: result: no" >&5
6236	>	echo "${ECHO_T}no" >&6
6237	>	fi
6238	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6239	>
6240	>	# fftwname was set if we found a header
6241	>
6242	>	if test -n "$fftwname"; then
6243	>	# we cannot run the code since an MPI program might not be allowed
6244	>	# on a login node of a supercomputer
6245	>	cat >conftest.$ac_ext <<_ACEOF
6246	>	/* confdefs.h.  */
6247	>	_ACEOF
6248	>	cat confdefs.h >>conftest.$ac_ext
6249	>	cat >>conftest.$ac_ext <<_ACEOF
6250	>	/* end confdefs.h.  */
6251	>	#include <$fftwname.h>
6252	>	#ifdef FC_DUMMY_MAIN
6253	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6254	>	#  ifdef __cplusplus
6255	>	extern "C"
6256	>	#  endif
6257	>	int FC_DUMMY_MAIN() { return 1; }
6258	>	#endif
6259	>	#endif
6260	>	int
6261	>	main ()
6262	>	{
6263	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264	>	;
6265	>	return 0;
6266	>	}
6267	>	_ACEOF
6268	>	rm -f conftest.$ac_objext
6269	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270	>	(eval $ac_compile) 2>conftest.er1
6271	>	ac_status=$?
6272	>	grep -v '^ *+' conftest.er1 >conftest.err
6273	>	rm -f conftest.er1
6274	>	cat conftest.err >&5
6275	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276	>	(exit $ac_status); } &&
6277	>	{ ac_try='test -z "$ac_c_werror_flag"
6278	>	|| test ! -s conftest.err'
6279	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280	>	(eval $ac_try) 2>&5
6281	>	ac_status=$?
6282	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283	>	(exit $ac_status); }; } &&
6284	>	{ ac_try='test -s conftest.$ac_objext'
6285	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286	>	(eval $ac_try) 2>&5
6287	>	ac_status=$?
6288	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289	>	(exit $ac_status); }; }; then
6290	>
6291	>	ok=yes
6292	>	usedprefix=$fftwcheckprefix
6293	>
6294	>	else
6295	>	echo "$as_me: failed program was:" >&5
6296	>	sed 's/^/| /' conftest.$ac_ext >&5
6297	>
6298	>	ok=no
6299	>	fi
6300	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301	>	fi
6302	>
6303	>	if test "$ok" != "yes"; then
6304	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306	>	cat >conftest.$ac_ext <<_ACEOF
6307	>	/* confdefs.h.  */
6308	>	_ACEOF
6309	>	cat confdefs.h >>conftest.$ac_ext
6310	>	cat >>conftest.$ac_ext <<_ACEOF
6311	>	/* end confdefs.h.  */
6312	>	#include <fftw3.h>
6313	>	#ifdef FC_DUMMY_MAIN
6314	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6315	>	#  ifdef __cplusplus
6316	>	extern "C"
6317	>	#  endif
6318	>	int FC_DUMMY_MAIN() { return 1; }
6319	>	#endif
6320	>	#endif
6321	>	int
6322	>	main ()
6323	>	{
6324	>
6325	>	;
6326	>	return 0;
6327	>	}
6328	>	_ACEOF
6329	>	rm -f conftest.$ac_objext
6330	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6331	>	(eval $ac_compile) 2>conftest.er1
6332	>	ac_status=$?
6333	>	grep -v '^ *+' conftest.er1 >conftest.err
6334	>	rm -f conftest.er1
6335	>	cat conftest.err >&5
6336	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337	>	(exit $ac_status); } &&
6338	>	{ ac_try='test -z "$ac_c_werror_flag"
6339	>	|| test ! -s conftest.err'
6340	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341	>	(eval $ac_try) 2>&5
6342	>	ac_status=$?
6343	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6344	>	(exit $ac_status); }; } &&
6345	>	{ ac_try='test -s conftest.$ac_objext'
6346	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6347	>	(eval $ac_try) 2>&5
6348	>	ac_status=$?
6349	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350	>	(exit $ac_status); }; }; then
6351	>	echo "$as_me:$LINENO: result: yes" >&5
6352	>	echo "${ECHO_T}yes" >&6
6353	>	else
6354	>	echo "$as_me: failed program was:" >&5
6355	>	sed 's/^/| /' conftest.$ac_ext >&5
6356	>
6357	>
6358	>	echo "$as_me:$LINENO: result: no" >&5
6359	>	echo "${ECHO_T}no" >&6
6360	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361	>	Do you have $prec precision FFTW installed? If you are using packages,
6362	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363	>	software at www.fftw.org.
6364	>	If you compiled FFTW yourself:
6365	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6366	>	use --with-mpi. It is a good idea to install both single & double.
6367	>	If you have installed FFTW in a non-standard location, you should
6368	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369	>	variables before running configure.
6370	>	That is also necessary to do if your compiler doesn't search
6371	>	/usr/local/include and /usr/local/lib by default." >&5
6372	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373	>	Do you have $prec precision FFTW installed? If you are using packages,
6374	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375	>	software at www.fftw.org.
6376	>	If you compiled FFTW yourself:
6377	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6378	>	use --with-mpi. It is a good idea to install both single & double.
6379	>	If you have installed FFTW in a non-standard location, you should
6380	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381	>	variables before running configure.
6382	>	That is also necessary to do if your compiler doesn't search
6383	>	/usr/local/include and /usr/local/lib by default." >&2;}
6384	>	{ (exit 1); exit 1; }; }
6385	>
6386	>	fi
6387	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6388	>	cat >conftest.$ac_ext <<_ACEOF
6389	>	/* confdefs.h.  */
6390	>	_ACEOF
6391	>	cat confdefs.h >>conftest.$ac_ext
6392	>	cat >>conftest.$ac_ext <<_ACEOF
6393	>	/* end confdefs.h.  */
6394	>	#include <fftw3.h>
6395	>	#ifdef FC_DUMMY_MAIN
6396	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6397	>	#  ifdef __cplusplus
6398	>	extern "C"
6399	>	#  endif
6400	>	int FC_DUMMY_MAIN() { return 1; }
6401	>	#endif
6402	>	#endif
6403	>	int
6404	>	main ()
6405	>	{
6406	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407	>	;
6408	>	return 0;
6409	>	}
6410	>	_ACEOF
6411	>	rm -f conftest.$ac_objext
6412	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413	>	(eval $ac_compile) 2>conftest.er1
6414	>	ac_status=$?
6415	>	grep -v '^ *+' conftest.er1 >conftest.err
6416	>	rm -f conftest.er1
6417	>	cat conftest.err >&5
6418	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419	>	(exit $ac_status); } &&
6420	>	{ ac_try='test -z "$ac_c_werror_flag"
6421	>	|| test ! -s conftest.err'
6422	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423	>	(eval $ac_try) 2>&5
6424	>	ac_status=$?
6425	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426	>	(exit $ac_status); }; } &&
6427	>	{ ac_try='test -s conftest.$ac_objext'
6428	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429	>	(eval $ac_try) 2>&5
6430	>	ac_status=$?
6431	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432	>	(exit $ac_status); }; }; then
6433	>
6434	>	usedprefix=""
6435	>	fftwname=fftw3
6436	>
6437	>	else
6438	>	echo "$as_me: failed program was:" >&5
6439	>	sed 's/^/| /' conftest.$ac_ext >&5
6440	>
6441	>
6442	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443	>	Do you have $prec precision FFTW installed? If you are using packages,
6444	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445	>	software at www.fftw.org.
6446	>	If you compiled FFTW yourself:
6447	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6448	>	use --with-mpi. It is a good idea to install both single & double.
6449	>	If you have installed FFTW in a non-standard location, you should
6450	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451	>	variables before running configure.
6452	>	That is also necessary to do if your compiler doesn't search
6453	>	/usr/local/include and /usr/local/lib by default." >&5
6454	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455	>	Do you have $prec precision FFTW installed? If you are using packages,
6456	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457	>	software at www.fftw.org.
6458	>	If you compiled FFTW yourself:
6459	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6460	>	use --with-mpi. It is a good idea to install both single & double.
6461	>	If you have installed FFTW in a non-standard location, you should
6462	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463	>	variables before running configure.
6464	>	That is also necessary to do if your compiler doesn't search
6465	>	/usr/local/include and /usr/local/lib by default." >&2;}
6466	>	{ (exit 1); exit 1; }; }
6467	>	fi
6468	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469	>	fi
6470	>
6471	>
6472	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6477	>	else
6478	>	ac_check_lib_save_LIBS=$LIBS
6479	>	LIBS="-l$fftwname  $LIBS"
6480	>	cat >conftest.$ac_ext <<_ACEOF
6481	>	/* confdefs.h.  */
6482	>	_ACEOF
6483	>	cat confdefs.h >>conftest.$ac_ext
6484	>	cat >>conftest.$ac_ext <<_ACEOF
6485	>	/* end confdefs.h.  */
6486	>
6487	>
6488	>	#ifdef FC_DUMMY_MAIN
6489	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6490	>	#  ifdef __cplusplus
6491	>	extern "C"
6492	>	#  endif
6493	>	int FC_DUMMY_MAIN() { return 1; }
6494	>	#endif
6495	>	#endif
6496	>	int
6497	>	main ()
6498	>	{
6499	>	main ();
6500	>	;
6501	>	return 0;
6502	>	}
6503	>	_ACEOF
6504	>	rm -f conftest.$ac_objext conftest$ac_exeext
6505	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506	>	(eval $ac_link) 2>conftest.er1
6507	>	ac_status=$?
6508	>	grep -v '^ *+' conftest.er1 >conftest.err
6509	>	rm -f conftest.er1
6510	>	cat conftest.err >&5
6511	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512	>	(exit $ac_status); } &&
6513	>	{ ac_try='test -z "$ac_c_werror_flag"
6514	>	|| test ! -s conftest.err'
6515	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516	>	(eval $ac_try) 2>&5
6517	>	ac_status=$?
6518	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519	>	(exit $ac_status); }; } &&
6520	>	{ ac_try='test -s conftest$ac_exeext'
6521	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522	>	(eval $ac_try) 2>&5
6523	>	ac_status=$?
6524	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525	>	(exit $ac_status); }; }; then
6526	>	eval "$as_ac_Lib=yes"
6527	>	else
6528	>	echo "$as_me: failed program was:" >&5
6529	>	sed 's/^/| /' conftest.$ac_ext >&5
6530	>
6531	>	eval "$as_ac_Lib=no"
6532	>	fi
6533	>	rm -f conftest.err conftest.$ac_objext \
6534	>	conftest$ac_exeext conftest.$ac_ext
6535	>	LIBS=$ac_check_lib_save_LIBS
6536	>	fi
6537	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540	>	cat >>confdefs.h <<_ACEOF
6541	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542	>	_ACEOF
6543	>
6544	>	LIBS="-l$fftwname $LIBS"
6545	>
6546	>	else
6547	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549	>	{ (exit 1); exit 1; }; }
6550	>	fi
6551	>
6552	>	ac_fftw_savedprefix=$usedprefix
6553	>	ac_fftw_firstname=$fftwname
6554	>
6555	>	else
6556	>
6557	>	fftwname=${ac_fftw_savedprefix}fftw3
6558	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560	>	cat >conftest.$ac_ext <<_ACEOF
6561	>	/* confdefs.h.  */
6562	>	_ACEOF
6563	>	cat confdefs.h >>conftest.$ac_ext
6564	>	cat >>conftest.$ac_ext <<_ACEOF
6565	>	/* end confdefs.h.  */
6566	>	#include <$fftwname.h>
6567	>	#ifdef FC_DUMMY_MAIN
6568	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6569	>	#  ifdef __cplusplus
6570	>	extern "C"
6571	>	#  endif
6572	>	int FC_DUMMY_MAIN() { return 1; }
6573	>	#endif
6574	>	#endif
6575	>	int
6576	>	main ()
6577	>	{
6578	>
6579	>	;
6580	>	return 0;
6581	>	}
6582	>	_ACEOF
6583	>	rm -f conftest.$ac_objext
6584	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585	>	(eval $ac_compile) 2>conftest.er1
6586	>	ac_status=$?
6587	>	grep -v '^ *+' conftest.er1 >conftest.err
6588	>	rm -f conftest.er1
6589	>	cat conftest.err >&5
6590	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591	>	(exit $ac_status); } &&
6592	>	{ ac_try='test -z "$ac_c_werror_flag"
6593	>	|| test ! -s conftest.err'
6594	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595	>	(eval $ac_try) 2>&5
6596	>	ac_status=$?
6597	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598	>	(exit $ac_status); }; } &&
6599	>	{ ac_try='test -s conftest.$ac_objext'
6600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601	>	(eval $ac_try) 2>&5
6602	>	ac_status=$?
6603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604	>	(exit $ac_status); }; }; then
6605	>	echo "$as_me:$LINENO: result: yes" >&5
6606	>	echo "${ECHO_T}yes" >&6
6607	>	LIBS="-l$fftwname $LIBS"
6608	>	cat >conftest.$ac_ext <<_ACEOF
6609	>	/* confdefs.h.  */
6610	>	_ACEOF
6611	>	cat confdefs.h >>conftest.$ac_ext
6612	>	cat >>conftest.$ac_ext <<_ACEOF
6613	>	/* end confdefs.h.  */
6614	>
6615	>
6616	>	#ifdef FC_DUMMY_MAIN
6617	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6618	>	#  ifdef __cplusplus
6619	>	extern "C"
6620	>	#  endif
6621	>	int FC_DUMMY_MAIN() { return 1; }
6622	>	#endif
6623	>	#endif
6624	>	int
6625	>	main ()
6626	>	{
6627	>	main ();
6628	>	;
6629	>	return 0;
6630	>	}
6631	>	_ACEOF
6632	>	rm -f conftest.$ac_objext conftest$ac_exeext
6633	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634	>	(eval $ac_link) 2>conftest.er1
6635	>	ac_status=$?
6636	>	grep -v '^ *+' conftest.er1 >conftest.err
6637	>	rm -f conftest.er1
6638	>	cat conftest.err >&5
6639	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640	>	(exit $ac_status); } &&
6641	>	{ ac_try='test -z "$ac_c_werror_flag"
6642	>	|| test ! -s conftest.err'
6643	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644	>	(eval $ac_try) 2>&5
6645	>	ac_status=$?
6646	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647	>	(exit $ac_status); }; } &&
6648	>	{ ac_try='test -s conftest$ac_exeext'
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); }; }; then
6654	>	:
6655	>	else
6656	>	echo "$as_me: failed program was:" >&5
6657	>	sed 's/^/| /' conftest.$ac_ext >&5
6658	>
6659	>	fi
6660	>	rm -f conftest.err conftest.$ac_objext \
6661	>	conftest$ac_exeext conftest.$ac_ext
6662	>	else
6663	>	echo "$as_me: failed program was:" >&5
6664	>	sed 's/^/| /' conftest.$ac_ext >&5
6665	>
6666	>
6667	>	echo "$as_me:$LINENO: result: no" >&5
6668	>	echo "${ECHO_T}no" >&6
6669	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673	>	{ (exit 1); exit 1; }; }
6674	>
6675	>	fi
6676	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677	>
6678	>	fi
6679	>
6680	>
6681	>
6682	>	if test "$with_mpi" = "yes"; then
6683	>
6684	>	if test -z "$ac_fftw_firstname"; then
6685	>
6686	>	sizeof_real=$sizeof_real
6687	>	if test $sizeof_real = 8; then
6688	>	prec="double"
6689	>	fftwcheckprefix=d
6690	>	else
6691	>	prec="single"
6692	>	fftwcheckprefix=s
6693	>	fi
6694	>
6695	>	xfftwname=${fftwcheckprefix}fftw3_mpi
6696	>
6697	>	ok="no"
6698	>	# check header doesn't work, since we must use mpicc to get includes,
6699	>	# we cant trust cpp.
6700	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702	>	cat >conftest.$ac_ext <<_ACEOF
6703	>	/* confdefs.h.  */
6704	>	_ACEOF
6705	>	cat confdefs.h >>conftest.$ac_ext
6706	>	cat >>conftest.$ac_ext <<_ACEOF
6707	>	/* end confdefs.h.  */
6708	>	#include <$xfftwname.h>
6709	>	#ifdef FC_DUMMY_MAIN
6710	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6711	>	#  ifdef __cplusplus
6712	>	extern "C"
6713	>	#  endif
6714	>	int FC_DUMMY_MAIN() { return 1; }
6715	>	#endif
6716	>	#endif
6717	>	int
6718	>	main ()
6719	>	{
6720	>
6721	>	;
6722	>	return 0;
6723	>	}
6724	>	_ACEOF
6725	>	rm -f conftest.$ac_objext
6726	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727	>	(eval $ac_compile) 2>conftest.er1
6728	>	ac_status=$?
6729	>	grep -v '^ *+' conftest.er1 >conftest.err
6730	>	rm -f conftest.er1
6731	>	cat conftest.err >&5
6732	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733	>	(exit $ac_status); } &&
6734	>	{ ac_try='test -z "$ac_c_werror_flag"
6735	>	|| test ! -s conftest.err'
6736	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737	>	(eval $ac_try) 2>&5
6738	>	ac_status=$?
6739	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740	>	(exit $ac_status); }; } &&
6741	>	{ ac_try='test -s conftest.$ac_objext'
6742	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743	>	(eval $ac_try) 2>&5
6744	>	ac_status=$?
6745	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746	>	(exit $ac_status); }; }; then
6747	>
6748	>	fftwname=$xfftwname
6749	>	echo "$as_me:$LINENO: result: yes" >&5
6750	>	echo "${ECHO_T}yes" >&6
6751	>
6752	>	else
6753	>	echo "$as_me: failed program was:" >&5
6754	>	sed 's/^/| /' conftest.$ac_ext >&5
6755	>
6756	>	echo "$as_me:$LINENO: result: no" >&5
6757	>	echo "${ECHO_T}no" >&6
6758	>	fi
6759	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760	>
6761	>	# fftwname was set if we found a header
6762	>
6763	>	if test -n "$fftwname"; then
6764	>	# we cannot run the code since an MPI program might not be allowed
6765	>	# on a login node of a supercomputer
6766	>	cat >conftest.$ac_ext <<_ACEOF
6767	>	/* confdefs.h.  */
6768	>	_ACEOF
6769	>	cat confdefs.h >>conftest.$ac_ext
6770	>	cat >>conftest.$ac_ext <<_ACEOF
6771	>	/* end confdefs.h.  */
6772	>	#include <$fftwname.h>
6773	>	#ifdef FC_DUMMY_MAIN
6774	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6775	>	#  ifdef __cplusplus
6776	>	extern "C"
6777	>	#  endif
6778	>	int FC_DUMMY_MAIN() { return 1; }
6779	>	#endif
6780	>	#endif
6781	>	int
6782	>	main ()
6783	>	{
6784	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785	>	;
6786	>	return 0;
6787	>	}
6788	>	_ACEOF
6789	>	rm -f conftest.$ac_objext
6790	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791	>	(eval $ac_compile) 2>conftest.er1
6792	>	ac_status=$?
6793	>	grep -v '^ *+' conftest.er1 >conftest.err
6794	>	rm -f conftest.er1
6795	>	cat conftest.err >&5
6796	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797	>	(exit $ac_status); } &&
6798	>	{ ac_try='test -z "$ac_c_werror_flag"
6799	>	|| test ! -s conftest.err'
6800	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801	>	(eval $ac_try) 2>&5
6802	>	ac_status=$?
6803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804	>	(exit $ac_status); }; } &&
6805	>	{ ac_try='test -s conftest.$ac_objext'
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); }; }; then
6811	>
6812	>	ok=yes
6813	>	usedprefix=$fftwcheckprefix
6814	>
6815	>	else
6816	>	echo "$as_me: failed program was:" >&5
6817	>	sed 's/^/| /' conftest.$ac_ext >&5
6818	>
6819	>	ok=no
6820	>	fi
6821	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822	>	fi
6823	>
6824	>	if test "$ok" != "yes"; then
6825	>	echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826	>	echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827	>	cat >conftest.$ac_ext <<_ACEOF
6828	>	/* confdefs.h.  */
6829	>	_ACEOF
6830	>	cat confdefs.h >>conftest.$ac_ext
6831	>	cat >>conftest.$ac_ext <<_ACEOF
6832	>	/* end confdefs.h.  */
6833	>	#include <fftw3_mpi.h>
6834	>	#ifdef FC_DUMMY_MAIN
6835	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6836	>	#  ifdef __cplusplus
6837	>	extern "C"
6838	>	#  endif
6839	>	int FC_DUMMY_MAIN() { return 1; }
6840	>	#endif
6841	>	#endif
6842	>	int
6843	>	main ()
6844	>	{
6845	>
6846	>	;
6847	>	return 0;
6848	>	}
6849	>	_ACEOF
6850	>	rm -f conftest.$ac_objext
6851	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852	>	(eval $ac_compile) 2>conftest.er1
6853	>	ac_status=$?
6854	>	grep -v '^ *+' conftest.er1 >conftest.err
6855	>	rm -f conftest.er1
6856	>	cat conftest.err >&5
6857	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858	>	(exit $ac_status); } &&
6859	>	{ ac_try='test -z "$ac_c_werror_flag"
6860	>	|| test ! -s conftest.err'
6861	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862	>	(eval $ac_try) 2>&5
6863	>	ac_status=$?
6864	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865	>	(exit $ac_status); }; } &&
6866	>	{ ac_try='test -s conftest.$ac_objext'
6867	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868	>	(eval $ac_try) 2>&5
6869	>	ac_status=$?
6870	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871	>	(exit $ac_status); }; }; then
6872	>	echo "$as_me:$LINENO: result: yes" >&5
6873	>	echo "${ECHO_T}yes" >&6
6874	>	else
6875	>	echo "$as_me: failed program was:" >&5
6876	>	sed 's/^/| /' conftest.$ac_ext >&5
6877	>
6878	>
6879	>	echo "$as_me:$LINENO: result: no" >&5
6880	>	echo "${ECHO_T}no" >&6
6881	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882	>	Do you have $prec precision FFTW installed? If you are using packages,
6883	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884	>	software at www.fftw.org.
6885	>	If you compiled FFTW yourself:
6886	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6887	>	use --with-mpi. It is a good idea to install both single & double.
6888	>	If you have installed FFTW in a non-standard location, you should
6889	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890	>	variables before running configure.
6891	>	That is also necessary to do if your compiler doesn't search
6892	>	/usr/local/include and /usr/local/lib by default." >&5
6893	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894	>	Do you have $prec precision FFTW installed? If you are using packages,
6895	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896	>	software at www.fftw.org.
6897	>	If you compiled FFTW yourself:
6898	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6899	>	use --with-mpi. It is a good idea to install both single & double.
6900	>	If you have installed FFTW in a non-standard location, you should
6901	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902	>	variables before running configure.
6903	>	That is also necessary to do if your compiler doesn't search
6904	>	/usr/local/include and /usr/local/lib by default." >&2;}
6905	>	{ (exit 1); exit 1; }; }
6906	>
6907	>	fi
6908	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909	>	cat >conftest.$ac_ext <<_ACEOF
6910	>	/* confdefs.h.  */
6911	>	_ACEOF
6912	>	cat confdefs.h >>conftest.$ac_ext
6913	>	cat >>conftest.$ac_ext <<_ACEOF
6914	>	/* end confdefs.h.  */
6915	>	#include <fftw3_mpi.h>
6916	>	#ifdef FC_DUMMY_MAIN
6917	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6918	>	#  ifdef __cplusplus
6919	>	extern "C"
6920	>	#  endif
6921	>	int FC_DUMMY_MAIN() { return 1; }
6922	>	#endif
6923	>	#endif
6924	>	int
6925	>	main ()
6926	>	{
6927	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928	>	;
6929	>	return 0;
6930	>	}
6931	>	_ACEOF
6932	>	rm -f conftest.$ac_objext
6933	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934	>	(eval $ac_compile) 2>conftest.er1
6935	>	ac_status=$?
6936	>	grep -v '^ *+' conftest.er1 >conftest.err
6937	>	rm -f conftest.er1
6938	>	cat conftest.err >&5
6939	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940	>	(exit $ac_status); } &&
6941	>	{ ac_try='test -z "$ac_c_werror_flag"
6942	>	|| test ! -s conftest.err'
6943	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944	>	(eval $ac_try) 2>&5
6945	>	ac_status=$?
6946	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947	>	(exit $ac_status); }; } &&
6948	>	{ ac_try='test -s conftest.$ac_objext'
6949	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950	>	(eval $ac_try) 2>&5
6951	>	ac_status=$?
6952	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953	>	(exit $ac_status); }; }; then
6954	>
6955	>	usedprefix=""
6956	>	fftwname=fftw3_mpi
6957	>
6958	>	else
6959	>	echo "$as_me: failed program was:" >&5
6960	>	sed 's/^/| /' conftest.$ac_ext >&5
6961	>
6962	>
6963	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964	>	Do you have $prec precision FFTW installed? If you are using packages,
6965	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966	>	software at www.fftw.org.
6967	>	If you compiled FFTW yourself:
6968	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6969	>	use --with-mpi. It is a good idea to install both single & double.
6970	>	If you have installed FFTW in a non-standard location, you should
6971	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972	>	variables before running configure.
6973	>	That is also necessary to do if your compiler doesn't search
6974	>	/usr/local/include and /usr/local/lib by default." >&5
6975	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976	>	Do you have $prec precision FFTW installed? If you are using packages,
6977	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978	>	software at www.fftw.org.
6979	>	If you compiled FFTW yourself:
6980	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6981	>	use --with-mpi. It is a good idea to install both single & double.
6982	>	If you have installed FFTW in a non-standard location, you should
6983	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984	>	variables before running configure.
6985	>	That is also necessary to do if your compiler doesn't search
6986	>	/usr/local/include and /usr/local/lib by default." >&2;}
6987	>	{ (exit 1); exit 1; }; }
6988	>	fi
6989	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990	>	fi
6991	>
6992	>
6993	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6998	>	else
6999	>	ac_check_lib_save_LIBS=$LIBS
7000	>	LIBS="-l$fftwname  $LIBS"
7001	>	cat >conftest.$ac_ext <<_ACEOF
7002	>	/* confdefs.h.  */
7003	>	_ACEOF
7004	>	cat confdefs.h >>conftest.$ac_ext
7005	>	cat >>conftest.$ac_ext <<_ACEOF
7006	>	/* end confdefs.h.  */
7007	>
7008	>
7009	>	#ifdef FC_DUMMY_MAIN
7010	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7011	>	#  ifdef __cplusplus
7012	>	extern "C"
7013	>	#  endif
7014	>	int FC_DUMMY_MAIN() { return 1; }
7015	>	#endif
7016	>	#endif
7017	>	int
7018	>	main ()
7019	>	{
7020	>	main ();
7021	>	;
7022	>	return 0;
7023	>	}
7024	>	_ACEOF
7025	>	rm -f conftest.$ac_objext conftest$ac_exeext
7026	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027	>	(eval $ac_link) 2>conftest.er1
7028	>	ac_status=$?
7029	>	grep -v '^ *+' conftest.er1 >conftest.err
7030	>	rm -f conftest.er1
7031	>	cat conftest.err >&5
7032	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033	>	(exit $ac_status); } &&
7034	>	{ ac_try='test -z "$ac_c_werror_flag"
7035	>	|| test ! -s conftest.err'
7036	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037	>	(eval $ac_try) 2>&5
7038	>	ac_status=$?
7039	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040	>	(exit $ac_status); }; } &&
7041	>	{ ac_try='test -s conftest$ac_exeext'
7042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043	>	(eval $ac_try) 2>&5
7044	>	ac_status=$?
7045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046	>	(exit $ac_status); }; }; then
7047	>	eval "$as_ac_Lib=yes"
7048	>	else
7049	>	echo "$as_me: failed program was:" >&5
7050	>	sed 's/^/| /' conftest.$ac_ext >&5
7051	>
7052	>	eval "$as_ac_Lib=no"
7053	>	fi
7054	>	rm -f conftest.err conftest.$ac_objext \
7055	>	conftest$ac_exeext conftest.$ac_ext
7056	>	LIBS=$ac_check_lib_save_LIBS
7057	>	fi
7058	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061	>	cat >>confdefs.h <<_ACEOF
7062	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063	>	_ACEOF
7064	>
7065	>	LIBS="-l$fftwname $LIBS"
7066	>
7067	>	else
7068	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070	>	{ (exit 1); exit 1; }; }
7071	>	fi
7072	>
7073	>	ac_fftw_savedprefix=$usedprefix
7074	>	ac_fftw_firstname=$fftwname
7075	>
7076	>	else
7077	>
7078	>	fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081	>	cat >conftest.$ac_ext <<_ACEOF
7082	>	/* confdefs.h.  */
7083	>	_ACEOF
7084	>	cat confdefs.h >>conftest.$ac_ext
7085	>	cat >>conftest.$ac_ext <<_ACEOF
7086	>	/* end confdefs.h.  */
7087	>	#include <$fftwname.h>
7088	>	#ifdef FC_DUMMY_MAIN
7089	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7090	>	#  ifdef __cplusplus
7091	>	extern "C"
7092	>	#  endif
7093	>	int FC_DUMMY_MAIN() { return 1; }
7094	>	#endif
7095	>	#endif
7096	>	int
7097	>	main ()
7098	>	{
7099	>
7100	>	;
7101	>	return 0;
7102	>	}
7103	>	_ACEOF
7104	>	rm -f conftest.$ac_objext
7105	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106	>	(eval $ac_compile) 2>conftest.er1
7107	>	ac_status=$?
7108	>	grep -v '^ *+' conftest.er1 >conftest.err
7109	>	rm -f conftest.er1
7110	>	cat conftest.err >&5
7111	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112	>	(exit $ac_status); } &&
7113	>	{ ac_try='test -z "$ac_c_werror_flag"
7114	>	|| test ! -s conftest.err'
7115	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116	>	(eval $ac_try) 2>&5
7117	>	ac_status=$?
7118	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119	>	(exit $ac_status); }; } &&
7120	>	{ ac_try='test -s conftest.$ac_objext'
7121	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122	>	(eval $ac_try) 2>&5
7123	>	ac_status=$?
7124	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125	>	(exit $ac_status); }; }; then
7126	>	echo "$as_me:$LINENO: result: yes" >&5
7127	>	echo "${ECHO_T}yes" >&6
7128	>	LIBS="-l$fftwname $LIBS"
7129	>	cat >conftest.$ac_ext <<_ACEOF
7130	>	/* confdefs.h.  */
7131	>	_ACEOF
7132	>	cat confdefs.h >>conftest.$ac_ext
7133	>	cat >>conftest.$ac_ext <<_ACEOF
7134	>	/* end confdefs.h.  */
7135	>
7136	>
7137	>	#ifdef FC_DUMMY_MAIN
7138	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7139	>	#  ifdef __cplusplus
7140	>	extern "C"
7141	>	#  endif
7142	>	int FC_DUMMY_MAIN() { return 1; }
7143	>	#endif
7144	>	#endif
7145	>	int
7146	>	main ()
7147	>	{
7148	>	main ();
7149	>	;
7150	>	return 0;
7151	>	}
7152	>	_ACEOF
7153	>	rm -f conftest.$ac_objext conftest$ac_exeext
7154	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155	>	(eval $ac_link) 2>conftest.er1
7156	>	ac_status=$?
7157	>	grep -v '^ *+' conftest.er1 >conftest.err
7158	>	rm -f conftest.er1
7159	>	cat conftest.err >&5
7160	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161	>	(exit $ac_status); } &&
7162	>	{ ac_try='test -z "$ac_c_werror_flag"
7163	>	|| test ! -s conftest.err'
7164	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165	>	(eval $ac_try) 2>&5
7166	>	ac_status=$?
7167	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168	>	(exit $ac_status); }; } &&
7169	>	{ ac_try='test -s conftest$ac_exeext'
7170	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171	>	(eval $ac_try) 2>&5
7172	>	ac_status=$?
7173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174	>	(exit $ac_status); }; }; then
7175	>	:
7176	>	else
7177	>	echo "$as_me: failed program was:" >&5
7178	>	sed 's/^/| /' conftest.$ac_ext >&5
7179	>
7180	>	fi
7181	>	rm -f conftest.err conftest.$ac_objext \
7182	>	conftest$ac_exeext conftest.$ac_ext
7183	>	else
7184	>	echo "$as_me: failed program was:" >&5
7185	>	sed 's/^/| /' conftest.$ac_ext >&5
7186	>
7187	>
7188	>	echo "$as_me:$LINENO: result: no" >&5
7189	>	echo "${ECHO_T}no" >&6
7190	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194	>	{ (exit 1); exit 1; }; }
7195	>
7196	>	fi
7197	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198	>
7199	>	fi
7200	>
7201	>
7202	>	fi
7203	>
7204	>	case ${ac_fftw_savedprefix} in
7205	>	d)
7206	>	cat >>confdefs.h <<\_ACEOF
7207	>	#define FFTW_NAME_DFFTW
7208	>	_ACEOF
7209	>	;;
7210	>	*)
7211	>	cat >>confdefs.h <<\_ACEOF
7212	>	#define FFTW_NAME_FFTW
7213	>	_ACEOF
7214	>	;;
7215	>	esac
7216	>	else
7217	>	echo "*******************************************************************"
7218	>	echo "* FFTW libraries and include files are required for computing     *"
7219	>	echo "* undulation spectra with the staticProps program.  If you don't  *"
7220	>	echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221	>	echo "* analyze your trajectories for this property.                    *"
7222	>	echo "*******************************************************************"
7223	>	fi # end of fftw check
7224	>
7225	>	# Checks for header files.
7226	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228	>	if test "${ac_cv_header_stdc+set}" = set; then
7229	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7230	>	else
7231	>	cat >conftest.$ac_ext <<_ACEOF
7232	>	/* confdefs.h.  */
7233	>	_ACEOF
7234	>	cat confdefs.h >>conftest.$ac_ext
7235	>	cat >>conftest.$ac_ext <<_ACEOF
7236	>	/* end confdefs.h.  */
7237	>	#include <stdlib.h>
7238	>	#include <stdarg.h>
7239	>	#include <string.h>
7240	>	#include <float.h>
7241	>
7242	>	#ifdef FC_DUMMY_MAIN
7243	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7244	>	#  ifdef __cplusplus
7245	>	extern "C"
7246	>	#  endif
7247	>	int FC_DUMMY_MAIN() { return 1; }
7248	>	#endif
7249	>	#endif
7250	>	int
7251	>	main ()
7252	>	{
7253	>
7254	>	;
7255	>	return 0;
7256	>	}
7257	>	_ACEOF
7258	>	rm -f conftest.$ac_objext
7259	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260	>	(eval $ac_compile) 2>conftest.er1
7261	>	ac_status=$?
7262	>	grep -v '^ *+' conftest.er1 >conftest.err
7263	>	rm -f conftest.er1
7264	>	cat conftest.err >&5
7265	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266	>	(exit $ac_status); } &&
7267	>	{ ac_try='test -z "$ac_c_werror_flag"
7268	>	|| test ! -s conftest.err'
7269	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270	>	(eval $ac_try) 2>&5
7271	>	ac_status=$?
7272	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273	>	(exit $ac_status); }; } &&
7274	>	{ ac_try='test -s conftest.$ac_objext'
7275	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276	>	(eval $ac_try) 2>&5
7277	>	ac_status=$?
7278	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279	>	(exit $ac_status); }; }; then
7280	>	ac_cv_header_stdc=yes
7281	>	else
7282	>	echo "$as_me: failed program was:" >&5
7283	>	sed 's/^/| /' conftest.$ac_ext >&5
7284	>
7285	>	ac_cv_header_stdc=no
7286	>	fi
7287	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288	>
7289	>	if test $ac_cv_header_stdc = yes; then
7290	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291	>	cat >conftest.$ac_ext <<_ACEOF
7292	>	/* confdefs.h.  */
7293	>	_ACEOF
7294	>	cat confdefs.h >>conftest.$ac_ext
7295	>	cat >>conftest.$ac_ext <<_ACEOF
7296	>	/* end confdefs.h.  */
7297	>	#include <string.h>
7298	>
7299	>	_ACEOF
7300	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301	>	$EGREP "memchr" >/dev/null 2>&1; then
7302	>	:
7303	>	else
7304	>	ac_cv_header_stdc=no
7305	>	fi
7306	>	rm -f conftest*
7307	>
7308	>	fi
7309	>
7310	>	if test $ac_cv_header_stdc = yes; then
7311	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312	>	cat >conftest.$ac_ext <<_ACEOF
7313	>	/* confdefs.h.  */
7314	>	_ACEOF
7315	>	cat confdefs.h >>conftest.$ac_ext
7316	>	cat >>conftest.$ac_ext <<_ACEOF
7317	>	/* end confdefs.h.  */
7318	>	#include <stdlib.h>
7319	>
7320	>	_ACEOF
7321	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322	>	$EGREP "free" >/dev/null 2>&1; then
7323	>	:
7324	>	else
7325	>	ac_cv_header_stdc=no
7326	>	fi
7327	>	rm -f conftest*
7328	>
7329	>	fi
7330	>
7331	>	if test $ac_cv_header_stdc = yes; then
7332	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333	>	if test "$cross_compiling" = yes; then
7334	>	:
7335	>	else
7336	>	cat >conftest.$ac_ext <<_ACEOF
7337	>	/* confdefs.h.  */
7338	>	_ACEOF
7339	>	cat confdefs.h >>conftest.$ac_ext
7340	>	cat >>conftest.$ac_ext <<_ACEOF
7341	>	/* end confdefs.h.  */
7342	>	#include <ctype.h>
7343	>	#if ((' ' & 0x0FF) == 0x020)
7344	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346	>	#else
7347	>	# define ISLOWER(c) \
7348	>	(('a' <= (c) && (c) <= 'i') \
7349	>	|| ('j' <= (c) && (c) <= 'r') \
7350	>	|| ('s' <= (c) && (c) <= 'z'))
7351	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352	>	#endif
7353	>
7354	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355	>	int
7356	>	main ()
7357	>	{
7358	>	int i;
7359	>	for (i = 0; i < 256; i++)
7360	>	if (XOR (islower (i), ISLOWER (i))
7361	>	|| toupper (i) != TOUPPER (i))
7362	>	exit(2);
7363	>	exit (0);
7364	>	}
7365	>	_ACEOF
7366	>	rm -f conftest$ac_exeext
7367	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368	>	(eval $ac_link) 2>&5
7369	>	ac_status=$?
7370	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373	>	(eval $ac_try) 2>&5
7374	>	ac_status=$?
7375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376	>	(exit $ac_status); }; }; then
7377	>	:
7378	>	else
7379	>	echo "$as_me: program exited with status $ac_status" >&5
7380	>	echo "$as_me: failed program was:" >&5
7381	>	sed 's/^/| /' conftest.$ac_ext >&5
7382	>
7383	>	( exit $ac_status )
7384	>	ac_cv_header_stdc=no
7385	>	fi
7386	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387	>	fi
7388	>	fi
7389	>	fi
7390	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392	>	if test $ac_cv_header_stdc = yes; then
7393	>
7394	>	cat >>confdefs.h <<\_ACEOF
7395	>	#define STDC_HEADERS 1
7396	>	_ACEOF
7397	>
7398	>	fi
7399	>
7400	>
7401	>
7402	>
7403	>
7404	>
7405	>
7406	>
7407	>
7408	>
7409	>
7410	>
7411	>
7412	>
7413	>
7414	>
7415	>
7416	>
7417	>
7418	>
7419	>
7420	>
7421	>
7422	>
7423	>
7424	>
7425	>	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
7426	>	do
7427	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7430	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7433	>	fi
7434	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436	>	else
7437	>	# Is the header compilable?
7438	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440	>	cat >conftest.$ac_ext <<_ACEOF
7441	>	/* confdefs.h.  */
7442	>	_ACEOF
7443	>	cat confdefs.h >>conftest.$ac_ext
7444	>	cat >>conftest.$ac_ext <<_ACEOF
7445	>	/* end confdefs.h.  */
7446	>	$ac_includes_default
7447	>	#include <$ac_header>
7448	>	_ACEOF
7449	>	rm -f conftest.$ac_objext
7450	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451	>	(eval $ac_compile) 2>conftest.er1
7452	>	ac_status=$?
7453	>	grep -v '^ *+' conftest.er1 >conftest.err
7454	>	rm -f conftest.er1
7455	>	cat conftest.err >&5
7456	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457	>	(exit $ac_status); } &&
7458	>	{ ac_try='test -z "$ac_c_werror_flag"
7459	>	|| test ! -s conftest.err'
7460	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461	>	(eval $ac_try) 2>&5
7462	>	ac_status=$?
7463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464	>	(exit $ac_status); }; } &&
7465	>	{ ac_try='test -s conftest.$ac_objext'
7466	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467	>	(eval $ac_try) 2>&5
7468	>	ac_status=$?
7469	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470	>	(exit $ac_status); }; }; then
7471	>	ac_header_compiler=yes
7472	>	else
7473	>	echo "$as_me: failed program was:" >&5
7474	>	sed 's/^/| /' conftest.$ac_ext >&5
7475	>
7476	>	ac_header_compiler=no
7477	>	fi
7478	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480	>	echo "${ECHO_T}$ac_header_compiler" >&6
7481	>
7482	>	# Is the header present?
7483	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485	>	cat >conftest.$ac_ext <<_ACEOF
7486	>	/* confdefs.h.  */
7487	>	_ACEOF
7488	>	cat confdefs.h >>conftest.$ac_ext
7489	>	cat >>conftest.$ac_ext <<_ACEOF
7490	>	/* end confdefs.h.  */
7491	>	#include <$ac_header>
7492	>	_ACEOF
7493	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495	>	ac_status=$?
7496	>	grep -v '^ *+' conftest.er1 >conftest.err
7497	>	rm -f conftest.er1
7498	>	cat conftest.err >&5
7499	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500	>	(exit $ac_status); } >/dev/null; then
7501	>	if test -s conftest.err; then
7502	>	ac_cpp_err=$ac_c_preproc_warn_flag
7503	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504	>	else
7505	>	ac_cpp_err=
7506	>	fi
7507	>	else
7508	>	ac_cpp_err=yes
7509	>	fi
7510	>	if test -z "$ac_cpp_err"; then
7511	>	ac_header_preproc=yes
7512	>	else
7513	>	echo "$as_me: failed program was:" >&5
7514	>	sed 's/^/| /' conftest.$ac_ext >&5
7515	>
7516	>	ac_header_preproc=no
7517	>	fi
7518	>	rm -f conftest.err conftest.$ac_ext
7519	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520	>	echo "${ECHO_T}$ac_header_preproc" >&6
7521	>
7522	>	# So?  What about this header?
7523	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524	>	yes:no: )
7525	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529	>	ac_header_preproc=yes
7530	>	;;
7531	>	no:yes:* )
7532	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544	>	(
7545	>	cat <<\_ASBOX
7546	>	## ------------------------------ ##
7547	>	## Report this to gezelter@nd.edu ##
7548	>	## ------------------------------ ##
7549	>	_ASBOX
7550	>	) |
7551	>	sed "s/^/$as_me: WARNING:     /" >&2
7552	>	;;
7553	>	esac
7554	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7555	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7558	>	else
7559	>	eval "$as_ac_Header=\$ac_header_preproc"
7560	>	fi
7561	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563	>
7564	>	fi
7565	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566	>	cat >>confdefs.h <<_ACEOF
7567	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568	>	_ACEOF
7569	>
7570	>	fi
7571	>
7572	>	done
7573	>
7574	>
7575	>	# Checks for typedefs, structures, and compiler characteristics.
7576	>	echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577	>	echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578	>	if test "${ac_cv_header_stdbool_h+set}" = set; then
7579	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7580	>	else
7581	>	cat >conftest.$ac_ext <<_ACEOF
7582	>	/* confdefs.h.  */
7583	>	_ACEOF
7584	>	cat confdefs.h >>conftest.$ac_ext
7585	>	cat >>conftest.$ac_ext <<_ACEOF
7586	>	/* end confdefs.h.  */
7587	>
7588	>	#include <stdbool.h>
7589	>	#ifndef bool
7590	>	# error bool is not defined
7591	>	#endif
7592	>	#ifndef false
7593	>	# error false is not defined
7594	>	#endif
7595	>	#if false
7596	>	# error false is not 0
7597	>	#endif
7598	>	#ifndef true
7599	>	# error true is not defined
7600	>	#endif
7601	>	#if true != 1
7602	>	# error true is not 1
7603	>	#endif
7604	>	#ifndef __bool_true_false_are_defined
7605	>	# error __bool_true_false_are_defined is not defined
7606	>	#endif
7607	>
7608	>	struct s { _Bool s: 1; _Bool t; } s;
7609	>
7610	>	char a[true == 1 ? 1 : -1];
7611	>	char b[false == 0 ? 1 : -1];
7612	>	char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613	>	char d[(bool) -0.5 == true ? 1 : -1];
7614	>	bool e = &s;
7615	>	char f[(_Bool) -0.0 == false ? 1 : -1];
7616	>	char g[true];
7617	>	char h[sizeof (_Bool)];
7618	>	char i[sizeof s.t];
7619	>
7620	>	#ifdef FC_DUMMY_MAIN
7621	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7622	>	#  ifdef __cplusplus
7623	>	extern "C"
7624	>	#  endif
7625	>	int FC_DUMMY_MAIN() { return 1; }
7626	>	#endif
7627	>	#endif
7628	>	int
7629	>	main ()
7630	>	{
7631	>	return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632	>	;
7633	>	return 0;
7634	>	}
7635	>	_ACEOF
7636	>	rm -f conftest.$ac_objext
7637	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638	>	(eval $ac_compile) 2>conftest.er1
7639	>	ac_status=$?
7640	>	grep -v '^ *+' conftest.er1 >conftest.err
7641	>	rm -f conftest.er1
7642	>	cat conftest.err >&5
7643	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644	>	(exit $ac_status); } &&
7645	>	{ ac_try='test -z "$ac_c_werror_flag"
7646	>	|| test ! -s conftest.err'
7647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648	>	(eval $ac_try) 2>&5
7649	>	ac_status=$?
7650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651	>	(exit $ac_status); }; } &&
7652	>	{ ac_try='test -s conftest.$ac_objext'
7653	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654	>	(eval $ac_try) 2>&5
7655	>	ac_status=$?
7656	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657	>	(exit $ac_status); }; }; then
7658	>	ac_cv_header_stdbool_h=yes
7659	>	else
7660	>	echo "$as_me: failed program was:" >&5
7661	>	sed 's/^/| /' conftest.$ac_ext >&5
7662	>
7663	>	ac_cv_header_stdbool_h=no
7664	>	fi
7665	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666	>	fi
7667	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668	>	echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669	>	echo "$as_me:$LINENO: checking for _Bool" >&5
7670	>	echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671	>	if test "${ac_cv_type__Bool+set}" = set; then
7672	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7673	>	else
7674	>	cat >conftest.$ac_ext <<_ACEOF
7675	>	/* confdefs.h.  */
7676	>	_ACEOF
7677	>	cat confdefs.h >>conftest.$ac_ext
7678	>	cat >>conftest.$ac_ext <<_ACEOF
7679	>	/* end confdefs.h.  */
7680	>	$ac_includes_default
7681	>	#ifdef FC_DUMMY_MAIN
7682	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7683	>	#  ifdef __cplusplus
7684	>	extern "C"
7685	>	#  endif
7686	>	int FC_DUMMY_MAIN() { return 1; }
7687	>	#endif
7688	>	#endif
7689	>	int
7690	>	main ()
7691	>	{
7692	>	if ((_Bool *) 0)
7693	>	return 0;
7694	>	if (sizeof (_Bool))
7695	>	return 0;
7696	>	;
7697	>	return 0;
7698	>	}
7699	>	_ACEOF
7700	>	rm -f conftest.$ac_objext
7701	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702	>	(eval $ac_compile) 2>conftest.er1
7703	>	ac_status=$?
7704	>	grep -v '^ *+' conftest.er1 >conftest.err
7705	>	rm -f conftest.er1
7706	>	cat conftest.err >&5
7707	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708	>	(exit $ac_status); } &&
7709	>	{ ac_try='test -z "$ac_c_werror_flag"
7710	>	|| test ! -s conftest.err'
7711	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712	>	(eval $ac_try) 2>&5
7713	>	ac_status=$?
7714	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715	>	(exit $ac_status); }; } &&
7716	>	{ ac_try='test -s conftest.$ac_objext'
7717	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718	>	(eval $ac_try) 2>&5
7719	>	ac_status=$?
7720	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721	>	(exit $ac_status); }; }; then
7722	>	ac_cv_type__Bool=yes
7723	>	else
7724	>	echo "$as_me: failed program was:" >&5
7725	>	sed 's/^/| /' conftest.$ac_ext >&5
7726	>
7727	>	ac_cv_type__Bool=no
7728	>	fi
7729	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730	>	fi
7731	>	echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732	>	echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733	>	if test $ac_cv_type__Bool = yes; then
7734	>
7735	>	cat >>confdefs.h <<_ACEOF
7736	>	#define HAVE__BOOL 1
7737	>	_ACEOF
7738	>
7739	>
7740	>	fi
7741	>
7742	>	if test $ac_cv_header_stdbool_h = yes; then
7743	>
7744	>	cat >>confdefs.h <<\_ACEOF
7745	>	#define HAVE_STDBOOL_H 1
7746	>	_ACEOF
7747	>
7748	>	fi
7749	>
7750	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752	>	if test "${ac_cv_c_const+set}" = set; then
7753	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7754	>	else
7755	>	cat >conftest.$ac_ext <<_ACEOF
7756	>	/* confdefs.h.  */
7757	>	_ACEOF
7758	>	cat confdefs.h >>conftest.$ac_ext
7759	>	cat >>conftest.$ac_ext <<_ACEOF
7760	>	/* end confdefs.h.  */
7761	>
7762	>	#ifdef FC_DUMMY_MAIN
7763	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7764	>	#  ifdef __cplusplus
7765	>	extern "C"
7766	>	#  endif
7767	>	int FC_DUMMY_MAIN() { return 1; }
7768	>	#endif
7769	>	#endif
7770	>	int
7771	>	main ()
7772	>	{
7773	>	/* FIXME: Include the comments suggested by Paul. */
7774	>	#ifndef __cplusplus
7775	>	/* Ultrix mips cc rejects this.  */
7776	>	typedef int charset[2];
7777	>	const charset x;
7778	>	/* SunOS 4.1.1 cc rejects this.  */
7779	>	char const *const *ccp;
7780	>	char **p;
7781	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7782	>	struct point {int x, y;};
7783	>	static struct point const zero = {0,0};
7784	>	/* AIX XL C 1.02.0.0 rejects this.
7785	>	It does not let you subtract one const X* pointer from another in
7786	>	an arm of an if-expression whose if-part is not a constant
7787	>	expression */
7788	>	const char *g = "string";
7789	>	ccp = &g + (g ? g-g : 0);
7790	>	/* HPUX 7.0 cc rejects these. */
7791	>	++ccp;
7792	>	p = (char**) ccp;
7793	>	ccp = (char const *const *) p;
7794	>	{ /* SCO 3.2v4 cc rejects this.  */
7795	>	char *t;
7796	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7797	>
7798	>	*t++ = 0;
7799	>	}
7800	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801	>	int x[] = {25, 17};
7802	>	const int *foo = &x[0];
7803	>	++foo;
7804	>	}
7805	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806	>	typedef const int *iptr;
7807	>	iptr p = 0;
7808	>	++p;
7809	>	}
7810	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7811	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812	>	struct s { int j; const int *ap[3]; };
7813	>	struct s *b; b->j = 5;
7814	>	}
7815	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816	>	const int foo = 10;
7817	>	}
7818	>	#endif
7819	>
7820	>	;
7821	>	return 0;
7822	>	}
7823	>	_ACEOF
7824	>	rm -f conftest.$ac_objext
7825	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826	>	(eval $ac_compile) 2>conftest.er1
7827	>	ac_status=$?
7828	>	grep -v '^ *+' conftest.er1 >conftest.err
7829	>	rm -f conftest.er1
7830	>	cat conftest.err >&5
7831	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832	>	(exit $ac_status); } &&
7833	>	{ ac_try='test -z "$ac_c_werror_flag"
7834	>	|| test ! -s conftest.err'
7835	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836	>	(eval $ac_try) 2>&5
7837	>	ac_status=$?
7838	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839	>	(exit $ac_status); }; } &&
7840	>	{ ac_try='test -s conftest.$ac_objext'
7841	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842	>	(eval $ac_try) 2>&5
7843	>	ac_status=$?
7844	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845	>	(exit $ac_status); }; }; then
7846	>	ac_cv_c_const=yes
7847	>	else
7848	>	echo "$as_me: failed program was:" >&5
7849	>	sed 's/^/| /' conftest.$ac_ext >&5
7850	>
7851	>	ac_cv_c_const=no
7852	>	fi
7853	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854	>	fi
7855	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856	>	echo "${ECHO_T}$ac_cv_c_const" >&6
7857	>	if test $ac_cv_c_const = no; then
7858	>
7859	>	cat >>confdefs.h <<\_ACEOF
7860	>	#define const
7861	>	_ACEOF
7862	>
7863	>	fi
7864	>
7865	>	echo "$as_me:$LINENO: checking for inline" >&5
7866	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867	>	if test "${ac_cv_c_inline+set}" = set; then
7868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7869	>	else
7870	>	ac_cv_c_inline=no
7871	>	for ac_kw in inline __inline__ __inline; do
7872	>	cat >conftest.$ac_ext <<_ACEOF
7873	>	/* confdefs.h.  */
7874	>	_ACEOF
7875	>	cat confdefs.h >>conftest.$ac_ext
7876	>	cat >>conftest.$ac_ext <<_ACEOF
7877	>	/* end confdefs.h.  */
7878	>	#ifndef __cplusplus
7879	>	typedef int foo_t;
7880	>	static $ac_kw foo_t static_foo () {return 0; }
7881	>	$ac_kw foo_t foo () {return 0; }
7882	>	#endif
7883	>
7884	>	_ACEOF
7885	>	rm -f conftest.$ac_objext
7886	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887	>	(eval $ac_compile) 2>conftest.er1
7888	>	ac_status=$?
7889	>	grep -v '^ *+' conftest.er1 >conftest.err
7890	>	rm -f conftest.er1
7891	>	cat conftest.err >&5
7892	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893	>	(exit $ac_status); } &&
7894	>	{ ac_try='test -z "$ac_c_werror_flag"
7895	>	|| test ! -s conftest.err'
7896	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897	>	(eval $ac_try) 2>&5
7898	>	ac_status=$?
7899	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900	>	(exit $ac_status); }; } &&
7901	>	{ ac_try='test -s conftest.$ac_objext'
7902	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903	>	(eval $ac_try) 2>&5
7904	>	ac_status=$?
7905	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906	>	(exit $ac_status); }; }; then
7907	>	ac_cv_c_inline=$ac_kw; break
7908	>	else
7909	>	echo "$as_me: failed program was:" >&5
7910	>	sed 's/^/| /' conftest.$ac_ext >&5
7911	>
7912	>	fi
7913	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914	>	done
7915	>
7916	>	fi
7917	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
7919	>
7920	>
7921	>	case $ac_cv_c_inline in
7922	>	inline | yes) ;;
7923	>	*)
7924	>	case $ac_cv_c_inline in
7925	>	no) ac_val=;;
7926	>	*) ac_val=$ac_cv_c_inline;;
7927	>	esac
7928	>	cat >>confdefs.h <<_ACEOF
7929	>	#ifndef __cplusplus
7930	>	#define inline $ac_val
7931	>	#endif
7932	>	_ACEOF
7933	>	;;
7934	>	esac
7935	>
7936	>	echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937	>	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938	>	if test "${ac_cv_c_restrict+set}" = set; then
7939	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7940	>	else
7941	>	ac_cv_c_restrict=no
7942	>	# Try the official restrict keyword, then gcc's __restrict, and
7943	>	# the less common variants.
7944	>	for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945	>	cat >conftest.$ac_ext <<_ACEOF
7946	>	/* confdefs.h.  */
7947	>	_ACEOF
7948	>	cat confdefs.h >>conftest.$ac_ext
7949	>	cat >>conftest.$ac_ext <<_ACEOF
7950	>	/* end confdefs.h.  */
7951	>	float * $ac_kw x;
7952	>	_ACEOF
7953	>	rm -f conftest.$ac_objext
7954	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955	>	(eval $ac_compile) 2>conftest.er1
7956	>	ac_status=$?
7957	>	grep -v '^ *+' conftest.er1 >conftest.err
7958	>	rm -f conftest.er1
7959	>	cat conftest.err >&5
7960	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961	>	(exit $ac_status); } &&
7962	>	{ ac_try='test -z "$ac_c_werror_flag"
7963	>	|| test ! -s conftest.err'
7964	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965	>	(eval $ac_try) 2>&5
7966	>	ac_status=$?
7967	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968	>	(exit $ac_status); }; } &&
7969	>	{ ac_try='test -s conftest.$ac_objext'
7970	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971	>	(eval $ac_try) 2>&5
7972	>	ac_status=$?
7973	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974	>	(exit $ac_status); }; }; then
7975	>	ac_cv_c_restrict=$ac_kw; break
7976	>	else
7977	>	echo "$as_me: failed program was:" >&5
7978	>	sed 's/^/| /' conftest.$ac_ext >&5
7979	>
7980	>	fi
7981	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982	>	done
7983	>
7984	>	fi
7985	>	echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986	>	echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987	>	case $ac_cv_c_restrict in
7988	>	restrict) ;;
7989	>	no)
7990	>	cat >>confdefs.h <<\_ACEOF
7991	>	#define restrict
7992	>	_ACEOF
7993	>	;;
7994	>	*)  cat >>confdefs.h <<_ACEOF
7995	>	#define restrict $ac_cv_c_restrict
7996	>	_ACEOF
7997	>	;;
7998	>	esac
7999	>
8000	>	echo "$as_me:$LINENO: checking for size_t" >&5
8001	>	echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002	>	if test "${ac_cv_type_size_t+set}" = set; then
8003	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8004	>	else
8005	>	cat >conftest.$ac_ext <<_ACEOF
8006	>	/* confdefs.h.  */
8007	>	_ACEOF
8008	>	cat confdefs.h >>conftest.$ac_ext
8009	>	cat >>conftest.$ac_ext <<_ACEOF
8010	>	/* end confdefs.h.  */
8011	>	$ac_includes_default
8012	>	#ifdef FC_DUMMY_MAIN
8013	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8014	>	#  ifdef __cplusplus
8015	>	extern "C"
8016	>	#  endif
8017	>	int FC_DUMMY_MAIN() { return 1; }
8018	>	#endif
8019	>	#endif
8020	>	int
8021	>	main ()
8022	>	{
8023	>	if ((size_t *) 0)
8024	>	return 0;
8025	>	if (sizeof (size_t))
8026	>	return 0;
8027	>	;
8028	>	return 0;
8029	>	}
8030	>	_ACEOF
8031	>	rm -f conftest.$ac_objext
8032	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033	>	(eval $ac_compile) 2>conftest.er1
8034	>	ac_status=$?
8035	>	grep -v '^ *+' conftest.er1 >conftest.err
8036	>	rm -f conftest.er1
8037	>	cat conftest.err >&5
8038	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039	>	(exit $ac_status); } &&
8040	>	{ ac_try='test -z "$ac_c_werror_flag"
8041	>	|| test ! -s conftest.err'
8042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043	>	(eval $ac_try) 2>&5
8044	>	ac_status=$?
8045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046	>	(exit $ac_status); }; } &&
8047	>	{ ac_try='test -s conftest.$ac_objext'
8048	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049	>	(eval $ac_try) 2>&5
8050	>	ac_status=$?
8051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052	>	(exit $ac_status); }; }; then
8053	>	ac_cv_type_size_t=yes
8054	>	else
8055	>	echo "$as_me: failed program was:" >&5
8056	>	sed 's/^/| /' conftest.$ac_ext >&5
8057	>
8058	>	ac_cv_type_size_t=no
8059	>	fi
8060	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061	>	fi
8062	>	echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063	>	echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064	>	if test $ac_cv_type_size_t = yes; then
8065	>	:
8066	>	else
8067	>
8068	>	cat >>confdefs.h <<_ACEOF
8069	>	#define size_t unsigned
8070	>	_ACEOF
8071	>
8072	>	fi
8073	>
8074	>	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075	>	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076	>	if test "${ac_cv_header_time+set}" = set; then
8077	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8078	>	else
8079	>	cat >conftest.$ac_ext <<_ACEOF
8080	>	/* confdefs.h.  */
8081	>	_ACEOF
8082	>	cat confdefs.h >>conftest.$ac_ext
8083	>	cat >>conftest.$ac_ext <<_ACEOF
8084	>	/* end confdefs.h.  */
8085	>	#include <sys/types.h>
8086	>	#include <sys/time.h>
8087	>	#include <time.h>
8088	>
8089	>	#ifdef FC_DUMMY_MAIN
8090	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8091	>	#  ifdef __cplusplus
8092	>	extern "C"
8093	>	#  endif
8094	>	int FC_DUMMY_MAIN() { return 1; }
8095	>	#endif
8096	>	#endif
8097	>	int
8098	>	main ()
8099	>	{
8100	>	if ((struct tm *) 0)
8101	>	return 0;
8102	>	;
8103	>	return 0;
8104	>	}
8105	>	_ACEOF
8106	>	rm -f conftest.$ac_objext
8107	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108	>	(eval $ac_compile) 2>conftest.er1
8109	>	ac_status=$?
8110	>	grep -v '^ *+' conftest.er1 >conftest.err
8111	>	rm -f conftest.er1
8112	>	cat conftest.err >&5
8113	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114	>	(exit $ac_status); } &&
8115	>	{ ac_try='test -z "$ac_c_werror_flag"
8116	>	|| test ! -s conftest.err'
8117	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118	>	(eval $ac_try) 2>&5
8119	>	ac_status=$?
8120	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121	>	(exit $ac_status); }; } &&
8122	>	{ ac_try='test -s conftest.$ac_objext'
8123	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124	>	(eval $ac_try) 2>&5
8125	>	ac_status=$?
8126	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127	>	(exit $ac_status); }; }; then
8128	>	ac_cv_header_time=yes
8129	>	else
8130	>	echo "$as_me: failed program was:" >&5
8131	>	sed 's/^/| /' conftest.$ac_ext >&5
8132	>
8133	>	ac_cv_header_time=no
8134	>	fi
8135	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136	>	fi
8137	>	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138	>	echo "${ECHO_T}$ac_cv_header_time" >&6
8139	>	if test $ac_cv_header_time = yes; then
8140	>
8141	>	cat >>confdefs.h <<\_ACEOF
8142	>	#define TIME_WITH_SYS_TIME 1
8143	>	_ACEOF
8144	>
8145	>	fi
8146	>
8147	>	echo "$as_me:$LINENO: checking for clock_t" >&5
8148	>	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149	>	if test "${ac_cv_type_clock_t+set}" = set; then
8150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8151	>	else
8152	>	cat >conftest.$ac_ext <<_ACEOF
8153	>	/* confdefs.h.  */
8154	>	_ACEOF
8155	>	cat confdefs.h >>conftest.$ac_ext
8156	>	cat >>conftest.$ac_ext <<_ACEOF
8157	>	/* end confdefs.h.  */
8158	>	$ac_includes_default
8159	>	#ifdef FC_DUMMY_MAIN
8160	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8161	>	#  ifdef __cplusplus
8162	>	extern "C"
8163	>	#  endif
8164	>	int FC_DUMMY_MAIN() { return 1; }
8165	>	#endif
8166	>	#endif
8167	>	int
8168	>	main ()
8169	>	{
8170	>	if ((clock_t *) 0)
8171	>	return 0;
8172	>	if (sizeof (clock_t))
8173	>	return 0;
8174	>	;
8175	>	return 0;
8176	>	}
8177	>	_ACEOF
8178	>	rm -f conftest.$ac_objext
8179	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180	>	(eval $ac_compile) 2>conftest.er1
8181	>	ac_status=$?
8182	>	grep -v '^ *+' conftest.er1 >conftest.err
8183	>	rm -f conftest.er1
8184	>	cat conftest.err >&5
8185	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186	>	(exit $ac_status); } &&
8187	>	{ ac_try='test -z "$ac_c_werror_flag"
8188	>	|| test ! -s conftest.err'
8189	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190	>	(eval $ac_try) 2>&5
8191	>	ac_status=$?
8192	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193	>	(exit $ac_status); }; } &&
8194	>	{ ac_try='test -s conftest.$ac_objext'
8195	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196	>	(eval $ac_try) 2>&5
8197	>	ac_status=$?
8198	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199	>	(exit $ac_status); }; }; then
8200	>	ac_cv_type_clock_t=yes
8201	>	else
8202	>	echo "$as_me: failed program was:" >&5
8203	>	sed 's/^/| /' conftest.$ac_ext >&5
8204	>
8205	>	ac_cv_type_clock_t=no
8206	>	fi
8207	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208	>	fi
8209	>	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210	>	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211	>	if test $ac_cv_type_clock_t = yes; then
8212	>
8213	>	cat >>confdefs.h <<_ACEOF
8214	>	#define HAVE_CLOCK_T 1
8215	>	_ACEOF
8216	>
8217	>
8218	>	fi
8219	>
8220	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222	>	if test "${ac_cv_c_const+set}" = set; then
8223	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8224	>	else
8225	>	cat >conftest.$ac_ext <<_ACEOF
8226	>	/* confdefs.h.  */
8227	>	_ACEOF
8228	>	cat confdefs.h >>conftest.$ac_ext
8229	>	cat >>conftest.$ac_ext <<_ACEOF
8230	>	/* end confdefs.h.  */
8231	>
8232	>	#ifdef FC_DUMMY_MAIN
8233	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8234	>	#  ifdef __cplusplus
8235	>	extern "C"
8236	>	#  endif
8237	>	int FC_DUMMY_MAIN() { return 1; }
8238	>	#endif
8239	>	#endif
8240	>	int
8241	>	main ()
8242	>	{
8243	>	/* FIXME: Include the comments suggested by Paul. */
8244	>	#ifndef __cplusplus
8245	>	/* Ultrix mips cc rejects this.  */
8246	>	typedef int charset[2];
8247	>	const charset x;
8248	>	/* SunOS 4.1.1 cc rejects this.  */
8249	>	char const *const *ccp;
8250	>	char **p;
8251	>	/* NEC SVR4.0.2 mips cc rejects this.  */
8252	>	struct point {int x, y;};
8253	>	static struct point const zero = {0,0};
8254	>	/* AIX XL C 1.02.0.0 rejects this.
8255	>	It does not let you subtract one const X* pointer from another in
8256	>	an arm of an if-expression whose if-part is not a constant
8257	>	expression */
8258	>	const char *g = "string";
8259	>	ccp = &g + (g ? g-g : 0);
8260	>	/* HPUX 7.0 cc rejects these. */
8261	>	++ccp;
8262	>	p = (char**) ccp;
8263	>	ccp = (char const *const *) p;
8264	>	{ /* SCO 3.2v4 cc rejects this.  */
8265	>	char *t;
8266	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
8267	>
8268	>	*t++ = 0;
8269	>	}
8270	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271	>	int x[] = {25, 17};
8272	>	const int *foo = &x[0];
8273	>	++foo;
8274	>	}
8275	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276	>	typedef const int *iptr;
8277	>	iptr p = 0;
8278	>	++p;
8279	>	}
8280	>	{ /* AIX XL C 1.02.0.0 rejects this saying
8281	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282	>	struct s { int j; const int *ap[3]; };
8283	>	struct s *b; b->j = 5;
8284	>	}
8285	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286	>	const int foo = 10;
8287	>	}
8288	>	#endif
8289	>
8290	>	;
8291	>	return 0;
8292	>	}
8293	>	_ACEOF
8294	>	rm -f conftest.$ac_objext
8295	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296	>	(eval $ac_compile) 2>conftest.er1
8297	>	ac_status=$?
8298	>	grep -v '^ *+' conftest.er1 >conftest.err
8299	>	rm -f conftest.er1
8300	>	cat conftest.err >&5
8301	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302	>	(exit $ac_status); } &&
8303	>	{ ac_try='test -z "$ac_c_werror_flag"
8304	>	|| test ! -s conftest.err'
8305	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306	>	(eval $ac_try) 2>&5
8307	>	ac_status=$?
8308	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309	>	(exit $ac_status); }; } &&
8310	>	{ ac_try='test -s conftest.$ac_objext'
8311	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312	>	(eval $ac_try) 2>&5
8313	>	ac_status=$?
8314	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315	>	(exit $ac_status); }; }; then
8316	>	ac_cv_c_const=yes
8317	>	else
8318	>	echo "$as_me: failed program was:" >&5
8319	>	sed 's/^/| /' conftest.$ac_ext >&5
8320	>
8321	>	ac_cv_c_const=no
8322	>	fi
8323	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324	>	fi
8325	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326	>	echo "${ECHO_T}$ac_cv_c_const" >&6
8327	>	if test $ac_cv_c_const = no; then
8328	>
8329	>	cat >>confdefs.h <<\_ACEOF
8330	>	#define const
8331	>	_ACEOF
8332	>
8333	>	fi
8334	>
8335	>	echo "$as_me:$LINENO: checking for inline" >&5
8336	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337	>	if test "${ac_cv_c_inline+set}" = set; then
8338	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8339	>	else
8340	>	ac_cv_c_inline=no
8341	>	for ac_kw in inline __inline__ __inline; do
8342	>	cat >conftest.$ac_ext <<_ACEOF
8343	>	/* confdefs.h.  */
8344	>	_ACEOF
8345	>	cat confdefs.h >>conftest.$ac_ext
8346	>	cat >>conftest.$ac_ext <<_ACEOF
8347	>	/* end confdefs.h.  */
8348	>	#ifndef __cplusplus
8349	>	typedef int foo_t;
8350	>	static $ac_kw foo_t static_foo () {return 0; }
8351	>	$ac_kw foo_t foo () {return 0; }
8352	>	#endif
8353	>
8354	>	_ACEOF
8355	>	rm -f conftest.$ac_objext
8356	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357	>	(eval $ac_compile) 2>conftest.er1
8358	>	ac_status=$?
8359	>	grep -v '^ *+' conftest.er1 >conftest.err
8360	>	rm -f conftest.er1
8361	>	cat conftest.err >&5
8362	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363	>	(exit $ac_status); } &&
8364	>	{ ac_try='test -z "$ac_c_werror_flag"
8365	>	|| test ! -s conftest.err'
8366	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367	>	(eval $ac_try) 2>&5
8368	>	ac_status=$?
8369	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370	>	(exit $ac_status); }; } &&
8371	>	{ ac_try='test -s conftest.$ac_objext'
8372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373	>	(eval $ac_try) 2>&5
8374	>	ac_status=$?
8375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376	>	(exit $ac_status); }; }; then
8377	>	ac_cv_c_inline=$ac_kw; break
8378	>	else
8379	>	echo "$as_me: failed program was:" >&5
8380	>	sed 's/^/| /' conftest.$ac_ext >&5
8381	>
8382	>	fi
8383	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384	>	done
8385	>
8386	>	fi
8387	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
8389	>
8390	>
8391	>	case $ac_cv_c_inline in
8392	>	inline | yes) ;;
8393	>	*)
8394	>	case $ac_cv_c_inline in
8395	>	no) ac_val=;;
8396	>	*) ac_val=$ac_cv_c_inline;;
8397	>	esac
8398	>	cat >>confdefs.h <<_ACEOF
8399	>	#ifndef __cplusplus
8400	>	#define inline $ac_val
8401	>	#endif
8402	>	_ACEOF
8403	>	;;
8404	>	esac
8405	>
8406	>
8407	>	# Checks for library functions.
8408	>
8409	>	for ac_header in stdlib.h
8410	>	do
8411	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8414	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8417	>	fi
8418	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420	>	else
8421	>	# Is the header compilable?
8422	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424	>	cat >conftest.$ac_ext <<_ACEOF
8425	>	/* confdefs.h.  */
8426	>	_ACEOF
8427	>	cat confdefs.h >>conftest.$ac_ext
8428	>	cat >>conftest.$ac_ext <<_ACEOF
8429	>	/* end confdefs.h.  */
8430	>	$ac_includes_default
8431	>	#include <$ac_header>
8432	>	_ACEOF
8433	>	rm -f conftest.$ac_objext
8434	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435	>	(eval $ac_compile) 2>conftest.er1
8436	>	ac_status=$?
8437	>	grep -v '^ *+' conftest.er1 >conftest.err
8438	>	rm -f conftest.er1
8439	>	cat conftest.err >&5
8440	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441	>	(exit $ac_status); } &&
8442	>	{ ac_try='test -z "$ac_c_werror_flag"
8443	>	|| test ! -s conftest.err'
8444	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445	>	(eval $ac_try) 2>&5
8446	>	ac_status=$?
8447	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448	>	(exit $ac_status); }; } &&
8449	>	{ ac_try='test -s conftest.$ac_objext'
8450	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451	>	(eval $ac_try) 2>&5
8452	>	ac_status=$?
8453	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454	>	(exit $ac_status); }; }; then
8455	>	ac_header_compiler=yes
8456	>	else
8457	>	echo "$as_me: failed program was:" >&5
8458	>	sed 's/^/| /' conftest.$ac_ext >&5
8459	>
8460	>	ac_header_compiler=no
8461	>	fi
8462	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464	>	echo "${ECHO_T}$ac_header_compiler" >&6
8465	>
8466	>	# Is the header present?
8467	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469	>	cat >conftest.$ac_ext <<_ACEOF
8470	>	/* confdefs.h.  */
8471	>	_ACEOF
8472	>	cat confdefs.h >>conftest.$ac_ext
8473	>	cat >>conftest.$ac_ext <<_ACEOF
8474	>	/* end confdefs.h.  */
8475	>	#include <$ac_header>
8476	>	_ACEOF
8477	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479	>	ac_status=$?
8480	>	grep -v '^ *+' conftest.er1 >conftest.err
8481	>	rm -f conftest.er1
8482	>	cat conftest.err >&5
8483	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484	>	(exit $ac_status); } >/dev/null; then
8485	>	if test -s conftest.err; then
8486	>	ac_cpp_err=$ac_c_preproc_warn_flag
8487	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488	>	else
8489	>	ac_cpp_err=
8490	>	fi
8491	>	else
8492	>	ac_cpp_err=yes
8493	>	fi
8494	>	if test -z "$ac_cpp_err"; then
8495	>	ac_header_preproc=yes
8496	>	else
8497	>	echo "$as_me: failed program was:" >&5
8498	>	sed 's/^/| /' conftest.$ac_ext >&5
8499	>
8500	>	ac_header_preproc=no
8501	>	fi
8502	>	rm -f conftest.err conftest.$ac_ext
8503	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504	>	echo "${ECHO_T}$ac_header_preproc" >&6
8505	>
8506	>	# So?  What about this header?
8507	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508	>	yes:no: )
8509	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513	>	ac_header_preproc=yes
8514	>	;;
8515	>	no:yes:* )
8516	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528	>	(
8529	>	cat <<\_ASBOX
8530	>	## ------------------------------ ##
8531	>	## Report this to gezelter@nd.edu ##
8532	>	## ------------------------------ ##
8533	>	_ASBOX
8534	>	) |
8535	>	sed "s/^/$as_me: WARNING:     /" >&2
8536	>	;;
8537	>	esac
8538	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8539	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8542	>	else
8543	>	eval "$as_ac_Header=\$ac_header_preproc"
8544	>	fi
8545	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547	>
8548	>	fi
8549	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550	>	cat >>confdefs.h <<_ACEOF
8551	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552	>	_ACEOF
8553	>
8554	>	fi
8555	>
8556	>	done
8557	>
8558	>	echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559	>	echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8562	>	else
8563	>	if test "$cross_compiling" = yes; then
8564	>	ac_cv_func_malloc_0_nonnull=no
8565	>	else
8566	>	cat >conftest.$ac_ext <<_ACEOF
8567	>	/* confdefs.h.  */
8568	>	_ACEOF
8569	>	cat confdefs.h >>conftest.$ac_ext
8570	>	cat >>conftest.$ac_ext <<_ACEOF
8571	>	/* end confdefs.h.  */
8572	>	#if STDC_HEADERS || HAVE_STDLIB_H
8573	>	# include <stdlib.h>
8574	>	#else
8575	>	char *malloc ();
8576	>	#endif
8577	>
8578	>	#ifdef FC_DUMMY_MAIN
8579	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8580	>	#  ifdef __cplusplus
8581	>	extern "C"
8582	>	#  endif
8583	>	int FC_DUMMY_MAIN() { return 1; }
8584	>	#endif
8585	>	#endif
8586	>	int
8587	>	main ()
8588	>	{
8589	>	exit (malloc (0) ? 0 : 1);
8590	>	;
8591	>	return 0;
8592	>	}
8593	>	_ACEOF
8594	>	rm -f conftest$ac_exeext
8595	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596	>	(eval $ac_link) 2>&5
8597	>	ac_status=$?
8598	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601	>	(eval $ac_try) 2>&5
8602	>	ac_status=$?
8603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604	>	(exit $ac_status); }; }; then
8605	>	ac_cv_func_malloc_0_nonnull=yes
8606	>	else
8607	>	echo "$as_me: program exited with status $ac_status" >&5
8608	>	echo "$as_me: failed program was:" >&5
8609	>	sed 's/^/| /' conftest.$ac_ext >&5
8610	>
8611	>	( exit $ac_status )
8612	>	ac_cv_func_malloc_0_nonnull=no
8613	>	fi
8614	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615	>	fi
8616	>	fi
8617	>	echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618	>	echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619	>	if test $ac_cv_func_malloc_0_nonnull = yes; then
8620	>
8621	>	cat >>confdefs.h <<\_ACEOF
8622	>	#define HAVE_MALLOC 1
8623	>	_ACEOF
8624	>
8625	>	else
8626	>	cat >>confdefs.h <<\_ACEOF
8627	>	#define HAVE_MALLOC 0
8628	>	_ACEOF
8629	>
8630	>	case $LIBOBJS in
8631	>	"malloc.$ac_objext"   | \
8632	>	*" malloc.$ac_objext"   | \
8633	>	"malloc.$ac_objext "* | \
8634	>	*" malloc.$ac_objext "* ) ;;
8635	>	*) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636	>	esac
8637	>
8638	>
8639	>	cat >>confdefs.h <<\_ACEOF
8640	>	#define malloc rpl_malloc
8641	>	_ACEOF
8642	>
8643	>	fi
8644	>
8645	>
8646	>
8647	>	echo "$as_me:$LINENO: checking for working memcmp" >&5
8648	>	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649	>	if test "${ac_cv_func_memcmp_working+set}" = set; then
8650	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8651	>	else
8652	>	if test "$cross_compiling" = yes; then
8653	>	ac_cv_func_memcmp_working=no
8654	>	else
8655	>	cat >conftest.$ac_ext <<_ACEOF
8656	>	/* confdefs.h.  */
8657	>	_ACEOF
8658	>	cat confdefs.h >>conftest.$ac_ext
8659	>	cat >>conftest.$ac_ext <<_ACEOF
8660	>	/* end confdefs.h.  */
8661	>	$ac_includes_default
8662	>	#ifdef FC_DUMMY_MAIN
8663	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8664	>	#  ifdef __cplusplus
8665	>	extern "C"
8666	>	#  endif
8667	>	int FC_DUMMY_MAIN() { return 1; }
8668	>	#endif
8669	>	#endif
8670	>	int
8671	>	main ()
8672	>	{
8673	>
8674	>	/* Some versions of memcmp are not 8-bit clean.  */
8675	>	char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676	>	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677	>	exit (1);
8678	>
8679	>	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680	>	or more and with at least one buffer not starting on a 4-byte boundary.
8681	>	William Lewis provided this test program.   */
8682	>	{
8683	>	char foo[21];
8684	>	char bar[21];
8685	>	int i;
8686	>	for (i = 0; i < 4; i++)
8687	>	{
8688	>	char *a = foo + i;
8689	>	char *b = bar + i;
8690	>	strcpy (a, "--------01111111");
8691	>	strcpy (b, "--------10000000");
8692	>	if (memcmp (a, b, 16) >= 0)
8693	>	exit (1);
8694	>	}
8695	>	exit (0);
8696	>	}
8697	>
8698	>	;
8699	>	return 0;
8700	>	}
8701	>	_ACEOF
8702	>	rm -f conftest$ac_exeext
8703	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704	>	(eval $ac_link) 2>&5
8705	>	ac_status=$?
8706	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709	>	(eval $ac_try) 2>&5
8710	>	ac_status=$?
8711	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712	>	(exit $ac_status); }; }; then
8713	>	ac_cv_func_memcmp_working=yes
8714	>	else
8715	>	echo "$as_me: program exited with status $ac_status" >&5
8716	>	echo "$as_me: failed program was:" >&5
8717	>	sed 's/^/| /' conftest.$ac_ext >&5
8718	>
8719	>	( exit $ac_status )
8720	>	ac_cv_func_memcmp_working=no
8721	>	fi
8722	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723	>	fi
8724	>	fi
8725	>	echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726	>	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727	>	test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728	>	"memcmp.$ac_objext"   | \
8729	>	*" memcmp.$ac_objext"   | \
8730	>	"memcmp.$ac_objext "* | \
8731	>	*" memcmp.$ac_objext "* ) ;;
8732	>	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733	>	esac
8734	>
8735	>
8736	>
8737	>	for ac_header in stdlib.h
8738	>	do
8739	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8742	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8745	>	fi
8746	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748	>	else
8749	>	# Is the header compilable?
8750	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752	>	cat >conftest.$ac_ext <<_ACEOF
8753	>	/* confdefs.h.  */
8754	>	_ACEOF
8755	>	cat confdefs.h >>conftest.$ac_ext
8756	>	cat >>conftest.$ac_ext <<_ACEOF
8757	>	/* end confdefs.h.  */
8758	>	$ac_includes_default
8759	>	#include <$ac_header>
8760	>	_ACEOF
8761	>	rm -f conftest.$ac_objext
8762	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763	>	(eval $ac_compile) 2>conftest.er1
8764	>	ac_status=$?
8765	>	grep -v '^ *+' conftest.er1 >conftest.err
8766	>	rm -f conftest.er1
8767	>	cat conftest.err >&5
8768	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769	>	(exit $ac_status); } &&
8770	>	{ ac_try='test -z "$ac_c_werror_flag"
8771	>	|| test ! -s conftest.err'
8772	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773	>	(eval $ac_try) 2>&5
8774	>	ac_status=$?
8775	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776	>	(exit $ac_status); }; } &&
8777	>	{ ac_try='test -s conftest.$ac_objext'
8778	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779	>	(eval $ac_try) 2>&5
8780	>	ac_status=$?
8781	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782	>	(exit $ac_status); }; }; then
8783	>	ac_header_compiler=yes
8784	>	else
8785	>	echo "$as_me: failed program was:" >&5
8786	>	sed 's/^/| /' conftest.$ac_ext >&5
8787	>
8788	>	ac_header_compiler=no
8789	>	fi
8790	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792	>	echo "${ECHO_T}$ac_header_compiler" >&6
8793	>
8794	>	# Is the header present?
8795	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797	>	cat >conftest.$ac_ext <<_ACEOF
8798	>	/* confdefs.h.  */
8799	>	_ACEOF
8800	>	cat confdefs.h >>conftest.$ac_ext
8801	>	cat >>conftest.$ac_ext <<_ACEOF
8802	>	/* end confdefs.h.  */
8803	>	#include <$ac_header>
8804	>	_ACEOF
8805	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807	>	ac_status=$?
8808	>	grep -v '^ *+' conftest.er1 >conftest.err
8809	>	rm -f conftest.er1
8810	>	cat conftest.err >&5
8811	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812	>	(exit $ac_status); } >/dev/null; then
8813	>	if test -s conftest.err; then
8814	>	ac_cpp_err=$ac_c_preproc_warn_flag
8815	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816	>	else
8817	>	ac_cpp_err=
8818	>	fi
8819	>	else
8820	>	ac_cpp_err=yes
8821	>	fi
8822	>	if test -z "$ac_cpp_err"; then
8823	>	ac_header_preproc=yes
8824	>	else
8825	>	echo "$as_me: failed program was:" >&5
8826	>	sed 's/^/| /' conftest.$ac_ext >&5
8827	>
8828	>	ac_header_preproc=no
8829	>	fi
8830	>	rm -f conftest.err conftest.$ac_ext
8831	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832	>	echo "${ECHO_T}$ac_header_preproc" >&6
8833	>
8834	>	# So?  What about this header?
8835	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836	>	yes:no: )
8837	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841	>	ac_header_preproc=yes
8842	>	;;
8843	>	no:yes:* )
8844	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856	>	(
8857	>	cat <<\_ASBOX
8858	>	## ------------------------------ ##
8859	>	## Report this to gezelter@nd.edu ##
8860	>	## ------------------------------ ##
8861	>	_ASBOX
8862	>	) |
8863	>	sed "s/^/$as_me: WARNING:     /" >&2
8864	>	;;
8865	>	esac
8866	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8867	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8870	>	else
8871	>	eval "$as_ac_Header=\$ac_header_preproc"
8872	>	fi
8873	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875	>
8876	>	fi
8877	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878	>	cat >>confdefs.h <<_ACEOF
8879	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880	>	_ACEOF
8881	>
8882	>	fi
8883	>
8884	>	done
8885	>
8886	>	echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887	>	echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8890	>	else
8891	>	if test "$cross_compiling" = yes; then
8892	>	ac_cv_func_realloc_0_nonnull=no
8893	>	else
8894	>	cat >conftest.$ac_ext <<_ACEOF
8895	>	/* confdefs.h.  */
8896	>	_ACEOF
8897	>	cat confdefs.h >>conftest.$ac_ext
8898	>	cat >>conftest.$ac_ext <<_ACEOF
8899	>	/* end confdefs.h.  */
8900	>	#if STDC_HEADERS || HAVE_STDLIB_H
8901	>	# include <stdlib.h>
8902	>	#else
8903	>	char *realloc ();
8904	>	#endif
8905	>
8906	>	#ifdef FC_DUMMY_MAIN
8907	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8908	>	#  ifdef __cplusplus
8909	>	extern "C"
8910	>	#  endif
8911	>	int FC_DUMMY_MAIN() { return 1; }
8912	>	#endif
8913	>	#endif
8914	>	int
8915	>	main ()
8916	>	{
8917	>	exit (realloc (0, 0) ? 0 : 1);
8918	>	;
8919	>	return 0;
8920	>	}
8921	>	_ACEOF
8922	>	rm -f conftest$ac_exeext
8923	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924	>	(eval $ac_link) 2>&5
8925	>	ac_status=$?
8926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929	>	(eval $ac_try) 2>&5
8930	>	ac_status=$?
8931	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932	>	(exit $ac_status); }; }; then
8933	>	ac_cv_func_realloc_0_nonnull=yes
8934	>	else
8935	>	echo "$as_me: program exited with status $ac_status" >&5
8936	>	echo "$as_me: failed program was:" >&5
8937	>	sed 's/^/| /' conftest.$ac_ext >&5
8938	>
8939	>	( exit $ac_status )
8940	>	ac_cv_func_realloc_0_nonnull=no
8941	>	fi
8942	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943	>	fi
8944	>	fi
8945	>	echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946	>	echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947	>	if test $ac_cv_func_realloc_0_nonnull = yes; then
8948	>
8949	>	cat >>confdefs.h <<\_ACEOF
8950	>	#define HAVE_REALLOC 1
8951	>	_ACEOF
8952	>
8953	>	else
8954	>	cat >>confdefs.h <<\_ACEOF
8955	>	#define HAVE_REALLOC 0
8956	>	_ACEOF
8957	>
8958	>	case $LIBOBJS in
8959	>	"realloc.$ac_objext"   | \
8960	>	*" realloc.$ac_objext"   | \
8961	>	"realloc.$ac_objext "* | \
8962	>	*" realloc.$ac_objext "* ) ;;
8963	>	*) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964	>	esac
8965	>
8966	>
8967	>	cat >>confdefs.h <<\_ACEOF
8968	>	#define realloc rpl_realloc
8969	>	_ACEOF
8970	>
8971	>	fi
8972	>
8973	>
8974	>
8975	>
8976	>
8977	>	for ac_header in sys/select.h sys/socket.h
8978	>	do
8979	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8982	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8985	>	fi
8986	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988	>	else
8989	>	# Is the header compilable?
8990	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992	>	cat >conftest.$ac_ext <<_ACEOF
8993	>	/* confdefs.h.  */
8994	>	_ACEOF
8995	>	cat confdefs.h >>conftest.$ac_ext
8996	>	cat >>conftest.$ac_ext <<_ACEOF
8997	>	/* end confdefs.h.  */
8998	>	$ac_includes_default
8999	>	#include <$ac_header>
9000	>	_ACEOF
9001	>	rm -f conftest.$ac_objext
9002	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003	>	(eval $ac_compile) 2>conftest.er1
9004	>	ac_status=$?
9005	>	grep -v '^ *+' conftest.er1 >conftest.err
9006	>	rm -f conftest.er1
9007	>	cat conftest.err >&5
9008	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009	>	(exit $ac_status); } &&
9010	>	{ ac_try='test -z "$ac_c_werror_flag"
9011	>	|| test ! -s conftest.err'
9012	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013	>	(eval $ac_try) 2>&5
9014	>	ac_status=$?
9015	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016	>	(exit $ac_status); }; } &&
9017	>	{ ac_try='test -s conftest.$ac_objext'
9018	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019	>	(eval $ac_try) 2>&5
9020	>	ac_status=$?
9021	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022	>	(exit $ac_status); }; }; then
9023	>	ac_header_compiler=yes
9024	>	else
9025	>	echo "$as_me: failed program was:" >&5
9026	>	sed 's/^/| /' conftest.$ac_ext >&5
9027	>
9028	>	ac_header_compiler=no
9029	>	fi
9030	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032	>	echo "${ECHO_T}$ac_header_compiler" >&6
9033	>
9034	>	# Is the header present?
9035	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037	>	cat >conftest.$ac_ext <<_ACEOF
9038	>	/* confdefs.h.  */
9039	>	_ACEOF
9040	>	cat confdefs.h >>conftest.$ac_ext
9041	>	cat >>conftest.$ac_ext <<_ACEOF
9042	>	/* end confdefs.h.  */
9043	>	#include <$ac_header>
9044	>	_ACEOF
9045	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047	>	ac_status=$?
9048	>	grep -v '^ *+' conftest.er1 >conftest.err
9049	>	rm -f conftest.er1
9050	>	cat conftest.err >&5
9051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052	>	(exit $ac_status); } >/dev/null; then
9053	>	if test -s conftest.err; then
9054	>	ac_cpp_err=$ac_c_preproc_warn_flag
9055	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056	>	else
9057	>	ac_cpp_err=
9058	>	fi
9059	>	else
9060	>	ac_cpp_err=yes
9061	>	fi
9062	>	if test -z "$ac_cpp_err"; then
9063	>	ac_header_preproc=yes
9064	>	else
9065	>	echo "$as_me: failed program was:" >&5
9066	>	sed 's/^/| /' conftest.$ac_ext >&5
9067	>
9068	>	ac_header_preproc=no
9069	>	fi
9070	>	rm -f conftest.err conftest.$ac_ext
9071	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072	>	echo "${ECHO_T}$ac_header_preproc" >&6
9073	>
9074	>	# So?  What about this header?
9075	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076	>	yes:no: )
9077	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081	>	ac_header_preproc=yes
9082	>	;;
9083	>	no:yes:* )
9084	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096	>	(
9097	>	cat <<\_ASBOX
9098	>	## ------------------------------ ##
9099	>	## Report this to gezelter@nd.edu ##
9100	>	## ------------------------------ ##
9101	>	_ASBOX
9102	>	) |
9103	>	sed "s/^/$as_me: WARNING:     /" >&2
9104	>	;;
9105	>	esac
9106	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9107	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9110	>	else
9111	>	eval "$as_ac_Header=\$ac_header_preproc"
9112	>	fi
9113	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115	>
9116	>	fi
9117	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118	>	cat >>confdefs.h <<_ACEOF
9119	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120	>	_ACEOF
9121	>
9122	>	fi
9123	>
9124	>	done
9125	>
9126	>	echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127	>	echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128	>	if test "${ac_cv_func_select_args+set}" = set; then
9129	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9130	>	else
9131	>	for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132	>	for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133	>	for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134	>	cat >conftest.$ac_ext <<_ACEOF
9135	>	/* confdefs.h.  */
9136	>	_ACEOF
9137	>	cat confdefs.h >>conftest.$ac_ext
9138	>	cat >>conftest.$ac_ext <<_ACEOF
9139	>	/* end confdefs.h.  */
9140	>	$ac_includes_default
9141	>	#if HAVE_SYS_SELECT_H
9142	>	# include <sys/select.h>
9143	>	#endif
9144	>	#if HAVE_SYS_SOCKET_H
9145	>	# include <sys/socket.h>
9146	>	#endif
9147	>
9148	>	#ifdef FC_DUMMY_MAIN
9149	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9150	>	#  ifdef __cplusplus
9151	>	extern "C"
9152	>	#  endif
9153	>	int FC_DUMMY_MAIN() { return 1; }
9154	>	#endif
9155	>	#endif
9156	>	int
9157	>	main ()
9158	>	{
9159	>	extern int select ($ac_arg1,
9160	>	$ac_arg234, $ac_arg234, $ac_arg234,
9161	>	$ac_arg5);
9162	>	;
9163	>	return 0;
9164	>	}
9165	>	_ACEOF
9166	>	rm -f conftest.$ac_objext
9167	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168	>	(eval $ac_compile) 2>conftest.er1
9169	>	ac_status=$?
9170	>	grep -v '^ *+' conftest.er1 >conftest.err
9171	>	rm -f conftest.er1
9172	>	cat conftest.err >&5
9173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174	>	(exit $ac_status); } &&
9175	>	{ ac_try='test -z "$ac_c_werror_flag"
9176	>	|| test ! -s conftest.err'
9177	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178	>	(eval $ac_try) 2>&5
9179	>	ac_status=$?
9180	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181	>	(exit $ac_status); }; } &&
9182	>	{ ac_try='test -s conftest.$ac_objext'
9183	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184	>	(eval $ac_try) 2>&5
9185	>	ac_status=$?
9186	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187	>	(exit $ac_status); }; }; then
9188	>	ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189	>	else
9190	>	echo "$as_me: failed program was:" >&5
9191	>	sed 's/^/| /' conftest.$ac_ext >&5
9192	>
9193	>	fi
9194	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195	>	done
9196	>	done
9197	>	done
9198	>	# Provide a safe default value.
9199	>	: ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200	>
9201	>	fi
9202	>	echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203	>	echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204	>	ac_save_IFS=$IFS; IFS=','
9205	>	set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206	>	IFS=$ac_save_IFS
9207	>	shift
9208	>
9209	>	cat >>confdefs.h <<_ACEOF
9210	>	#define SELECT_TYPE_ARG1 $1
9211	>	_ACEOF
9212	>
9213	>
9214	>	cat >>confdefs.h <<_ACEOF
9215	>	#define SELECT_TYPE_ARG234 ($2)
9216	>	_ACEOF
9217	>
9218	>
9219	>	cat >>confdefs.h <<_ACEOF
9220	>	#define SELECT_TYPE_ARG5 ($3)
9221	>	_ACEOF
9222	>
9223	>	rm -f conftest*
9224	>
9225	>
9226	>	for ac_func in strftime
9227	>	do
9228	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9230	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9232	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9233	>	else
9234	>	cat >conftest.$ac_ext <<_ACEOF
9235	>	/* confdefs.h.  */
9236	>	_ACEOF
9237	>	cat confdefs.h >>conftest.$ac_ext
9238	>	cat >>conftest.$ac_ext <<_ACEOF
9239	>	/* end confdefs.h.  */
9240	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242	>	#define $ac_func innocuous_$ac_func
9243	>
9244	>	/* System header to define __stub macros and hopefully few prototypes,
9245	>	which can conflict with char $ac_func (); below.
9246	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247	>	<limits.h> exists even on freestanding compilers.  */
9248	>
9249	>	#ifdef __STDC__
9250	>	# include <limits.h>
9251	>	#else
9252	>	# include <assert.h>
9253	>	#endif
9254	>
9255	>	#undef $ac_func
9256	>
9257	>	/* Override any gcc2 internal prototype to avoid an error.  */
9258	>	#ifdef __cplusplus
9259	>	extern "C"
9260	>	{
9261	>	#endif
9262	>	/* We use char because int might match the return type of a gcc2
9263	>	builtin and then its argument prototype would still apply.  */
9264	>	char $ac_func ();
9265	>	/* The GNU C library defines this for functions which it implements
9266	>	to always fail with ENOSYS.  Some functions are actually named
9267	>	something starting with __ and the normal name is an alias.  */
9268	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269	>	choke me
9270	>	#else
9271	>	char (*f) () = $ac_func;
9272	>	#endif
9273	>	#ifdef __cplusplus
9274	>	}
9275	>	#endif
9276	>
9277	>	#ifdef FC_DUMMY_MAIN
9278	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9279	>	#  ifdef __cplusplus
9280	>	extern "C"
9281	>	#  endif
9282	>	int FC_DUMMY_MAIN() { return 1; }
9283	>	#endif
9284	>	#endif
9285	>	int
9286	>	main ()
9287	>	{
9288	>	return f != $ac_func;
9289	>	;
9290	>	return 0;
9291	>	}
9292	>	_ACEOF
9293	>	rm -f conftest.$ac_objext conftest$ac_exeext
9294	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295	>	(eval $ac_link) 2>conftest.er1
9296	>	ac_status=$?
9297	>	grep -v '^ *+' conftest.er1 >conftest.err
9298	>	rm -f conftest.er1
9299	>	cat conftest.err >&5
9300	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301	>	(exit $ac_status); } &&
9302	>	{ ac_try='test -z "$ac_c_werror_flag"
9303	>	|| test ! -s conftest.err'
9304	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305	>	(eval $ac_try) 2>&5
9306	>	ac_status=$?
9307	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308	>	(exit $ac_status); }; } &&
9309	>	{ ac_try='test -s conftest$ac_exeext'
9310	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311	>	(eval $ac_try) 2>&5
9312	>	ac_status=$?
9313	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314	>	(exit $ac_status); }; }; then
9315	>	eval "$as_ac_var=yes"
9316	>	else
9317	>	echo "$as_me: failed program was:" >&5
9318	>	sed 's/^/| /' conftest.$ac_ext >&5
9319	>
9320	>	eval "$as_ac_var=no"
9321	>	fi
9322	>	rm -f conftest.err conftest.$ac_objext \
9323	>	conftest$ac_exeext conftest.$ac_ext
9324	>	fi
9325	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9328	>	cat >>confdefs.h <<_ACEOF
9329	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330	>	_ACEOF
9331	>
9332	>	else
9333	>	# strftime is in -lintl on SCO UNIX.
9334	>	echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335	>	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336	>	if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9338	>	else
9339	>	ac_check_lib_save_LIBS=$LIBS
9340	>	LIBS="-lintl  $LIBS"
9341	>	cat >conftest.$ac_ext <<_ACEOF
9342	>	/* confdefs.h.  */
9343	>	_ACEOF
9344	>	cat confdefs.h >>conftest.$ac_ext
9345	>	cat >>conftest.$ac_ext <<_ACEOF
9346	>	/* end confdefs.h.  */
9347	>
9348	>	/* Override any gcc2 internal prototype to avoid an error.  */
9349	>	#ifdef __cplusplus
9350	>	extern "C"
9351	>	#endif
9352	>	/* We use char because int might match the return type of a gcc2
9353	>	builtin and then its argument prototype would still apply.  */
9354	>	char strftime ();
9355	>	#ifdef FC_DUMMY_MAIN
9356	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9357	>	#  ifdef __cplusplus
9358	>	extern "C"
9359	>	#  endif
9360	>	int FC_DUMMY_MAIN() { return 1; }
9361	>	#endif
9362	>	#endif
9363	>	int
9364	>	main ()
9365	>	{
9366	>	strftime ();
9367	>	;
9368	>	return 0;
9369	>	}
9370	>	_ACEOF
9371	>	rm -f conftest.$ac_objext conftest$ac_exeext
9372	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373	>	(eval $ac_link) 2>conftest.er1
9374	>	ac_status=$?
9375	>	grep -v '^ *+' conftest.er1 >conftest.err
9376	>	rm -f conftest.er1
9377	>	cat conftest.err >&5
9378	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379	>	(exit $ac_status); } &&
9380	>	{ ac_try='test -z "$ac_c_werror_flag"
9381	>	|| test ! -s conftest.err'
9382	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383	>	(eval $ac_try) 2>&5
9384	>	ac_status=$?
9385	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386	>	(exit $ac_status); }; } &&
9387	>	{ ac_try='test -s conftest$ac_exeext'
9388	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389	>	(eval $ac_try) 2>&5
9390	>	ac_status=$?
9391	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392	>	(exit $ac_status); }; }; then
9393	>	ac_cv_lib_intl_strftime=yes
9394	>	else
9395	>	echo "$as_me: failed program was:" >&5
9396	>	sed 's/^/| /' conftest.$ac_ext >&5
9397	>
9398	>	ac_cv_lib_intl_strftime=no
9399	>	fi
9400	>	rm -f conftest.err conftest.$ac_objext \
9401	>	conftest$ac_exeext conftest.$ac_ext
9402	>	LIBS=$ac_check_lib_save_LIBS
9403	>	fi
9404	>	echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405	>	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406	>	if test $ac_cv_lib_intl_strftime = yes; then
9407	>	cat >>confdefs.h <<\_ACEOF
9408	>	#define HAVE_STRFTIME 1
9409	>	_ACEOF
9410	>
9411	>	LIBS="-lintl $LIBS"
9412	>	fi
9413	>
9414	>	fi
9415	>	done
9416	>
9417	>	echo "$as_me:$LINENO: checking for working strtod" >&5
9418	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419	>	if test "${ac_cv_func_strtod+set}" = set; then
9420	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9421	>	else
9422	>	if test "$cross_compiling" = yes; then
9423	>	ac_cv_func_strtod=no
9424	>	else
9425	>	cat >conftest.$ac_ext <<_ACEOF
9426	>	/* confdefs.h.  */
9427	>	_ACEOF
9428	>	cat confdefs.h >>conftest.$ac_ext
9429	>	cat >>conftest.$ac_ext <<_ACEOF
9430	>	/* end confdefs.h.  */
9431	>
9432	>	double strtod ();
9433	>	int
9434	>	main()
9435	>	{
9436	>	{
9437	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438	>	char *string = " +69";
9439	>	char *term;
9440	>	double value;
9441	>	value = strtod (string, &term);
9442	>	if (value != 69 || term != (string + 4))
9443	>	exit (1);
9444	>	}
9445	>
9446	>	{
9447	>	/* Under Solaris 2.4, strtod returns the wrong value for the
9448	>	terminating character under some conditions.  */
9449	>	char *string = "NaN";
9450	>	char *term;
9451	>	strtod (string, &term);
9452	>	if (term != string && *(term - 1) == 0)
9453	>	exit (1);
9454	>	}
9455	>	exit (0);
9456	>	}
9457	>
9458	>	_ACEOF
9459	>	rm -f conftest$ac_exeext
9460	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461	>	(eval $ac_link) 2>&5
9462	>	ac_status=$?
9463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466	>	(eval $ac_try) 2>&5
9467	>	ac_status=$?
9468	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469	>	(exit $ac_status); }; }; then
9470	>	ac_cv_func_strtod=yes
9471	>	else
9472	>	echo "$as_me: program exited with status $ac_status" >&5
9473	>	echo "$as_me: failed program was:" >&5
9474	>	sed 's/^/| /' conftest.$ac_ext >&5
9475	>
9476	>	( exit $ac_status )
9477	>	ac_cv_func_strtod=no
9478	>	fi
9479	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480	>	fi
9481	>	fi
9482	>	echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484	>	if test $ac_cv_func_strtod = no; then
9485	>	case $LIBOBJS in
9486	>	"strtod.$ac_objext"   | \
9487	>	*" strtod.$ac_objext"   | \
9488	>	"strtod.$ac_objext "* | \
9489	>	*" strtod.$ac_objext "* ) ;;
9490	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491	>	esac
9492	>
9493	>	echo "$as_me:$LINENO: checking for pow" >&5
9494	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495	>	if test "${ac_cv_func_pow+set}" = set; then
9496	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9497	>	else
9498	>	cat >conftest.$ac_ext <<_ACEOF
9499	>	/* confdefs.h.  */
9500	>	_ACEOF
9501	>	cat confdefs.h >>conftest.$ac_ext
9502	>	cat >>conftest.$ac_ext <<_ACEOF
9503	>	/* end confdefs.h.  */
9504	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506	>	#define pow innocuous_pow
9507	>
9508	>	/* System header to define __stub macros and hopefully few prototypes,
9509	>	which can conflict with char pow (); below.
9510	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511	>	<limits.h> exists even on freestanding compilers.  */
9512	>
9513	>	#ifdef __STDC__
9514	>	# include <limits.h>
9515	>	#else
9516	>	# include <assert.h>
9517	>	#endif
9518	>
9519	>	#undef pow
9520	>
9521	>	/* Override any gcc2 internal prototype to avoid an error.  */
9522	>	#ifdef __cplusplus
9523	>	extern "C"
9524	>	{
9525	>	#endif
9526	>	/* We use char because int might match the return type of a gcc2
9527	>	builtin and then its argument prototype would still apply.  */
9528	>	char pow ();
9529	>	/* The GNU C library defines this for functions which it implements
9530	>	to always fail with ENOSYS.  Some functions are actually named
9531	>	something starting with __ and the normal name is an alias.  */
9532	>	#if defined (__stub_pow) || defined (__stub___pow)
9533	>	choke me
9534	>	#else
9535	>	char (*f) () = pow;
9536	>	#endif
9537	>	#ifdef __cplusplus
9538	>	}
9539	>	#endif
9540	>
9541	>	#ifdef FC_DUMMY_MAIN
9542	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9543	>	#  ifdef __cplusplus
9544	>	extern "C"
9545	>	#  endif
9546	>	int FC_DUMMY_MAIN() { return 1; }
9547	>	#endif
9548	>	#endif
9549	>	int
9550	>	main ()
9551	>	{
9552	>	return f != pow;
9553	>	;
9554	>	return 0;
9555	>	}
9556	>	_ACEOF
9557	>	rm -f conftest.$ac_objext conftest$ac_exeext
9558	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559	>	(eval $ac_link) 2>conftest.er1
9560	>	ac_status=$?
9561	>	grep -v '^ *+' conftest.er1 >conftest.err
9562	>	rm -f conftest.er1
9563	>	cat conftest.err >&5
9564	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565	>	(exit $ac_status); } &&
9566	>	{ ac_try='test -z "$ac_c_werror_flag"
9567	>	|| test ! -s conftest.err'
9568	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569	>	(eval $ac_try) 2>&5
9570	>	ac_status=$?
9571	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572	>	(exit $ac_status); }; } &&
9573	>	{ ac_try='test -s conftest$ac_exeext'
9574	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575	>	(eval $ac_try) 2>&5
9576	>	ac_status=$?
9577	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578	>	(exit $ac_status); }; }; then
9579	>	ac_cv_func_pow=yes
9580	>	else
9581	>	echo "$as_me: failed program was:" >&5
9582	>	sed 's/^/| /' conftest.$ac_ext >&5
9583	>
9584	>	ac_cv_func_pow=no
9585	>	fi
9586	>	rm -f conftest.err conftest.$ac_objext \
9587	>	conftest$ac_exeext conftest.$ac_ext
9588	>	fi
9589	>	echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590	>	echo "${ECHO_T}$ac_cv_func_pow" >&6
9591	>
9592	>	if test $ac_cv_func_pow = no; then
9593	>	echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595	>	if test "${ac_cv_lib_m_pow+set}" = set; then
9596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9597	>	else
9598	>	ac_check_lib_save_LIBS=$LIBS
9599	>	LIBS="-lm  $LIBS"
9600	>	cat >conftest.$ac_ext <<_ACEOF
9601	>	/* confdefs.h.  */
9602	>	_ACEOF
9603	>	cat confdefs.h >>conftest.$ac_ext
9604	>	cat >>conftest.$ac_ext <<_ACEOF
9605	>	/* end confdefs.h.  */
9606	>
9607	>	/* Override any gcc2 internal prototype to avoid an error.  */
9608	>	#ifdef __cplusplus
9609	>	extern "C"
9610	>	#endif
9611	>	/* We use char because int might match the return type of a gcc2
9612	>	builtin and then its argument prototype would still apply.  */
9613	>	char pow ();
9614	>	#ifdef FC_DUMMY_MAIN
9615	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9616	>	#  ifdef __cplusplus
9617	>	extern "C"
9618	>	#  endif
9619	>	int FC_DUMMY_MAIN() { return 1; }
9620	>	#endif
9621	>	#endif
9622	>	int
9623	>	main ()
9624	>	{
9625	>	pow ();
9626	>	;
9627	>	return 0;
9628	>	}
9629	>	_ACEOF
9630	>	rm -f conftest.$ac_objext conftest$ac_exeext
9631	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632	>	(eval $ac_link) 2>conftest.er1
9633	>	ac_status=$?
9634	>	grep -v '^ *+' conftest.er1 >conftest.err
9635	>	rm -f conftest.er1
9636	>	cat conftest.err >&5
9637	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638	>	(exit $ac_status); } &&
9639	>	{ ac_try='test -z "$ac_c_werror_flag"
9640	>	|| test ! -s conftest.err'
9641	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642	>	(eval $ac_try) 2>&5
9643	>	ac_status=$?
9644	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645	>	(exit $ac_status); }; } &&
9646	>	{ ac_try='test -s conftest$ac_exeext'
9647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648	>	(eval $ac_try) 2>&5
9649	>	ac_status=$?
9650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651	>	(exit $ac_status); }; }; then
9652	>	ac_cv_lib_m_pow=yes
9653	>	else
9654	>	echo "$as_me: failed program was:" >&5
9655	>	sed 's/^/| /' conftest.$ac_ext >&5
9656	>
9657	>	ac_cv_lib_m_pow=no
9658	>	fi
9659	>	rm -f conftest.err conftest.$ac_objext \
9660	>	conftest$ac_exeext conftest.$ac_ext
9661	>	LIBS=$ac_check_lib_save_LIBS
9662	>	fi
9663	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665	>	if test $ac_cv_lib_m_pow = yes; then
9666	>	POW_LIB=-lm
9667	>	else
9668	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670	>	fi
9671	>
9672	>	fi
9673	>
9674	>	fi
9675	>
9676	>
9677	>
9678	>
9679	>
9680	>
9681	>
9682	>
9683	>
9684	>
9685	>
9686	>
9687	>
9688	>
9689	>
9690	>
9691	>
9692	>
9693	>
9694	>
9695	>
9696	>
9697	>
9698	>
9699	>
9700	>
9701	>
9702	>
9703	>	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
9704	>	do
9705	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9707	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9709	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9710	>	else
9711	>	cat >conftest.$ac_ext <<_ACEOF
9712	>	/* confdefs.h.  */
9713	>	_ACEOF
9714	>	cat confdefs.h >>conftest.$ac_ext
9715	>	cat >>conftest.$ac_ext <<_ACEOF
9716	>	/* end confdefs.h.  */
9717	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719	>	#define $ac_func innocuous_$ac_func
9720	>
9721	>	/* System header to define __stub macros and hopefully few prototypes,
9722	>	which can conflict with char $ac_func (); below.
9723	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724	>	<limits.h> exists even on freestanding compilers.  */
9725	>
9726	>	#ifdef __STDC__
9727	>	# include <limits.h>
9728	>	#else
9729	>	# include <assert.h>
9730	>	#endif
9731	>
9732	>	#undef $ac_func
9733	>
9734	>	/* Override any gcc2 internal prototype to avoid an error.  */
9735	>	#ifdef __cplusplus
9736	>	extern "C"
9737	>	{
9738	>	#endif
9739	>	/* We use char because int might match the return type of a gcc2
9740	>	builtin and then its argument prototype would still apply.  */
9741	>	char $ac_func ();
9742	>	/* The GNU C library defines this for functions which it implements
9743	>	to always fail with ENOSYS.  Some functions are actually named
9744	>	something starting with __ and the normal name is an alias.  */
9745	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746	>	choke me
9747	>	#else
9748	>	char (*f) () = $ac_func;
9749	>	#endif
9750	>	#ifdef __cplusplus
9751	>	}
9752	>	#endif
9753	>
9754	>	#ifdef FC_DUMMY_MAIN
9755	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9756	>	#  ifdef __cplusplus
9757	>	extern "C"
9758	>	#  endif
9759	>	int FC_DUMMY_MAIN() { return 1; }
9760	>	#endif
9761	>	#endif
9762	>	int
9763	>	main ()
9764	>	{
9765	>	return f != $ac_func;
9766	>	;
9767	>	return 0;
9768	>	}
9769	>	_ACEOF
9770	>	rm -f conftest.$ac_objext conftest$ac_exeext
9771	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772	>	(eval $ac_link) 2>conftest.er1
9773	>	ac_status=$?
9774	>	grep -v '^ *+' conftest.er1 >conftest.err
9775	>	rm -f conftest.er1
9776	>	cat conftest.err >&5
9777	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778	>	(exit $ac_status); } &&
9779	>	{ ac_try='test -z "$ac_c_werror_flag"
9780	>	|| test ! -s conftest.err'
9781	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782	>	(eval $ac_try) 2>&5
9783	>	ac_status=$?
9784	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785	>	(exit $ac_status); }; } &&
9786	>	{ ac_try='test -s conftest$ac_exeext'
9787	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788	>	(eval $ac_try) 2>&5
9789	>	ac_status=$?
9790	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791	>	(exit $ac_status); }; }; then
9792	>	eval "$as_ac_var=yes"
9793	>	else
9794	>	echo "$as_me: failed program was:" >&5
9795	>	sed 's/^/| /' conftest.$ac_ext >&5
9796	>
9797	>	eval "$as_ac_var=no"
9798	>	fi
9799	>	rm -f conftest.err conftest.$ac_objext \
9800	>	conftest$ac_exeext conftest.$ac_ext
9801	>	fi
9802	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9805	>	cat >>confdefs.h <<_ACEOF
9806	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807	>	_ACEOF
9808	>
9809	>	fi
9810	>	done
9811	>
9812	>
9813	>	# special check for _system_configuration because AIX <4.3.2 do not
9814	>	# contain the `physmem' member.
9815	>	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817	>	cat >conftest.$ac_ext <<_ACEOF
9818	>	/* confdefs.h.  */
9819	>	_ACEOF
9820	>	cat confdefs.h >>conftest.$ac_ext
9821	>	cat >>conftest.$ac_ext <<_ACEOF
9822	>	/* end confdefs.h.  */
9823	>	#include <sys/systemcfg.h>
9824	>	#ifdef FC_DUMMY_MAIN
9825	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9826	>	#  ifdef __cplusplus
9827	>	extern "C"
9828	>	#  endif
9829	>	int FC_DUMMY_MAIN() { return 1; }
9830	>	#endif
9831	>	#endif
9832	>	int
9833	>	main ()
9834	>	{
9835	>	double x = _system_configuration.physmem;
9836	>	;
9837	>	return 0;
9838	>	}
9839	>	_ACEOF
9840	>	rm -f conftest.$ac_objext
9841	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842	>	(eval $ac_compile) 2>conftest.er1
9843	>	ac_status=$?
9844	>	grep -v '^ *+' conftest.er1 >conftest.err
9845	>	rm -f conftest.er1
9846	>	cat conftest.err >&5
9847	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848	>	(exit $ac_status); } &&
9849	>	{ ac_try='test -z "$ac_c_werror_flag"
9850	>	|| test ! -s conftest.err'
9851	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852	>	(eval $ac_try) 2>&5
9853	>	ac_status=$?
9854	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855	>	(exit $ac_status); }; } &&
9856	>	{ ac_try='test -s conftest.$ac_objext'
9857	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858	>	(eval $ac_try) 2>&5
9859	>	ac_status=$?
9860	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861	>	(exit $ac_status); }; }; then
9862	>	echo "$as_me:$LINENO: result: yes" >&5
9863	>	echo "${ECHO_T}yes" >&6
9864	>
9865	>	cat >>confdefs.h <<\_ACEOF
9866	>	#define HAVE__SYSTEM_CONFIGURATION 1
9867	>	_ACEOF
9868	>
9869	>	else
9870	>	echo "$as_me: failed program was:" >&5
9871	>	sed 's/^/| /' conftest.$ac_ext >&5
9872	>
9873	>	echo "$as_me:$LINENO: result: no" >&5
9874	>	echo "${ECHO_T}no" >&6
9875	>	fi
9876	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877	>
9878	>	# clean out junk possibly left behind by a previous configuration
9879	>	rm -f src/getopt.h
9880	>	# Check for getopt_long support
9881	>
9882	>	for ac_header in getopt.h
9883	>	do
9884	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9887	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9890	>	fi
9891	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893	>	else
9894	>	# Is the header compilable?
9895	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897	>	cat >conftest.$ac_ext <<_ACEOF
9898	>	/* confdefs.h.  */
9899	>	_ACEOF
9900	>	cat confdefs.h >>conftest.$ac_ext
9901	>	cat >>conftest.$ac_ext <<_ACEOF
9902	>	/* end confdefs.h.  */
9903	>	$ac_includes_default
9904	>	#include <$ac_header>
9905	>	_ACEOF
9906	>	rm -f conftest.$ac_objext
9907	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908	>	(eval $ac_compile) 2>conftest.er1
9909	>	ac_status=$?
9910	>	grep -v '^ *+' conftest.er1 >conftest.err
9911	>	rm -f conftest.er1
9912	>	cat conftest.err >&5
9913	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914	>	(exit $ac_status); } &&
9915	>	{ ac_try='test -z "$ac_c_werror_flag"
9916	>	|| test ! -s conftest.err'
9917	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918	>	(eval $ac_try) 2>&5
9919	>	ac_status=$?
9920	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921	>	(exit $ac_status); }; } &&
9922	>	{ ac_try='test -s conftest.$ac_objext'
9923	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924	>	(eval $ac_try) 2>&5
9925	>	ac_status=$?
9926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927	>	(exit $ac_status); }; }; then
9928	>	ac_header_compiler=yes
9929	>	else
9930	>	echo "$as_me: failed program was:" >&5
9931	>	sed 's/^/| /' conftest.$ac_ext >&5
9932	>
9933	>	ac_header_compiler=no
9934	>	fi
9935	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937	>	echo "${ECHO_T}$ac_header_compiler" >&6
9938	>
9939	>	# Is the header present?
9940	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942	>	cat >conftest.$ac_ext <<_ACEOF
9943	>	/* confdefs.h.  */
9944	>	_ACEOF
9945	>	cat confdefs.h >>conftest.$ac_ext
9946	>	cat >>conftest.$ac_ext <<_ACEOF
9947	>	/* end confdefs.h.  */
9948	>	#include <$ac_header>
9949	>	_ACEOF
9950	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952	>	ac_status=$?
9953	>	grep -v '^ *+' conftest.er1 >conftest.err
9954	>	rm -f conftest.er1
9955	>	cat conftest.err >&5
9956	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957	>	(exit $ac_status); } >/dev/null; then
9958	>	if test -s conftest.err; then
9959	>	ac_cpp_err=$ac_c_preproc_warn_flag
9960	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961	>	else
9962	>	ac_cpp_err=
9963	>	fi
9964	>	else
9965	>	ac_cpp_err=yes
9966	>	fi
9967	>	if test -z "$ac_cpp_err"; then
9968	>	ac_header_preproc=yes
9969	>	else
9970	>	echo "$as_me: failed program was:" >&5
9971	>	sed 's/^/| /' conftest.$ac_ext >&5
9972	>
9973	>	ac_header_preproc=no
9974	>	fi
9975	>	rm -f conftest.err conftest.$ac_ext
9976	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977	>	echo "${ECHO_T}$ac_header_preproc" >&6
9978	>
9979	>	# So?  What about this header?
9980	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981	>	yes:no: )
9982	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986	>	ac_header_preproc=yes
9987	>	;;
9988	>	no:yes:* )
9989	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001	>	(
10002	>	cat <<\_ASBOX
10003	>	## ------------------------------ ##
10004	>	## Report this to gezelter@nd.edu ##
10005	>	## ------------------------------ ##
10006	>	_ASBOX
10007	>	) |
10008	>	sed "s/^/$as_me: WARNING:     /" >&2
10009	>	;;
10010	>	esac
10011	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10012	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10015	>	else
10016	>	eval "$as_ac_Header=\$ac_header_preproc"
10017	>	fi
10018	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020	>
10021	>	fi
10022	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023	>	cat >>confdefs.h <<_ACEOF
10024	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025	>	_ACEOF
10026	>
10027	>	fi
10028	>
10029	>	done
10030	>
10031	>
10032	>	for ac_func in getopt_long
10033	>	do
10034	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
10036	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
10038	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10039	>	else
10040	>	cat >conftest.$ac_ext <<_ACEOF
10041	>	/* confdefs.h.  */
10042	>	_ACEOF
10043	>	cat confdefs.h >>conftest.$ac_ext
10044	>	cat >>conftest.$ac_ext <<_ACEOF
10045	>	/* end confdefs.h.  */
10046	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048	>	#define $ac_func innocuous_$ac_func
10049	>
10050	>	/* System header to define __stub macros and hopefully few prototypes,
10051	>	which can conflict with char $ac_func (); below.
10052	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053	>	<limits.h> exists even on freestanding compilers.  */
10054	>
10055	>	#ifdef __STDC__
10056	>	# include <limits.h>
10057	>	#else
10058	>	# include <assert.h>
10059	>	#endif
10060	>
10061	>	#undef $ac_func
10062	>
10063	>	/* Override any gcc2 internal prototype to avoid an error.  */
10064	>	#ifdef __cplusplus
10065	>	extern "C"
10066	>	{
10067	>	#endif
10068	>	/* We use char because int might match the return type of a gcc2
10069	>	builtin and then its argument prototype would still apply.  */
10070	>	char $ac_func ();
10071	>	/* The GNU C library defines this for functions which it implements
10072	>	to always fail with ENOSYS.  Some functions are actually named
10073	>	something starting with __ and the normal name is an alias.  */
10074	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075	>	choke me
10076	>	#else
10077	>	char (*f) () = $ac_func;
10078	>	#endif
10079	>	#ifdef __cplusplus
10080	>	}
10081	>	#endif
10082	>
10083	>	#ifdef FC_DUMMY_MAIN
10084	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10085	>	#  ifdef __cplusplus
10086	>	extern "C"
10087	>	#  endif
10088	>	int FC_DUMMY_MAIN() { return 1; }
10089	>	#endif
10090	>	#endif
10091	>	int
10092	>	main ()
10093	>	{
10094	>	return f != $ac_func;
10095	>	;
10096	>	return 0;
10097	>	}
10098	>	_ACEOF
10099	>	rm -f conftest.$ac_objext conftest$ac_exeext
10100	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10101	>	(eval $ac_link) 2>conftest.er1
10102	>	ac_status=$?
10103	>	grep -v '^ *+' conftest.er1 >conftest.err
10104	>	rm -f conftest.er1
10105	>	cat conftest.err >&5
10106	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10107	>	(exit $ac_status); } &&
10108	>	{ ac_try='test -z "$ac_c_werror_flag"
10109	>	|| test ! -s conftest.err'
10110	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10111	>	(eval $ac_try) 2>&5
10112	>	ac_status=$?
10113	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10114	>	(exit $ac_status); }; } &&
10115	>	{ ac_try='test -s conftest$ac_exeext'
10116	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10117	>	(eval $ac_try) 2>&5
10118	>	ac_status=$?
10119	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120	>	(exit $ac_status); }; }; then
10121	>	eval "$as_ac_var=yes"
10122	>	else
10123	>	echo "$as_me: failed program was:" >&5
10124	>	sed 's/^/| /' conftest.$ac_ext >&5
10125	>
10126	>	eval "$as_ac_var=no"
10127	>	fi
10128	>	rm -f conftest.err conftest.$ac_objext \
10129	>	conftest$ac_exeext conftest.$ac_ext
10130	>	fi
10131	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
10134	>	cat >>confdefs.h <<_ACEOF
10135	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136	>	_ACEOF
10137	>
10138	>	else
10139	>	# FreeBSD has a gnugetopt library for this
10140	>	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141	>	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142	>	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10144	>	else
10145	>	ac_check_lib_save_LIBS=$LIBS
10146	>	LIBS="-lgnugetopt  $LIBS"
10147	>	cat >conftest.$ac_ext <<_ACEOF
10148	>	/* confdefs.h.  */
10149	>	_ACEOF
10150	>	cat confdefs.h >>conftest.$ac_ext
10151	>	cat >>conftest.$ac_ext <<_ACEOF
10152	>	/* end confdefs.h.  */
10153	>
10154	>	/* Override any gcc2 internal prototype to avoid an error.  */
10155	>	#ifdef __cplusplus
10156	>	extern "C"
10157	>	#endif
10158	>	/* We use char because int might match the return type of a gcc2
10159	>	builtin and then its argument prototype would still apply.  */
10160	>	char getopt_long ();
10161	>	#ifdef FC_DUMMY_MAIN
10162	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10163	>	#  ifdef __cplusplus
10164	>	extern "C"
10165	>	#  endif
10166	>	int FC_DUMMY_MAIN() { return 1; }
10167	>	#endif
10168	>	#endif
10169	>	int
10170	>	main ()
10171	>	{
10172	>	getopt_long ();
10173	>	;
10174	>	return 0;
10175	>	}
10176	>	_ACEOF
10177	>	rm -f conftest.$ac_objext conftest$ac_exeext
10178	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179	>	(eval $ac_link) 2>conftest.er1
10180	>	ac_status=$?
10181	>	grep -v '^ *+' conftest.er1 >conftest.err
10182	>	rm -f conftest.er1
10183	>	cat conftest.err >&5
10184	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10185	>	(exit $ac_status); } &&
10186	>	{ ac_try='test -z "$ac_c_werror_flag"
10187	>	|| test ! -s conftest.err'
10188	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10189	>	(eval $ac_try) 2>&5
10190	>	ac_status=$?
10191	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192	>	(exit $ac_status); }; } &&
10193	>	{ ac_try='test -s conftest$ac_exeext'
10194	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195	>	(eval $ac_try) 2>&5
10196	>	ac_status=$?
10197	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198	>	(exit $ac_status); }; }; then
10199	>	ac_cv_lib_gnugetopt_getopt_long=yes
10200	>	else
10201	>	echo "$as_me: failed program was:" >&5
10202	>	sed 's/^/| /' conftest.$ac_ext >&5
10203	>
10204	>	ac_cv_lib_gnugetopt_getopt_long=no
10205	>	fi
10206	>	rm -f conftest.err conftest.$ac_objext \
10207	>	conftest$ac_exeext conftest.$ac_ext
10208	>	LIBS=$ac_check_lib_save_LIBS
10209	>	fi
10210	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211	>	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212	>	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213	>	cat >>confdefs.h <<\_ACEOF
10214	>	#define HAVE_GETOPT_LONG 1
10215	>	_ACEOF
10216	>
10217	>	else
10218	>	# use the GNU replacement
10219	>	case $LIBOBJS in
10220	>	"getopt.$ac_objext"   | \
10221	>	*" getopt.$ac_objext"   | \
10222	>	"getopt.$ac_objext "* | \
10223	>	*" getopt.$ac_objext "* ) ;;
10224	>	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225	>	esac
10226	>
10227	>	case $LIBOBJS in
10228	>	"getopt1.$ac_objext"   | \
10229	>	*" getopt1.$ac_objext"   | \
10230	>	"getopt1.$ac_objext "* | \
10231	>	*" getopt1.$ac_objext "* ) ;;
10232	>	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233	>	esac
10234	>
10235	>	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236	>
10237	>	fi
10238	>
10239	>	fi
10240	>	done
10241	>
10242	>
10243	>	ac_ext=cc
10244	>	ac_cpp='$CXXCPP $CPPFLAGS'
10245	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248	>
10249	>
10250	>	echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10251	>	echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10252	>	if test "${ac_cv_cxx_namespaces+set}" = set; then
10253	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10254	>	else
10255	>
10256	>
10257	>	ac_ext=cc
10258	>	ac_cpp='$CXXCPP $CPPFLAGS'
10259	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262	>
10263	>	cat >conftest.$ac_ext <<_ACEOF
10264	>	/* confdefs.h.  */
10265	>	_ACEOF
10266	>	cat confdefs.h >>conftest.$ac_ext
10267	>	cat >>conftest.$ac_ext <<_ACEOF
10268	>	/* end confdefs.h.  */
10269	>	namespace Outer { namespace Inner { int i = 0; }}
10270	>	#ifdef FC_DUMMY_MAIN
10271	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10272	>	#  ifdef __cplusplus
10273	>	extern "C"
10274	>	#  endif
10275	>	int FC_DUMMY_MAIN() { return 1; }
10276	>	#endif
10277	>	#endif
10278	>	int
10279	>	main ()
10280	>	{
10281	>	using namespace Outer::Inner; return i;
10282	>	;
10283	>	return 0;
10284	>	}
10285	>	_ACEOF
10286	>	rm -f conftest.$ac_objext
10287	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10288	>	(eval $ac_compile) 2>conftest.er1
10289	>	ac_status=$?
10290	>	grep -v '^ *+' conftest.er1 >conftest.err
10291	>	rm -f conftest.er1
10292	>	cat conftest.err >&5
10293	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294	>	(exit $ac_status); } &&
10295	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10296	>	|| test ! -s conftest.err'
10297	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298	>	(eval $ac_try) 2>&5
10299	>	ac_status=$?
10300	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10301	>	(exit $ac_status); }; } &&
10302	>	{ ac_try='test -s conftest.$ac_objext'
10303	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10304	>	(eval $ac_try) 2>&5
10305	>	ac_status=$?
10306	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307	>	(exit $ac_status); }; }; then
10308	>	ac_cv_cxx_namespaces=yes
10309	>	else
10310	>	echo "$as_me: failed program was:" >&5
10311	>	sed 's/^/| /' conftest.$ac_ext >&5
10312	>
10313	>	ac_cv_cxx_namespaces=no
10314	>	fi
10315	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316	>	ac_ext=cc
10317	>	ac_cpp='$CXXCPP $CPPFLAGS'
10318	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10319	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10320	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10321	>
10322	>
10323	>	fi
10324	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325	>	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326	>	if test "$ac_cv_cxx_namespaces" = yes; then
10327	>
10328	>	cat >>confdefs.h <<\_ACEOF
10329	>	#define HAVE_NAMESPACES
10330	>	_ACEOF
10331	>
10332	>	fi
10333	>
10334	>	ac_ext=cc
10335	>	ac_cpp='$CXXCPP $CPPFLAGS'
10336	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339	>	echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340	>	echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341	>	if test -z "$CXXCPP"; then
10342	>	if test "${ac_cv_prog_CXXCPP+set}" = set; then
10343	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10344	>	else
10345	>	# Double quotes because CXXCPP needs to be expanded
10346	>	for CXXCPP in "$CXX -E" "/lib/cpp"
10347	>	do
10348	>	ac_preproc_ok=false
10349	>	for ac_cxx_preproc_warn_flag in '' yes
10350	>	do
10351	>	# Use a header file that comes with gcc, so configuring glibc
10352	>	# with a fresh cross-compiler works.
10353	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10354	>	# <limits.h> exists even on freestanding compilers.
10355	>	# On the NeXT, cc -E runs the code through the compiler's parser,
10356	>	# not just through cpp. "Syntax error" is here to catch this case.
10357	>	cat >conftest.$ac_ext <<_ACEOF
10358	>	/* confdefs.h.  */
10359	>	_ACEOF
10360	>	cat confdefs.h >>conftest.$ac_ext
10361	>	cat >>conftest.$ac_ext <<_ACEOF
10362	>	/* end confdefs.h.  */
10363	>	#ifdef __STDC__
10364	>	# include <limits.h>
10365	>	#else
10366	>	# include <assert.h>
10367	>	#endif
10368	>	Syntax error
10369	>	_ACEOF
10370	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10371	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10372	>	ac_status=$?
10373	>	grep -v '^ *+' conftest.er1 >conftest.err
10374	>	rm -f conftest.er1
10375	>	cat conftest.err >&5
10376	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377	>	(exit $ac_status); } >/dev/null; then
10378	>	if test -s conftest.err; then
10379	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10380	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381	>	else
10382	>	ac_cpp_err=
10383	>	fi
10384	>	else
10385	>	ac_cpp_err=yes
10386	>	fi
10387	>	if test -z "$ac_cpp_err"; then
10388	>	:
10389	>	else
10390	>	echo "$as_me: failed program was:" >&5
10391	>	sed 's/^/| /' conftest.$ac_ext >&5
10392	>
10393	>	# Broken: fails on valid input.
10394	>	continue
10395	>	fi
10396	>	rm -f conftest.err conftest.$ac_ext
10397	>
10398	>	# OK, works on sane cases.  Now check whether non-existent headers
10399	>	# can be detected and how.
10400	>	cat >conftest.$ac_ext <<_ACEOF
10401	>	/* confdefs.h.  */
10402	>	_ACEOF
10403	>	cat confdefs.h >>conftest.$ac_ext
10404	>	cat >>conftest.$ac_ext <<_ACEOF
10405	>	/* end confdefs.h.  */
10406	>	#include <ac_nonexistent.h>
10407	>	_ACEOF
10408	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10409	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10410	>	ac_status=$?
10411	>	grep -v '^ *+' conftest.er1 >conftest.err
10412	>	rm -f conftest.er1
10413	>	cat conftest.err >&5
10414	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415	>	(exit $ac_status); } >/dev/null; then
10416	>	if test -s conftest.err; then
10417	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10418	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10419	>	else
10420	>	ac_cpp_err=
10421	>	fi
10422	>	else
10423	>	ac_cpp_err=yes
10424	>	fi
10425	>	if test -z "$ac_cpp_err"; then
10426	>	# Broken: success on invalid input.
10427	>	continue
10428	>	else
10429	>	echo "$as_me: failed program was:" >&5
10430	>	sed 's/^/| /' conftest.$ac_ext >&5
10431	>
10432	>	# Passes both tests.
10433	>	ac_preproc_ok=:
10434	>	break
10435	>	fi
10436	>	rm -f conftest.err conftest.$ac_ext
10437	>
10438	>	done
10439	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10440	>	rm -f conftest.err conftest.$ac_ext
10441	>	if $ac_preproc_ok; then
10442	>	break
10443	>	fi
10444	>
10445	>	done
10446	>	ac_cv_prog_CXXCPP=$CXXCPP
10447	>
10448	>	fi
10449	>	CXXCPP=$ac_cv_prog_CXXCPP
10450	>	else
10451	>	ac_cv_prog_CXXCPP=$CXXCPP
10452	>	fi
10453	>	echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454	>	echo "${ECHO_T}$CXXCPP" >&6
10455	>	ac_preproc_ok=false
10456	>	for ac_cxx_preproc_warn_flag in '' yes
10457	>	do
10458	>	# Use a header file that comes with gcc, so configuring glibc
10459	>	# with a fresh cross-compiler works.
10460	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10461	>	# <limits.h> exists even on freestanding compilers.
10462	>	# On the NeXT, cc -E runs the code through the compiler's parser,
10463	>	# not just through cpp. "Syntax error" is here to catch this case.
10464	>	cat >conftest.$ac_ext <<_ACEOF
10465	>	/* confdefs.h.  */
10466	>	_ACEOF
10467	>	cat confdefs.h >>conftest.$ac_ext
10468	>	cat >>conftest.$ac_ext <<_ACEOF
10469	>	/* end confdefs.h.  */
10470	>	#ifdef __STDC__
10471	>	# include <limits.h>
10472	>	#else
10473	>	# include <assert.h>
10474	>	#endif
10475	>	Syntax error
10476	>	_ACEOF
10477	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10478	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10479	>	ac_status=$?
10480	>	grep -v '^ *+' conftest.er1 >conftest.err
10481	>	rm -f conftest.er1
10482	>	cat conftest.err >&5
10483	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484	>	(exit $ac_status); } >/dev/null; then
10485	>	if test -s conftest.err; then
10486	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10487	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10488	>	else
10489	>	ac_cpp_err=
10490	>	fi
10491	>	else
10492	>	ac_cpp_err=yes
10493	>	fi
10494	>	if test -z "$ac_cpp_err"; then
10495	>	:
10496	>	else
10497	>	echo "$as_me: failed program was:" >&5
10498	>	sed 's/^/| /' conftest.$ac_ext >&5
10499	>
10500	>	# Broken: fails on valid input.
10501	>	continue
10502	>	fi
10503	>	rm -f conftest.err conftest.$ac_ext
10504	>
10505	>	# OK, works on sane cases.  Now check whether non-existent headers
10506	>	# can be detected and how.
10507	>	cat >conftest.$ac_ext <<_ACEOF
10508	>	/* confdefs.h.  */
10509	>	_ACEOF
10510	>	cat confdefs.h >>conftest.$ac_ext
10511	>	cat >>conftest.$ac_ext <<_ACEOF
10512	>	/* end confdefs.h.  */
10513	>	#include <ac_nonexistent.h>
10514	>	_ACEOF
10515	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10516	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10517	>	ac_status=$?
10518	>	grep -v '^ *+' conftest.er1 >conftest.err
10519	>	rm -f conftest.er1
10520	>	cat conftest.err >&5
10521	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522	>	(exit $ac_status); } >/dev/null; then
10523	>	if test -s conftest.err; then
10524	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10525	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10526	>	else
10527	>	ac_cpp_err=
10528	>	fi
10529	>	else
10530	>	ac_cpp_err=yes
10531	>	fi
10532	>	if test -z "$ac_cpp_err"; then
10533	>	# Broken: success on invalid input.
10534	>	continue
10535	>	else
10536	>	echo "$as_me: failed program was:" >&5
10537	>	sed 's/^/| /' conftest.$ac_ext >&5
10538	>
10539	>	# Passes both tests.
10540	>	ac_preproc_ok=:
10541	>	break
10542	>	fi
10543	>	rm -f conftest.err conftest.$ac_ext
10544	>
10545	>	done
10546	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10547	>	rm -f conftest.err conftest.$ac_ext
10548	>	if $ac_preproc_ok; then
10549	>	:
10550	>	else
10551	>	{ { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10552	>	See \`config.log' for more details." >&5
10553	>	echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10554	>	See \`config.log' for more details." >&2;}
10555	>	{ (exit 1); exit 1; }; }
10556	>	fi
10557	>
10558	>	ac_ext=cc
10559	>	ac_cpp='$CXXCPP $CPPFLAGS'
10560	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563	>
10564	>
10565	>	echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566	>	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567	>	if test "${ac_cv_cxx_have_stl+set}" = set; then
10568	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10569	>	else
10570	>
10571	>
10572	>
10573	>	ac_ext=cc
10574	>	ac_cpp='$CXXCPP $CPPFLAGS'
10575	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578	>
10579	>	cat >conftest.$ac_ext <<_ACEOF
10580	>	/* confdefs.h.  */
10581	>	_ACEOF
10582	>	cat confdefs.h >>conftest.$ac_ext
10583	>	cat >>conftest.$ac_ext <<_ACEOF
10584	>	/* end confdefs.h.  */
10585	>	#include <list>
10586	>	#include <deque>
10587	>	#ifdef HAVE_NAMESPACES
10588	>	using namespace std;
10589	>	#endif
10590	>	#ifdef FC_DUMMY_MAIN
10591	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10592	>	#  ifdef __cplusplus
10593	>	extern "C"
10594	>	#  endif
10595	>	int FC_DUMMY_MAIN() { return 1; }
10596	>	#endif
10597	>	#endif
10598	>	int
10599	>	main ()
10600	>	{
10601	>	list<int> x; x.push_back(5);
10602	>	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603	>	;
10604	>	return 0;
10605	>	}
10606	>	_ACEOF
10607	>	rm -f conftest.$ac_objext
10608	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10609	>	(eval $ac_compile) 2>conftest.er1
10610	>	ac_status=$?
10611	>	grep -v '^ *+' conftest.er1 >conftest.err
10612	>	rm -f conftest.er1
10613	>	cat conftest.err >&5
10614	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615	>	(exit $ac_status); } &&
10616	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10617	>	|| test ! -s conftest.err'
10618	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10619	>	(eval $ac_try) 2>&5
10620	>	ac_status=$?
10621	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10622	>	(exit $ac_status); }; } &&
10623	>	{ ac_try='test -s conftest.$ac_objext'
10624	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10625	>	(eval $ac_try) 2>&5
10626	>	ac_status=$?
10627	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628	>	(exit $ac_status); }; }; then
10629	>	ac_cv_cxx_have_stl=yes
10630	>	else
10631	>	echo "$as_me: failed program was:" >&5
10632	>	sed 's/^/| /' conftest.$ac_ext >&5
10633	>
10634	>	ac_cv_cxx_have_stl=no
10635	>	fi
10636	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637	>	ac_ext=cc
10638	>	ac_cpp='$CXXCPP $CPPFLAGS'
10639	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10641	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10642	>
10643	>
10644	>	fi
10645	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646	>	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647	>	if test "$ac_cv_cxx_have_stl" = yes; then
10648	>
10649	>	cat >>confdefs.h <<\_ACEOF
10650	>	#define HAVE_STL
10651	>	_ACEOF
10652	>
10653	>	fi
10654	>
10655	>
10656	>
10657	>	if test "${ac_cv_header_iostream+set}" = set; then
10658	>	echo "$as_me:$LINENO: checking for iostream" >&5
10659	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660	>	if test "${ac_cv_header_iostream+set}" = set; then
10661	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10662	>	fi
10663	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665	>	else
10666	>	# Is the header compilable?
10667	>	echo "$as_me:$LINENO: checking iostream usability" >&5
10668	>	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669	>	cat >conftest.$ac_ext <<_ACEOF
10670	>	/* confdefs.h.  */
10671	>	_ACEOF
10672	>	cat confdefs.h >>conftest.$ac_ext
10673	>	cat >>conftest.$ac_ext <<_ACEOF
10674	>	/* end confdefs.h.  */
10675	>	$ac_includes_default
10676	>	#include <iostream>
10677	>	_ACEOF
10678	>	rm -f conftest.$ac_objext
10679	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10680	>	(eval $ac_compile) 2>conftest.er1
10681	>	ac_status=$?
10682	>	grep -v '^ *+' conftest.er1 >conftest.err
10683	>	rm -f conftest.er1
10684	>	cat conftest.err >&5
10685	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10686	>	(exit $ac_status); } &&
10687	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10688	>	|| test ! -s conftest.err'
10689	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10690	>	(eval $ac_try) 2>&5
10691	>	ac_status=$?
10692	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693	>	(exit $ac_status); }; } &&
10694	>	{ ac_try='test -s conftest.$ac_objext'
10695	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10696	>	(eval $ac_try) 2>&5
10697	>	ac_status=$?
10698	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699	>	(exit $ac_status); }; }; then
10700	>	ac_header_compiler=yes
10701	>	else
10702	>	echo "$as_me: failed program was:" >&5
10703	>	sed 's/^/| /' conftest.$ac_ext >&5
10704	>
10705	>	ac_header_compiler=no
10706	>	fi
10707	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10708	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10709	>	echo "${ECHO_T}$ac_header_compiler" >&6
10710	>
10711	>	# Is the header present?
10712	>	echo "$as_me:$LINENO: checking iostream presence" >&5
10713	>	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714	>	cat >conftest.$ac_ext <<_ACEOF
10715	>	/* confdefs.h.  */
10716	>	_ACEOF
10717	>	cat confdefs.h >>conftest.$ac_ext
10718	>	cat >>conftest.$ac_ext <<_ACEOF
10719	>	/* end confdefs.h.  */
10720	>	#include <iostream>
10721	>	_ACEOF
10722	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10724	>	ac_status=$?
10725	>	grep -v '^ *+' conftest.er1 >conftest.err
10726	>	rm -f conftest.er1
10727	>	cat conftest.err >&5
10728	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10729	>	(exit $ac_status); } >/dev/null; then
10730	>	if test -s conftest.err; then
10731	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10732	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10733	>	else
10734	>	ac_cpp_err=
10735	>	fi
10736	>	else
10737	>	ac_cpp_err=yes
10738	>	fi
10739	>	if test -z "$ac_cpp_err"; then
10740	>	ac_header_preproc=yes
10741	>	else
10742	>	echo "$as_me: failed program was:" >&5
10743	>	sed 's/^/| /' conftest.$ac_ext >&5
10744	>
10745	>	ac_header_preproc=no
10746	>	fi
10747	>	rm -f conftest.err conftest.$ac_ext
10748	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10749	>	echo "${ECHO_T}$ac_header_preproc" >&6
10750	>
10751	>	# So?  What about this header?
10752	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753	>	yes:no: )
10754	>	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755	>	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757	>	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758	>	ac_header_preproc=yes
10759	>	;;
10760	>	no:yes:* )
10761	>	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762	>	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763	>	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764	>	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765	>	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766	>	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767	>	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768	>	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770	>	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771	>	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772	>	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773	>	(
10774	>	cat <<\_ASBOX
10775	>	## ------------------------------ ##
10776	>	## Report this to gezelter@nd.edu ##
10777	>	## ------------------------------ ##
10778	>	_ASBOX
10779	>	) |
10780	>	sed "s/^/$as_me: WARNING:     /" >&2
10781	>	;;
10782	>	esac
10783	>	echo "$as_me:$LINENO: checking for iostream" >&5
10784	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785	>	if test "${ac_cv_header_iostream+set}" = set; then
10786	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10787	>	else
10788	>	ac_cv_header_iostream=$ac_header_preproc
10789	>	fi
10790	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792	>
10793	>	fi
10794	>	if test $ac_cv_header_iostream = yes; then
10795	>
10796	>
10797	>	cat >>confdefs.h <<\_ACEOF
10798	>	#define HAVE_IOSTREAM 1
10799	>	_ACEOF
10800	>
10801	>
10802	>	else
10803	>
10804	>
10805	>	for ac_header in iostream.h
10806	>	do
10807	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10809	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10810	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10811	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10812	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10813	>	fi
10814	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10815	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10816	>	else
10817	>	# Is the header compilable?
10818	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10819	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10820	>	cat >conftest.$ac_ext <<_ACEOF
10821	>	/* confdefs.h.  */
10822	>	_ACEOF
10823	>	cat confdefs.h >>conftest.$ac_ext
10824	>	cat >>conftest.$ac_ext <<_ACEOF
10825	>	/* end confdefs.h.  */
10826	>	$ac_includes_default
10827	>	#include <$ac_header>
10828	>	_ACEOF
10829	>	rm -f conftest.$ac_objext
10830	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831	>	(eval $ac_compile) 2>conftest.er1
10832	>	ac_status=$?
10833	>	grep -v '^ *+' conftest.er1 >conftest.err
10834	>	rm -f conftest.er1
10835	>	cat conftest.err >&5
10836	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837	>	(exit $ac_status); } &&
10838	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10839	>	|| test ! -s conftest.err'
10840	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841	>	(eval $ac_try) 2>&5
10842	>	ac_status=$?
10843	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844	>	(exit $ac_status); }; } &&
10845	>	{ ac_try='test -s conftest.$ac_objext'
10846	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10847	>	(eval $ac_try) 2>&5
10848	>	ac_status=$?
10849	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10850	>	(exit $ac_status); }; }; then
10851	>	ac_header_compiler=yes
10852	>	else
10853	>	echo "$as_me: failed program was:" >&5
10854	>	sed 's/^/| /' conftest.$ac_ext >&5
10855	>
10856	>	ac_header_compiler=no
10857	>	fi
10858	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10859	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10860	>	echo "${ECHO_T}$ac_header_compiler" >&6
10861	>
10862	>	# Is the header present?
10863	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10864	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10865	>	cat >conftest.$ac_ext <<_ACEOF
10866	>	/* confdefs.h.  */
10867	>	_ACEOF
10868	>	cat confdefs.h >>conftest.$ac_ext
10869	>	cat >>conftest.$ac_ext <<_ACEOF
10870	>	/* end confdefs.h.  */
10871	>	#include <$ac_header>
10872	>	_ACEOF
10873	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10874	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10875	>	ac_status=$?
10876	>	grep -v '^ *+' conftest.er1 >conftest.err
10877	>	rm -f conftest.er1
10878	>	cat conftest.err >&5
10879	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880	>	(exit $ac_status); } >/dev/null; then
10881	>	if test -s conftest.err; then
10882	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10883	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10884	>	else
10885	>	ac_cpp_err=
10886	>	fi
10887	>	else
10888	>	ac_cpp_err=yes
10889	>	fi
10890	>	if test -z "$ac_cpp_err"; then
10891	>	ac_header_preproc=yes
10892	>	else
10893	>	echo "$as_me: failed program was:" >&5
10894	>	sed 's/^/| /' conftest.$ac_ext >&5
10895	>
10896	>	ac_header_preproc=no
10897	>	fi
10898	>	rm -f conftest.err conftest.$ac_ext
10899	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10900	>	echo "${ECHO_T}$ac_header_preproc" >&6
10901	>
10902	>	# So?  What about this header?
10903	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904	>	yes:no: )
10905	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10908	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10909	>	ac_header_preproc=yes
10910	>	;;
10911	>	no:yes:* )
10912	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10913	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10914	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10915	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10916	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10917	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10918	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10919	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10920	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10921	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10922	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10923	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10924	>	(
10925	>	cat <<\_ASBOX
10926	>	## ------------------------------ ##
10927	>	## Report this to gezelter@nd.edu ##
10928	>	## ------------------------------ ##
10929	>	_ASBOX
10930	>	) |
10931	>	sed "s/^/$as_me: WARNING:     /" >&2
10932	>	;;
10933	>	esac
10934	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10935	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10936	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10937	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10938	>	else
10939	>	eval "$as_ac_Header=\$ac_header_preproc"
10940	>	fi
10941	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943	>
10944	>	fi
10945	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10946	>	cat >>confdefs.h <<_ACEOF
10947	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10948	>	_ACEOF
10949	>
10950	>	fi
10951	>
10952	>	done
10953	>
10954	>
10955	>	fi
10956	>
10957	>
10958	>
10959	>
10960	>	if test "${ac_cv_header_iomanip+set}" = set; then
10961	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10962	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963	>	if test "${ac_cv_header_iomanip+set}" = set; then
10964	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10965	>	fi
10966	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968	>	else
10969	>	# Is the header compilable?
10970	>	echo "$as_me:$LINENO: checking iomanip usability" >&5
10971	>	echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10972	>	cat >conftest.$ac_ext <<_ACEOF
10973	>	/* confdefs.h.  */
10974	>	_ACEOF
10975	>	cat confdefs.h >>conftest.$ac_ext
10976	>	cat >>conftest.$ac_ext <<_ACEOF
10977	>	/* end confdefs.h.  */
10978	>	$ac_includes_default
10979	>	#include <iomanip>
10980	>	_ACEOF
10981	>	rm -f conftest.$ac_objext
10982	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10983	>	(eval $ac_compile) 2>conftest.er1
10984	>	ac_status=$?
10985	>	grep -v '^ *+' conftest.er1 >conftest.err
10986	>	rm -f conftest.er1
10987	>	cat conftest.err >&5
10988	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989	>	(exit $ac_status); } &&
10990	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10991	>	|| test ! -s conftest.err'
10992	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993	>	(eval $ac_try) 2>&5
10994	>	ac_status=$?
10995	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10996	>	(exit $ac_status); }; } &&
10997	>	{ ac_try='test -s conftest.$ac_objext'
10998	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10999	>	(eval $ac_try) 2>&5
11000	>	ac_status=$?
11001	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002	>	(exit $ac_status); }; }; then
11003	>	ac_header_compiler=yes
11004	>	else
11005	>	echo "$as_me: failed program was:" >&5
11006	>	sed 's/^/| /' conftest.$ac_ext >&5
11007
11008	<
4198	<	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4199	<	if test $madedir = 1 ; then rmdir conf ; fi
11008	>	ac_header_compiler=no
11009		fi
11010	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11011	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11012	+	echo "${ECHO_T}$ac_header_compiler" >&6
11013
11014	<
11015	<	ac_ext=c
11016	<	ac_cpp='$CPP $CPPFLAGS'
11017	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4206	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4207	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4208	<
4209	<
4210	<	ac_ext=c
4211	<	ac_cpp='$CPP $CPPFLAGS'
4212	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4213	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4214	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4215	<
4216	<	ac_ext=c
4217	<	ac_cpp='$CPP $CPPFLAGS'
4218	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4219	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4220	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4221	<	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4222	<	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4223	<	# On Suns, sometimes $CPP names a directory.
4224	<	if test -n "$CPP" && test -d "$CPP"; then
4225	<	CPP=
4226	<	fi
4227	<	if test -z "$CPP"; then
4228	<	if test "${ac_cv_prog_CPP+set}" = set; then
4229	<	echo $ECHO_N "(cached) $ECHO_C" >&6
4230	<	else
4231	<	# Double quotes because CPP needs to be expanded
4232	<	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4233	<	do
4234	<	ac_preproc_ok=false
4235	<	for ac_c_preproc_warn_flag in '' yes
4236	<	do
4237	<	# Use a header file that comes with gcc, so configuring glibc
4238	<	# with a fresh cross-compiler works.
4239	<	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4240	<	# <limits.h> exists even on freestanding compilers.
4241	<	# On the NeXT, cc -E runs the code through the compiler's parser,
4242	<	# not just through cpp. "Syntax error" is here to catch this case.
4243	<	cat >conftest.$ac_ext <<_ACEOF
11014	>	# Is the header present?
11015	>	echo "$as_me:$LINENO: checking iomanip presence" >&5
11016	>	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017	>	cat >conftest.$ac_ext <<_ACEOF
11018		/* confdefs.h.  */
11019		_ACEOF
11020		cat confdefs.h >>conftest.$ac_ext
11021		cat >>conftest.$ac_ext <<_ACEOF
11022		/* end confdefs.h.  */
11023	<	#ifdef __STDC__
4250	<	# include <limits.h>
4251	<	#else
4252	<	# include <assert.h>
4253	<	#endif
4254	<	Syntax error
11023	>	#include <iomanip>
11024		_ACEOF
11025		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 4262 | Line 11031 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11031		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032		(exit $ac_status); } >/dev/null; then
11033		if test -s conftest.err; then
11034	<	ac_cpp_err=$ac_c_preproc_warn_flag
11035	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11034	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11035	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036		else
11037		ac_cpp_err=
11038		fi
#	Line 4271 | Line 11040 | if test -z "$ac_cpp_err"; then
11040		ac_cpp_err=yes
11041		fi
11042		if test -z "$ac_cpp_err"; then
11043	<	:
11043	>	ac_header_preproc=yes
11044		else
11045		echo "$as_me: failed program was:" >&5
11046		sed 's/^/| /' conftest.$ac_ext >&5
11047
11048	<	# Broken: fails on valid input.
4280	<	continue
11048	>	ac_header_preproc=no
11049		fi
11050		rm -f conftest.err conftest.$ac_ext
11051	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11052	+	echo "${ECHO_T}$ac_header_preproc" >&6
11053
11054	<	# OK, works on sane cases.  Now check whether non-existent headers
11055	<	# can be detected and how.
11056	<	cat >conftest.$ac_ext <<_ACEOF
11054	>	# So?  What about this header?
11055	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056	>	yes:no: )
11057	>	{ echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058	>	echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060	>	echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061	>	ac_header_preproc=yes
11062	>	;;
11063	>	no:yes:* )
11064	>	{ echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065	>	echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067	>	echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068	>	{ echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069	>	echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071	>	echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073	>	echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074	>	{ echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075	>	echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076	>	(
11077	>	cat <<\_ASBOX
11078	>	## ------------------------------ ##
11079	>	## Report this to gezelter@nd.edu ##
11080	>	## ------------------------------ ##
11081	>	_ASBOX
11082	>	) |
11083	>	sed "s/^/$as_me: WARNING:     /" >&2
11084	>	;;
11085	>	esac
11086	>	echo "$as_me:$LINENO: checking for iomanip" >&5
11087	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088	>	if test "${ac_cv_header_iomanip+set}" = set; then
11089	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11090	>	else
11091	>	ac_cv_header_iomanip=$ac_header_preproc
11092	>	fi
11093	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095	>
11096	>	fi
11097	>	if test $ac_cv_header_iomanip = yes; then
11098	>
11099	>
11100	>	cat >>confdefs.h <<\_ACEOF
11101	>	#define HAVE_IOMANIP 1
11102	>	_ACEOF
11103	>
11104	>
11105	>	else
11106	>
11107	>
11108	>	for ac_header in iomanip.h
11109	>	do
11110	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11112	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11113	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11114	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11115	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11116	>	fi
11117	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11118	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11119	>	else
11120	>	# Is the header compilable?
11121	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
11122	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11123	>	cat >conftest.$ac_ext <<_ACEOF
11124		/* confdefs.h.  */
11125		_ACEOF
11126		cat confdefs.h >>conftest.$ac_ext
11127		cat >>conftest.$ac_ext <<_ACEOF
11128		/* end confdefs.h.  */
11129	<	#include <ac_nonexistent.h>
11129	>	$ac_includes_default
11130	>	#include <$ac_header>
11131		_ACEOF
11132	+	rm -f conftest.$ac_objext
11133	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11134	+	(eval $ac_compile) 2>conftest.er1
11135	+	ac_status=$?
11136	+	grep -v '^ *+' conftest.er1 >conftest.err
11137	+	rm -f conftest.er1
11138	+	cat conftest.err >&5
11139	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11140	+	(exit $ac_status); } &&
11141	+	{ ac_try='test -z "$ac_cxx_werror_flag"
11142	+	|| test ! -s conftest.err'
11143	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11144	+	(eval $ac_try) 2>&5
11145	+	ac_status=$?
11146	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11147	+	(exit $ac_status); }; } &&
11148	+	{ ac_try='test -s conftest.$ac_objext'
11149	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11150	+	(eval $ac_try) 2>&5
11151	+	ac_status=$?
11152	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11153	+	(exit $ac_status); }; }; then
11154	+	ac_header_compiler=yes
11155	+	else
11156	+	echo "$as_me: failed program was:" >&5
11157	+	sed 's/^/| /' conftest.$ac_ext >&5
11158	+
11159	+	ac_header_compiler=no
11160	+	fi
11161	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11162	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11163	+	echo "${ECHO_T}$ac_header_compiler" >&6
11164	+
11165	+	# Is the header present?
11166	+	echo "$as_me:$LINENO: checking $ac_header presence" >&5
11167	+	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11168	+	cat >conftest.$ac_ext <<_ACEOF
11169	+	/* confdefs.h.  */
11170	+	_ACEOF
11171	+	cat confdefs.h >>conftest.$ac_ext
11172	+	cat >>conftest.$ac_ext <<_ACEOF
11173	+	/* end confdefs.h.  */
11174	+	#include <$ac_header>
11175	+	_ACEOF
11176		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11177		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11178		ac_status=$?
#	Line 4300 | Line 11182 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11182		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11183		(exit $ac_status); } >/dev/null; then
11184		if test -s conftest.err; then
11185	<	ac_cpp_err=$ac_c_preproc_warn_flag
11186	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11185	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11186	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187		else
11188		ac_cpp_err=
11189		fi
#	Line 4309 | Line 11191 | if test -z "$ac_cpp_err"; then
11191		ac_cpp_err=yes
11192		fi
11193		if test -z "$ac_cpp_err"; then
11194	<	# Broken: success on invalid input.
4313	<	continue
11194	>	ac_header_preproc=yes
11195		else
11196		echo "$as_me: failed program was:" >&5
11197		sed 's/^/| /' conftest.$ac_ext >&5
11198
11199	<	# Passes both tests.
4319	<	ac_preproc_ok=:
4320	<	break
11199	>	ac_header_preproc=no
11200		fi
11201		rm -f conftest.err conftest.$ac_ext
11202	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11203	+	echo "${ECHO_T}$ac_header_preproc" >&6
11204
11205	<	done
11206	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
11207	<	rm -f conftest.err conftest.$ac_ext
11208	<	if $ac_preproc_ok; then
11209	<	break
11205	>	# So?  What about this header?
11206	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207	>	yes:no: )
11208	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11210	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11211	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11212	>	ac_header_preproc=yes
11213	>	;;
11214	>	no:yes:* )
11215	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11216	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11217	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11218	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11219	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11220	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11221	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11222	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11223	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11224	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11225	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11226	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11227	>	(
11228	>	cat <<\_ASBOX
11229	>	## ------------------------------ ##
11230	>	## Report this to gezelter@nd.edu ##
11231	>	## ------------------------------ ##
11232	>	_ASBOX
11233	>	) |
11234	>	sed "s/^/$as_me: WARNING:     /" >&2
11235	>	;;
11236	>	esac
11237	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11238	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11239	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11240	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11241	>	else
11242	>	eval "$as_ac_Header=\$ac_header_preproc"
11243		fi
11244	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11245	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11246
11247	<	done
11248	<	ac_cv_prog_CPP=$CPP
11247	>	fi
11248	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11249	>	cat >>confdefs.h <<_ACEOF
11250	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11251	>	_ACEOF
11252
11253		fi
11254	<	CPP=$ac_cv_prog_CPP
11255	<	else
11256	<	ac_cv_prog_CPP=$CPP
11254	>
11255	>	done
11256	>
11257	>
11258		fi
11259	<	echo "$as_me:$LINENO: result: $CPP" >&5
11260	<	echo "${ECHO_T}$CPP" >&6
11261	<	ac_preproc_ok=false
11262	<	for ac_c_preproc_warn_flag in '' yes
11259	>
11260	>
11261	>
11262	>
11263	>	for ac_header in cmath
11264		do
11265	<	# Use a header file that comes with gcc, so configuring glibc
11266	<	# with a fresh cross-compiler works.
11267	<	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11268	<	# <limits.h> exists even on freestanding compilers.
11269	<	# On the NeXT, cc -E runs the code through the compiler's parser,
11270	<	# not just through cpp. "Syntax error" is here to catch this case.
11271	<	cat >conftest.$ac_ext <<_ACEOF
11265	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11266	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11267	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11268	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11269	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11270	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11271	>	fi
11272	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11273	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11274	>	else
11275	>	# Is the header compilable?
11276	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
11277	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11278	>	cat >conftest.$ac_ext <<_ACEOF
11279		/* confdefs.h.  */
11280		_ACEOF
11281		cat confdefs.h >>conftest.$ac_ext
11282		cat >>conftest.$ac_ext <<_ACEOF
11283		/* end confdefs.h.  */
11284	<	#ifdef __STDC__
11285	<	# include <limits.h>
4358	<	#else
4359	<	# include <assert.h>
4360	<	#endif
4361	<	Syntax error
11284	>	$ac_includes_default
11285	>	#include <$ac_header>
11286		_ACEOF
11287	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11288	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11287	>	rm -f conftest.$ac_objext
11288	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11289	>	(eval $ac_compile) 2>conftest.er1
11290		ac_status=$?
11291		grep -v '^ *+' conftest.er1 >conftest.err
11292		rm -f conftest.er1
11293		cat conftest.err >&5
11294		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295	<	(exit $ac_status); } >/dev/null; then
11296	<	if test -s conftest.err; then
11297	<	ac_cpp_err=$ac_c_preproc_warn_flag
11298	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11299	<	else
11300	<	ac_cpp_err=
11301	<	fi
11295	>	(exit $ac_status); } &&
11296	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11297	>	|| test ! -s conftest.err'
11298	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11299	>	(eval $ac_try) 2>&5
11300	>	ac_status=$?
11301	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11302	>	(exit $ac_status); }; } &&
11303	>	{ ac_try='test -s conftest.$ac_objext'
11304	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11305	>	(eval $ac_try) 2>&5
11306	>	ac_status=$?
11307	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11308	>	(exit $ac_status); }; }; then
11309	>	ac_header_compiler=yes
11310		else
4378	–	ac_cpp_err=yes
4379	–	fi
4380	–	if test -z "$ac_cpp_err"; then
4381	–	:
4382	–	else
11311		echo "$as_me: failed program was:" >&5
11312		sed 's/^/| /' conftest.$ac_ext >&5
11313
11314	<	# Broken: fails on valid input.
4387	<	continue
11314	>	ac_header_compiler=no
11315		fi
11316	<	rm -f conftest.err conftest.$ac_ext
11316	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11317	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11318	>	echo "${ECHO_T}$ac_header_compiler" >&6
11319
11320	<	# OK, works on sane cases.  Now check whether non-existent headers
11321	<	# can be detected and how.
11322	<	cat >conftest.$ac_ext <<_ACEOF
11320	>	# Is the header present?
11321	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
11322	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11323	>	cat >conftest.$ac_ext <<_ACEOF
11324		/* confdefs.h.  */
11325		_ACEOF
11326		cat confdefs.h >>conftest.$ac_ext
11327		cat >>conftest.$ac_ext <<_ACEOF
11328		/* end confdefs.h.  */
11329	<	#include <ac_nonexistent.h>
11329	>	#include <$ac_header>
11330		_ACEOF
11331		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11332		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 4407 | Line 11337 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11337		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11338		(exit $ac_status); } >/dev/null; then
11339		if test -s conftest.err; then
11340	<	ac_cpp_err=$ac_c_preproc_warn_flag
11341	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11340	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11341	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11342		else
11343		ac_cpp_err=
11344		fi
#	Line 4416 | Line 11346 | if test -z "$ac_cpp_err"; then
11346		ac_cpp_err=yes
11347		fi
11348		if test -z "$ac_cpp_err"; then
11349	<	# Broken: success on invalid input.
4420	<	continue
11349	>	ac_header_preproc=yes
11350		else
11351		echo "$as_me: failed program was:" >&5
11352		sed 's/^/| /' conftest.$ac_ext >&5
11353
11354	<	# Passes both tests.
4426	<	ac_preproc_ok=:
4427	<	break
11354	>	ac_header_preproc=no
11355		fi
11356		rm -f conftest.err conftest.$ac_ext
11357	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11358	+	echo "${ECHO_T}$ac_header_preproc" >&6
11359
11360	<	done
11361	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
11362	<	rm -f conftest.err conftest.$ac_ext
11363	<	if $ac_preproc_ok; then
11364	<	:
11360	>	# So?  What about this header?
11361	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11362	>	yes:no: )
11363	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11364	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11365	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11366	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11367	>	ac_header_preproc=yes
11368	>	;;
11369	>	no:yes:* )
11370	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11371	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11372	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11373	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11374	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11375	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11376	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11377	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11378	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11379	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11380	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11381	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11382	>	(
11383	>	cat <<\_ASBOX
11384	>	## ------------------------------ ##
11385	>	## Report this to gezelter@nd.edu ##
11386	>	## ------------------------------ ##
11387	>	_ASBOX
11388	>	) |
11389	>	sed "s/^/$as_me: WARNING:     /" >&2
11390	>	;;
11391	>	esac
11392	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11393	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11394	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11395	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11396		else
11397	<	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4438	<	See \`config.log' for more details." >&5
4439	<	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4440	<	See \`config.log' for more details." >&2;}
4441	<	{ (exit 1); exit 1; }; }
11397	>	eval "$as_ac_Header=\$ac_header_preproc"
11398		fi
11399	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11400	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11401
11402	<	ac_ext=c
11403	<	ac_cpp='$CPP $CPPFLAGS'
11404	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11405	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11406	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
11402	>	fi
11403	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11404	>	cat >>confdefs.h <<_ACEOF
11405	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11406	>	_ACEOF
11407
4450	–
4451	–	echo "$as_me:$LINENO: checking for egrep" >&5
4452	–	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4453	–	if test "${ac_cv_prog_egrep+set}" = set; then
4454	–	echo $ECHO_N "(cached) $ECHO_C" >&6
4455	–	else
4456	–	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4457	–	then ac_cv_prog_egrep='grep -E'
4458	–	else ac_cv_prog_egrep='egrep'
4459	–	fi
11408		fi
4461	–	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4462	–	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4463	–	EGREP=$ac_cv_prog_egrep
11409
11410	+	done
11411
11412	<	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
11413	<	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
11414	<	if test "${ac_cv_header_stdc+set}" = set; then
11412	>
11413	>
11414	>
11415	>	echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11416	>	echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11417	>	if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11418		echo $ECHO_N "(cached) $ECHO_C" >&6
11419		else
11420	<	cat >conftest.$ac_ext <<_ACEOF
11420	>
11421	>	ac_cv_cxx_have_std_iostream=no
11422	>	ac_cv_cxx_need_use_std_iostream=no
11423	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11424	>
11425	>
11426	>	ac_ext=cc
11427	>	ac_cpp='$CXXCPP $CPPFLAGS'
11428	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431	>
11432	>	cat >conftest.$ac_ext <<_ACEOF
11433		/* confdefs.h.  */
11434		_ACEOF
11435		cat confdefs.h >>conftest.$ac_ext
11436		cat >>conftest.$ac_ext <<_ACEOF
11437		/* end confdefs.h.  */
4477	–	#include <stdlib.h>
4478	–	#include <stdarg.h>
4479	–	#include <string.h>
4480	–	#include <float.h>
11438
11439	+	#ifdef HAVE_IOSTREAM
11440	+	#include <iostream>
11441	+	#else
11442	+	#include <iostream.h>
11443	+	#endif
11444	+
11445	+	#ifdef FC_DUMMY_MAIN
11446	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11447	+	#  ifdef __cplusplus
11448	+	extern "C"
11449	+	#  endif
11450	+	int FC_DUMMY_MAIN() { return 1; }
11451	+	#endif
11452	+	#endif
11453		int
11454		main ()
11455		{
11456	<
11456	>	std::cout<<"Hello World"<<std::endl;return 0;
11457		;
11458		return 0;
11459		}
#	Line 4496 | Line 11467 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11467		cat conftest.err >&5
11468		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469		(exit $ac_status); } &&
11470	<	{ ac_try='test -z "$ac_c_werror_flag"
11470	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11471		|| test ! -s conftest.err'
11472		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473		(eval $ac_try) 2>&5
#	Line 4509 | Line 11480 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11480		ac_status=$?
11481		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482		(exit $ac_status); }; }; then
11483	<	ac_cv_header_stdc=yes
11483	>	ac_cv_cxx_have_std_iostream=yes
11484		else
11485		echo "$as_me: failed program was:" >&5
11486		sed 's/^/| /' conftest.$ac_ext >&5
11487
4517	–	ac_cv_header_stdc=no
11488		fi
11489		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490	<
4521	<	if test $ac_cv_header_stdc = yes; then
4522	<	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4523	<	cat >conftest.$ac_ext <<_ACEOF
11490	>	cat >conftest.$ac_ext <<_ACEOF
11491		/* confdefs.h.  */
11492		_ACEOF
11493		cat confdefs.h >>conftest.$ac_ext
11494		cat >>conftest.$ac_ext <<_ACEOF
11495		/* end confdefs.h.  */
4529	–	#include <string.h>
11496
11497	<	_ACEOF
11498	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11499	<	$EGREP "memchr" >/dev/null 2>&1; then
11500	<	:
11501	<	else
11502	<	ac_cv_header_stdc=no
11497	>	#define __USE_STD_IOSTREAM 1
11498	>	#ifdef HAVE_IOSTREAM
11499	>	#include <iostream>
11500	>	#else
11501	>	#include <iostream.h>
11502	>	#endif
11503	>
11504	>	#ifdef FC_DUMMY_MAIN
11505	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11506	>	#  ifdef __cplusplus
11507	>	extern "C"
11508	>	#  endif
11509	>	int FC_DUMMY_MAIN() { return 1; }
11510	>	#endif
11511	>	#endif
11512	>	int
11513	>	main ()
11514	>	{
11515	>	std::cout<<"Hello World"<<std::endl;return 0;
11516	>	;
11517	>	return 0;
11518	>	}
11519	>	_ACEOF
11520	>	rm -f conftest.$ac_objext
11521	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11522	>	(eval $ac_compile) 2>conftest.er1
11523	>	ac_status=$?
11524	>	grep -v '^ *+' conftest.er1 >conftest.err
11525	>	rm -f conftest.er1
11526	>	cat conftest.err >&5
11527	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528	>	(exit $ac_status); } &&
11529	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11530	>	|| test ! -s conftest.err'
11531	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532	>	(eval $ac_try) 2>&5
11533	>	ac_status=$?
11534	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535	>	(exit $ac_status); }; } &&
11536	>	{ ac_try='test -s conftest.$ac_objext'
11537	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11538	>	(eval $ac_try) 2>&5
11539	>	ac_status=$?
11540	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541	>	(exit $ac_status); }; }; then
11542	>	ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11543	>	else
11544	>	echo "$as_me: failed program was:" >&5
11545	>	sed 's/^/| /' conftest.$ac_ext >&5
11546	>
11547		fi
11548	<	rm -f conftest*
11548	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549	>	ac_ext=cc
11550	>	ac_cpp='$CXXCPP $CPPFLAGS'
11551	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554
11555	+	fi
11556	+
11557		fi
11558	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559	+	echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560	+	if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561
11562	<	if test $ac_cv_header_stdc = yes; then
11563	<	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
11564	<	cat >conftest.$ac_ext <<_ACEOF
11562	>	cat >>confdefs.h <<\_ACEOF
11563	>	#define HAVE_STD_IOSTREAM 1
11564	>	_ACEOF
11565	>
11566	>	fi
11567	>	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568	>
11569	>	cat >>confdefs.h <<\_ACEOF
11570	>	#define __USE_STD_IOSTREAM 1
11571	>	_ACEOF
11572	>
11573	>	fi
11574	>
11575	>
11576	>
11577	>
11578	>	echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579	>	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580	>	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11582	>	else
11583	>
11584	>	ac_cv_cxx_have_std_stl=no
11585	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11586	>
11587	>
11588	>	ac_ext=cc
11589	>	ac_cpp='$CXXCPP $CPPFLAGS'
11590	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593	>
11594	>	cat >conftest.$ac_ext <<_ACEOF
11595		/* confdefs.h.  */
11596		_ACEOF
11597		cat confdefs.h >>conftest.$ac_ext
11598		cat >>conftest.$ac_ext <<_ACEOF
11599		/* end confdefs.h.  */
11600	<	#include <stdlib.h>
11600	>	#include <list>
11601
11602	+	#ifdef FC_DUMMY_MAIN
11603	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11604	+	#  ifdef __cplusplus
11605	+	extern "C"
11606	+	#  endif
11607	+	int FC_DUMMY_MAIN() { return 1; }
11608	+	#endif
11609	+	#endif
11610	+	int
11611	+	main ()
11612	+	{
11613	+	std::list<int> foo;return 0;
11614	+	;
11615	+	return 0;
11616	+	}
11617		_ACEOF
11618	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11619	<	$EGREP "free" >/dev/null 2>&1; then
11620	<	:
11618	>	rm -f conftest.$ac_objext
11619	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11620	>	(eval $ac_compile) 2>conftest.er1
11621	>	ac_status=$?
11622	>	grep -v '^ *+' conftest.er1 >conftest.err
11623	>	rm -f conftest.er1
11624	>	cat conftest.err >&5
11625	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626	>	(exit $ac_status); } &&
11627	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11628	>	|| test ! -s conftest.err'
11629	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11630	>	(eval $ac_try) 2>&5
11631	>	ac_status=$?
11632	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11633	>	(exit $ac_status); }; } &&
11634	>	{ ac_try='test -s conftest.$ac_objext'
11635	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11636	>	(eval $ac_try) 2>&5
11637	>	ac_status=$?
11638	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639	>	(exit $ac_status); }; }; then
11640	>	ac_cv_cxx_have_std_stl=yes
11641		else
11642	<	ac_cv_header_stdc=no
11642	>	echo "$as_me: failed program was:" >&5
11643	>	sed 's/^/| /' conftest.$ac_ext >&5
11644	>
11645		fi
11646	<	rm -f conftest*
11646	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647	>	ac_ext=cc
11648	>	ac_cpp='$CXXCPP $CPPFLAGS'
11649	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652
11653	+	fi
11654	+
11655		fi
11656	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657	+	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658	+	if test "$ac_cv_cxx_have_std_stl" = yes; then
11659
11660	<	if test $ac_cv_header_stdc = yes; then
11661	<	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
11662	<	if test "$cross_compiling" = yes; then
11663	<	:
11660	>	cat >>confdefs.h <<\_ACEOF
11661	>	#define HAVE_STD_STL 1
11662	>	_ACEOF
11663	>
11664	>	fi
11665	>
11666	>
11667	>
11668	>	echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669	>	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670	>	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11672		else
11673	<	cat >conftest.$ac_ext <<_ACEOF
11673	>
11674	>	ac_cv_cxx_have_fstream_attach=no
11675	>
11676	>
11677	>	ac_ext=cc
11678	>	ac_cpp='$CXXCPP $CPPFLAGS'
11679	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682	>
11683	>	cat >conftest.$ac_ext <<_ACEOF
11684		/* confdefs.h.  */
11685		_ACEOF
11686		cat confdefs.h >>conftest.$ac_ext
11687		cat >>conftest.$ac_ext <<_ACEOF
11688		/* end confdefs.h.  */
11689	<	#include <ctype.h>
11690	<	#if ((' ' & 0x0FF) == 0x020)
11691	<	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4577	<	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
11689	>
11690	>	#ifdef HAVE_IOSTREAM
11691	>	#include <fstream>
11692		#else
11693	<	# define ISLOWER(c) \
4580	<	(('a' <= (c) && (c) <= 'i') \
4581	<	|| ('j' <= (c) && (c) <= 'r') \
4582	<	|| ('s' <= (c) && (c) <= 'z'))
4583	<	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
11693	>	#include <fstream.h>
11694		#endif
11695	+	#ifdef HAVE_STD_IOSTREAM
11696	+	using namespace std;
11697	+	#endif
11698
11699	<	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
11699	>	#ifdef FC_DUMMY_MAIN
11700	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11701	>	#  ifdef __cplusplus
11702	>	extern "C"
11703	>	#  endif
11704	>	int FC_DUMMY_MAIN() { return 1; }
11705	>	#endif
11706	>	#endif
11707		int
11708		main ()
11709		{
11710	<	int i;
11711	<	for (i = 0; i < 256; i++)
11712	<	if (XOR (islower (i), ISLOWER (i))
4593	<	|| toupper (i) != TOUPPER (i))
4594	<	exit(2);
4595	<	exit (0);
11710	>	int fd=0;ofstream s;s.attach(fd);
11711	>	;
11712	>	return 0;
11713		}
11714		_ACEOF
11715	<	rm -f conftest$ac_exeext
11716	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11717	<	(eval $ac_link) 2>&5
11715	>	rm -f conftest.$ac_objext
11716	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717	>	(eval $ac_compile) 2>conftest.er1
11718		ac_status=$?
11719	+	grep -v '^ *+' conftest.er1 >conftest.err
11720	+	rm -f conftest.er1
11721	+	cat conftest.err >&5
11722		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11723	>	(exit $ac_status); } &&
11724	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11725	>	|| test ! -s conftest.err'
11726		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727		(eval $ac_try) 2>&5
11728		ac_status=$?
11729		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11730	+	(exit $ac_status); }; } &&
11731	+	{ ac_try='test -s conftest.$ac_objext'
11732	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11733	+	(eval $ac_try) 2>&5
11734	+	ac_status=$?
11735	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736		(exit $ac_status); }; }; then
11737	<	:
11737	>	ac_cv_cxx_have_fstream_attach=yes
11738		else
11739	<	echo "$as_me: program exited with status $ac_status" >&5
4612	<	echo "$as_me: failed program was:" >&5
11739	>	echo "$as_me: failed program was:" >&5
11740		sed 's/^/| /' conftest.$ac_ext >&5
11741
4615	–	( exit $ac_status )
4616	–	ac_cv_header_stdc=no
11742		fi
11743	<	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11744	<	fi
11745	<	fi
11743	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744	>	ac_ext=cc
11745	>	ac_cpp='$CXXCPP $CPPFLAGS'
11746	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749	>
11750	>
11751		fi
11752	<	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
11753	<	echo "${ECHO_T}$ac_cv_header_stdc" >&6
11754	<	if test $ac_cv_header_stdc = yes; then
11752	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11753	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11754	>	if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11755
11756		cat >>confdefs.h <<\_ACEOF
11757	<	#define STDC_HEADERS 1
11757	>	#define HAVE_FSTREAM_ATTACH 1
11758		_ACEOF
11759
11760	<	fi
11760	>	fi
11761
4632	–	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
11762
11763
11764	+	echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765	+	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766	+	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767	+	echo $ECHO_N "(cached) $ECHO_C" >&6
11768	+	else
11769
11770	+	ac_cv_cxx_have_fstream_open=no
11771	+	ac_cv_cxx_fstream_open_prot=no
11772
11773
11774	+	ac_ext=cc
11775	+	ac_cpp='$CXXCPP $CPPFLAGS'
11776	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779
11780	+	# Try with 2 parameters
11781	+	cat >conftest.$ac_ext <<_ACEOF
11782	+	/* confdefs.h.  */
11783	+	_ACEOF
11784	+	cat confdefs.h >>conftest.$ac_ext
11785	+	cat >>conftest.$ac_ext <<_ACEOF
11786	+	/* end confdefs.h.  */
11787
11788	+	#ifdef HAVE_IOSTREAM
11789	+	#include <fstream>
11790	+	#else
11791	+	#include <fstream.h>
11792	+	#endif
11793	+	#ifdef HAVE_STD_IOSTREAM
11794	+	using namespace std;
11795	+	#endif
11796
11797	<
11798	<	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
11799	<	inttypes.h stdint.h unistd.h
11800	<	do
11801	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11802	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
11803	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11804	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11805	<	echo $ECHO_N "(cached) $ECHO_C" >&6
11797	>	#ifdef FC_DUMMY_MAIN
11798	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11799	>	#  ifdef __cplusplus
11800	>	extern "C"
11801	>	#  endif
11802	>	int FC_DUMMY_MAIN() { return 1; }
11803	>	#endif
11804	>	#endif
11805	>	int
11806	>	main ()
11807	>	{
11808	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809	>	;
11810	>	return 0;
11811	>	}
11812	>	_ACEOF
11813	>	rm -f conftest.$ac_objext
11814	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11815	>	(eval $ac_compile) 2>conftest.er1
11816	>	ac_status=$?
11817	>	grep -v '^ *+' conftest.er1 >conftest.err
11818	>	rm -f conftest.er1
11819	>	cat conftest.err >&5
11820	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821	>	(exit $ac_status); } &&
11822	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11823	>	|| test ! -s conftest.err'
11824	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825	>	(eval $ac_try) 2>&5
11826	>	ac_status=$?
11827	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828	>	(exit $ac_status); }; } &&
11829	>	{ ac_try='test -s conftest.$ac_objext'
11830	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11831	>	(eval $ac_try) 2>&5
11832	>	ac_status=$?
11833	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834	>	(exit $ac_status); }; }; then
11835	>	ac_cv_cxx_have_fstream_open=yes
11836		else
11837	<	cat >conftest.$ac_ext <<_ACEOF
11837	>	echo "$as_me: failed program was:" >&5
11838	>	sed 's/^/| /' conftest.$ac_ext >&5
11839	>
11840	>	fi
11841	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842	>	# Try with mode parameter
11843	>	cat >conftest.$ac_ext <<_ACEOF
11844		/* confdefs.h.  */
11845		_ACEOF
11846		cat confdefs.h >>conftest.$ac_ext
11847		cat >>conftest.$ac_ext <<_ACEOF
11848		/* end confdefs.h.  */
4657	–	$ac_includes_default
11849
11850	<	#include <$ac_header>
11850	>	#ifdef HAVE_IOSTREAM
11851	>	#include <fstream>
11852	>	#else
11853	>	#include <fstream.h>
11854	>	#endif
11855	>	#ifdef HAVE_STD_IOSTREAM
11856	>	using namespace std;
11857	>	#endif
11858	>
11859	>	#ifdef FC_DUMMY_MAIN
11860	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11861	>	#  ifdef __cplusplus
11862	>	extern "C"
11863	>	#  endif
11864	>	int FC_DUMMY_MAIN() { return 1; }
11865	>	#endif
11866	>	#endif
11867	>	int
11868	>	main ()
11869	>	{
11870	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871	>	;
11872	>	return 0;
11873	>	}
11874		_ACEOF
11875		rm -f conftest.$ac_objext
11876		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 4667 | Line 11881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11881		cat conftest.err >&5
11882		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883		(exit $ac_status); } &&
11884	<	{ ac_try='test -z "$ac_c_werror_flag"
11884	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11885		|| test ! -s conftest.err'
11886		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887		(eval $ac_try) 2>&5
#	Line 4680 | Line 11894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11894		ac_status=$?
11895		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896		(exit $ac_status); }; }; then
11897	<	eval "$as_ac_Header=yes"
11897	>	ac_cv_cxx_fstream_open_prot=yes
11898		else
11899		echo "$as_me: failed program was:" >&5
11900		sed 's/^/| /' conftest.$ac_ext >&5
11901
4688	–	eval "$as_ac_Header=no"
11902		fi
11903		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904	+	ac_ext=cc
11905	+	ac_cpp='$CXXCPP $CPPFLAGS'
11906	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909	+
11910	+
11911		fi
11912	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11913	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11914	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
11915	<	cat >>confdefs.h <<_ACEOF
11916	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11912	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11913	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11914	>	if test "$ac_cv_cxx_have_fstream_open" = yes; then
11915	>
11916	>	cat >>confdefs.h <<\_ACEOF
11917	>	#define HAVE_FSTREAM_OPEN 1
11918		_ACEOF
11919
11920	<	fi
11920	>	fi
11921	>	if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11922
11923	<	done
11923	>	cat >>confdefs.h <<\_ACEOF
11924	>	#define FSTREAM_OPEN_PROT 1
11925	>	_ACEOF
11926
11927	+	fi
11928
4704	–	# clean out junk possibly left behind by a previous configuration
4705	–	rm -f utils/getopt.h
4706	–	# Check for getopt_long support
11929
11930	<	for ac_header in getopt.h
11930	>
11931	>
11932	>
11933	>
11934	>
11935	>	for ac_header in ctype.h iostream fstream sstream strstream
11936		do
11937		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11938		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 4738 | Line 11965 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11965		cat conftest.err >&5
11966		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11967		(exit $ac_status); } &&
11968	<	{ ac_try='test -z "$ac_c_werror_flag"
11968	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11969		|| test ! -s conftest.err'
11970		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11971		(eval $ac_try) 2>&5
#	Line 4782 | Line 12009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12009		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010		(exit $ac_status); } >/dev/null; then
12011		if test -s conftest.err; then
12012	<	ac_cpp_err=$ac_c_preproc_warn_flag
12013	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
12012	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
12013	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12014		else
12015		ac_cpp_err=
12016		fi
#	Line 4803 | Line 12030 | echo "${ECHO_T}$ac_header_preproc" >&6
12030		echo "${ECHO_T}$ac_header_preproc" >&6
12031
12032		# So?  What about this header?
12033	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12033	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034		yes:no: )
12035		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 4854 | Line 12081 | done
12081
12082		done
12083
12084	+	# AC_CPP_FUNC
12085	+	# ------------------ #
12086	+	# Checks to see if ANSI C99 CPP variable __func__ works.
12087	+	# If not, perhaps __FUNCTION__ works instead.
12088	+	# If not, we'll just define __func__ to "".
12089	+	# AC_CPP_FUNC
12090
12091	<	for ac_func in getopt_long
12092	<	do
12093	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12094	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
4862	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
4863	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
12091	>
12092	>	echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093	>	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094	>	if test "${ac_cv_cpp_func+set}" = set; then
12095		echo $ECHO_N "(cached) $ECHO_C" >&6
12096		else
12097		cat >conftest.$ac_ext <<_ACEOF
#	Line 4869 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100		cat confdefs.h >>conftest.$ac_ext
12101		cat >>conftest.$ac_ext <<_ACEOF
12102		/* end confdefs.h.  */
4872	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
4873	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
4874	–	#define $ac_func innocuous_$ac_func
12103
12104	<	/* System header to define __stub macros and hopefully few prototypes,
12105	<	which can conflict with char $ac_func (); below.
12106	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12107	<	<limits.h> exists even on freestanding compilers.  */
12108	<
12109	<	#ifdef __STDC__
4882	<	# include <limits.h>
4883	<	#else
4884	<	# include <assert.h>
4885	<	#endif
4886	<
4887	<	#undef $ac_func
4888	<
4889	<	/* Override any gcc2 internal prototype to avoid an error.  */
4890	<	#ifdef __cplusplus
4891	<	extern "C"
4892	<	{
4893	<	#endif
4894	<	/* We use char because int might match the return type of a gcc2
4895	<	builtin and then its argument prototype would still apply.  */
4896	<	char $ac_func ();
4897	<	/* The GNU C library defines this for functions which it implements
4898	<	to always fail with ENOSYS.  Some functions are actually named
4899	<	something starting with __ and the normal name is an alias.  */
4900	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4901	<	choke me
4902	<	#else
4903	<	char (*f) () = $ac_func;
12104	>	#ifdef FC_DUMMY_MAIN
12105	>	#ifndef FC_DUMMY_MAIN_EQ_F77
12106	>	#  ifdef __cplusplus
12107	>	extern "C"
12108	>	#  endif
12109	>	int FC_DUMMY_MAIN() { return 1; }
12110		#endif
4905	–	#ifdef __cplusplus
4906	–	}
12111		#endif
4908	–
12112		int
12113		main ()
12114		{
12115	<	return f != $ac_func;
12115	>	const char *foo = __func__;
12116		;
12117		return 0;
12118		}
12119		_ACEOF
12120	<	rm -f conftest.$ac_objext conftest$ac_exeext
12121	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12122	<	(eval $ac_link) 2>conftest.er1
12120	>	rm -f conftest.$ac_objext
12121	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12122	>	(eval $ac_compile) 2>conftest.er1
12123		ac_status=$?
12124		grep -v '^ *+' conftest.er1 >conftest.err
12125		rm -f conftest.er1
12126		cat conftest.err >&5
12127		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128		(exit $ac_status); } &&
12129	<	{ ac_try='test -z "$ac_c_werror_flag"
12129	>	{ ac_try='test -z "$ac_cxx_werror_flag"
12130		|| test ! -s conftest.err'
12131		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12132		(eval $ac_try) 2>&5
12133		ac_status=$?
12134		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12135		(exit $ac_status); }; } &&
12136	<	{ ac_try='test -s conftest$ac_exeext'
12136	>	{ ac_try='test -s conftest.$ac_objext'
12137		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12138		(eval $ac_try) 2>&5
12139		ac_status=$?
12140		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12141		(exit $ac_status); }; }; then
12142	<	eval "$as_ac_var=yes"
12142	>	ac_cv_cpp_func=yes
12143		else
12144		echo "$as_me: failed program was:" >&5
12145		sed 's/^/| /' conftest.$ac_ext >&5
12146
4944	–	eval "$as_ac_var=no"
4945	–	fi
4946	–	rm -f conftest.err conftest.$ac_objext \
4947	–	conftest$ac_exeext conftest.$ac_ext
4948	–	fi
4949	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
4950	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
4951	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
4952	–	cat >>confdefs.h <<_ACEOF
4953	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
4954	–	_ACEOF
4955	–
4956	–	else
4957	–	# FreeBSD has a gnugetopt library for this
4958	–	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
4959	–	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
4960	–	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
4961	–	echo $ECHO_N "(cached) $ECHO_C" >&6
4962	–	else
4963	–	ac_check_lib_save_LIBS=$LIBS
4964	–	LIBS="-lgnugetopt  $LIBS"
12147		cat >conftest.$ac_ext <<_ACEOF
12148		/* confdefs.h.  */
12149		_ACEOF
#	Line 4969 | Line 12151 | cat >>conftest.$ac_ext <<_ACEOF
12151		cat >>conftest.$ac_ext <<_ACEOF
12152		/* end confdefs.h.  */
12153
12154	<	/* Override any gcc2 internal prototype to avoid an error.  */
12155	<	#ifdef __cplusplus
12156	<	extern "C"
12154	>	#ifdef FC_DUMMY_MAIN
12155	>	#ifndef FC_DUMMY_MAIN_EQ_F77
12156	>	#  ifdef __cplusplus
12157	>	extern "C"
12158	>	#  endif
12159	>	int FC_DUMMY_MAIN() { return 1; }
12160		#endif
12161	<	/* We use char because int might match the return type of a gcc2
4977	<	builtin and then its argument prototype would still apply.  */
4978	<	char getopt_long ();
12161	>	#endif
12162		int
12163		main ()
12164		{
12165	<	getopt_long ();
12165	>	const char *foo = __FUNCTION__;
12166		;
12167		return 0;
12168		}
12169		_ACEOF
12170	<	rm -f conftest.$ac_objext conftest$ac_exeext
12171	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12172	<	(eval $ac_link) 2>conftest.er1
12170	>	rm -f conftest.$ac_objext
12171	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12172	>	(eval $ac_compile) 2>conftest.er1
12173		ac_status=$?
12174		grep -v '^ *+' conftest.er1 >conftest.err
12175		rm -f conftest.er1
12176		cat conftest.err >&5
12177		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12178		(exit $ac_status); } &&
12179	<	{ ac_try='test -z "$ac_c_werror_flag"
12179	>	{ ac_try='test -z "$ac_cxx_werror_flag"
12180		|| test ! -s conftest.err'
12181		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12182		(eval $ac_try) 2>&5
12183		ac_status=$?
12184		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12185		(exit $ac_status); }; } &&
12186	<	{ ac_try='test -s conftest$ac_exeext'
12186	>	{ ac_try='test -s conftest.$ac_objext'
12187		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12188		(eval $ac_try) 2>&5
12189		ac_status=$?
12190		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12191		(exit $ac_status); }; }; then
12192	<	ac_cv_lib_gnugetopt_getopt_long=yes
12192	>	ac_cv_cpp_func=__FUNCTION__
12193		else
12194		echo "$as_me: failed program was:" >&5
12195		sed 's/^/| /' conftest.$ac_ext >&5
12196
12197	<	ac_cv_lib_gnugetopt_getopt_long=no
12197	>	ac_cv_cpp_func=no
12198		fi
12199	<	rm -f conftest.err conftest.$ac_objext \
5017	<	conftest$ac_exeext conftest.$ac_ext
5018	<	LIBS=$ac_check_lib_save_LIBS
12199	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12200		fi
12201	<	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12202	<	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12203	<	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12204	<	cat >>confdefs.h <<\_ACEOF
12205	<	#define HAVE_GETOPT_LONG 1
12201	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12202	>	fi
12203	>	echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12204	>	echo "${ECHO_T}$ac_cv_cpp_func" >&6
12205	>	if test $ac_cv_cpp_func = __FUNCTION__; then
12206	>
12207	>	cat >>confdefs.h <<\_ACEOF
12208	>	#define __func__ __FUNCTION__
12209		_ACEOF
12210
12211	<	else
5028	<	# use the GNU replacement
5029	<	case $LIBOBJS in
5030	<	"getopt.$ac_objext"   | \
5031	<	*" getopt.$ac_objext"   | \
5032	<	"getopt.$ac_objext "* | \
5033	<	*" getopt.$ac_objext "* ) ;;
5034	<	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5035	<	esac
12211	>	elif test $ac_cv_cpp_func = no; then
12212
12213	<	case $LIBOBJS in
12214	<	"getopt1.$ac_objext"   | \
12215	<	*" getopt1.$ac_objext"   | \
5040	<	"getopt1.$ac_objext "* | \
5041	<	*" getopt1.$ac_objext "* ) ;;
5042	<	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5043	<	esac
12213	>	cat >>confdefs.h <<\_ACEOF
12214	>	#define __func__ ""
12215	>	_ACEOF
12216
5045	–	ac_config_links="$ac_config_links utils/getopt.h:utils/gnugetopt.h"
5046	–
12217		fi
12218
5049	–	fi
5050	–	done
12219
12220
12221
12222	+
12223		case $debug in
12224		1)
12225		;;
#	Line 5059 | Line 12228 | case $debug in
12228
12229
12230
12231	+	# Try to determine "good" native compiler flags if none specified on command
12232	+	# line
12233
12234	+	if test "$ac_test_FFLAGS" != "set"; then
12235	+	FCFLAGS=""
12236	+	case "${host_cpu}-${host_os}" in
12237
12238	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12239	+	FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
12240	+	fi;;
12241	+	rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12242	+	FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12243	+	fi;;
12244	+	powerpc*-aix*)
12245	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12246	+	FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12247	+	echo "*******************************************************"
12248	+	echo "*  You have AIX on an unknown powerpc system.  It is  *"
12249	+	echo "*  recommended that you use                           *"
12250	+	echo "*                                                     *"
12251	+	echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12252	+	echo "*                                 ^^^                 *"
12253	+	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12254	+	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12255	+	echo "*******************************************************"
12256	+	fi;;
12257	+	*darwin*)
12258	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12259	+	FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12260	+	fi
12261	+	if test "$FC" = ifort; then
12262	+	FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12263	+	fi;;
12264	+	esac
12265	+
12266	+	if test -n "$CPU_FLAGS"; then
12267	+	FCFLAGS="$FCFLAGS $CPU_FLAGS"
12268	+	fi
12269	+
12270	+	if test -z "$FCFLAGS"; then
12271	+	echo ""
12272	+	echo "*********************************************************"
12273	+	echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12274	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12275	+	echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12276	+	echo "*********************************************************"
12277	+	echo ""
12278	+	FCFLAGS="-O3"
12279	+	fi
12280	+
12281	+
12282	+	echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12283	+	echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12284	+	if test "${ac_guessed_f90flags+set}" = set; then
12285	+	echo $ECHO_N "(cached) $ECHO_C" >&6
12286	+	else
12287	+
12288	+
12289	+
12290	+	ac_ext=${FC_SRCEXT-f}
12291	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12292	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12293	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12294	+
12295	+	echo 'program main' > conftest.$ac_ext
12296	+	echo 'end program main' >> conftest.$ac_ext
12297	+	ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12298	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12299	+	(eval $ac_compile) 2>&5
12300	+	ac_status=$?
12301	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12302	+	(exit $ac_status); }; then
12303	+	ac_guessed_f90flags=yes
12304	+	else
12305	+	ac_guessed_f90flags=no
12306	+	fi
12307	+	rm -f conftest*
12308	+	ac_ext=cc
12309	+	ac_cpp='$CXXCPP $CPPFLAGS'
12310	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12311	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12312	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12313	+
12314	+
12315	+	fi
12316	+	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12317	+	echo "${ECHO_T}$ac_guessed_f90flags" >&6
12318	+	if test "$ac_guessed_f90flags" = yes; then
12319	+	:
12320	+
12321	+	else
12322	+	:
12323	+
12324	+	echo ""
12325	+	echo "**********************************************************"
12326	+	echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12327	+	echo "* your compiler.                                        *"
12328	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12329	+	echo "*********************************************************"
12330	+	echo ""
12331	+	FCFLAGS=""
12332	+
12333	+	fi
12334	+
12335	+
12336	+	fi
12337	+
12338	+
12339	+
12340	+
12341	+
12342	+
12343	+
12344		echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12345		echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12346		if test "${ac_cv_prog_really_gcc+set}" = set; then
#	Line 5069 | Line 12349 | cat > conftest.c <<EOF
12349
12350		cat > conftest.c <<EOF
12351		#ifdef __GNUC__
12352	<	#ifndef __INTEL_COMPILER
12352	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12353	>	no;
12354	>	#else
12355		yes;
12356		#endif
12357		#endif
#	Line 5107 | Line 12389 | if test "$ac_test_CFLAGS" != "set"; then
12389		CFLAGS="-O"
12390		fi;;
12391		sparc-solaris2*) if test "$CC" = cc; then
12392	<	CFLAGS="-native -fast -xO5 -dalign"
12392	>	CFLAGS="-O -dalign"
12393		fi;;
12394
12395		alpha*-osf*)  if test "$CC" = cc; then
#	Line 5136 | Line 12418 | if test "$ac_test_CFLAGS" != "set"; then
12418		fi;;
12419		*darwin*)
12420		if test "$CC" = xlc -o "$CC" = cc; then
12421	<	CFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12421	>	CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12422	>	fi
12423	>	if test "$CC" = icc; then
12424	>	CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12425		fi;;
12426		esac
12427
#	Line 5150 | Line 12435 | if test "$ac_test_CFLAGS" != "set"; then
12435		# -malign-double for x86 systems
12436
12437
12438	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439	<	echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439	>	echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440		if test "${ac_align_double+set}" = set; then
12441		echo $ECHO_N "(cached) $ECHO_C" >&6
12442		else
12443		echo 'void f(){}' > conftest.c
12444	<	if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444	>	if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445		ac_align_double=yes
12446		else
12447		ac_align_double=no
#	Line 5177 | Line 12462 | fi
12462		# -fstrict-aliasing for gcc-2.95+
12463
12464
12465	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466	<	echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466	>	echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467		if test "${ac_fstrict_aliasing+set}" = set; then
12468		echo $ECHO_N "(cached) $ECHO_C" >&6
12469		else
12470		echo 'void f(){}' > conftest.c
12471	<	if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471	>	if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472		ac_fstrict_aliasing=yes
12473		else
12474		ac_fstrict_aliasing=no
#	Line 5208 | Line 12493 | fi
12493		case "${host_cpu}" in
12494		i586*)
12495
12496	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498		if test "${ac_cpu_pentium+set}" = set; then
12499		echo $ECHO_N "(cached) $ECHO_C" >&6
12500		else
12501		echo 'void f(){}' > conftest.c
12502	<	if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502	>	if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503		ac_cpu_pentium=yes
12504		else
12505		ac_cpu_pentium=no
#	Line 5231 | Line 12516 | else
12516		:
12517
12518
12519	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520	>	echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521		if test "${ac_pentium+set}" = set; then
12522		echo $ECHO_N "(cached) $ECHO_C" >&6
12523		else
12524		echo 'void f(){}' > conftest.c
12525	<	if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525	>	if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526		ac_pentium=yes
12527		else
12528		ac_pentium=no
#	Line 5260 | Line 12545 | fi
12545		;;
12546		i686*)
12547
12548	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550		if test "${ac_cpu_pentiumpro+set}" = set; then
12551		echo $ECHO_N "(cached) $ECHO_C" >&6
12552		else
12553		echo 'void f(){}' > conftest.c
12554	<	if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554	>	if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555		ac_cpu_pentiumpro=yes
12556		else
12557		ac_cpu_pentiumpro=no
#	Line 5283 | Line 12568 | else
12568		:
12569
12570
12571	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572	>	echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573		if test "${ac_pentiumpro+set}" = set; then
12574		echo $ECHO_N "(cached) $ECHO_C" >&6
12575		else
12576		echo 'void f(){}' > conftest.c
12577	<	if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577	>	if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578		ac_pentiumpro=yes
12579		else
12580		ac_pentiumpro=no
#	Line 5316 | Line 12601 | fi
12601		if test -n "$is60x"; then
12602
12603
12604	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606		if test "${ac_m_cpu_60x+set}" = set; then
12607		echo $ECHO_N "(cached) $ECHO_C" >&6
12608		else
12609		echo 'void f(){}' > conftest.c
12610	<	if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610	>	if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611		ac_m_cpu_60x=yes
12612		else
12613		ac_m_cpu_60x=no
#	Line 5374 | Line 12659 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12659		:
12660
12661
12662	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664		if test "${ac_m_cpu_750+set}" = set; then
12665		echo $ECHO_N "(cached) $ECHO_C" >&6
12666		else
12667		echo 'void f(){}' > conftest.c
12668	<	if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668	>	if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669		ac_m_cpu_750=yes
12670		else
12671		ac_m_cpu_750=no
#	Line 5407 | Line 12692 | fi
12692		if test -z "$CPU_FLAGS"; then
12693
12694
12695	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697		if test "${ac_m_cpu_powerpc+set}" = set; then
12698		echo $ECHO_N "(cached) $ECHO_C" >&6
12699		else
12700		echo 'void f(){}' > conftest.c
12701	<	if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701	>	if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702		ac_m_cpu_powerpc=yes
12703		else
12704		ac_m_cpu_powerpc=no
#	Line 5435 | Line 12720 | fi
12720		if test -z "$CPU_FLAGS"; then
12721
12722
12723	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724	>	echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725		if test "${ac_m_powerpc+set}" = set; then
12726		echo $ECHO_N "(cached) $ECHO_C" >&6
12727		else
12728		echo 'void f(){}' > conftest.c
12729	<	if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729	>	if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730		ac_m_powerpc=yes
12731		else
12732		ac_m_powerpc=no
#	Line 5480 | Line 12765 | fi
12765
12766
12767
12768	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769	<	echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768	>	echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769	>	echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770		if test "${ac_guessed_cflags+set}" = set; then
12771		echo $ECHO_N "(cached) $ECHO_C" >&6
12772		else
12773		echo 'void f(){}' > conftest.c
12774	<	if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774	>	if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775		ac_guessed_cflags=yes
12776		else
12777		ac_guessed_cflags=no
#	Line 5530 | Line 12815 | cat > conftest.cpp <<EOF
12815
12816		cat > conftest.cpp <<EOF
12817		#ifdef __GNUC__
12818	<	#ifndef __INTEL_COMPILER
12818	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12819	>	no;
12820	>	#else
12821		yes;
12822		#endif
12823		#endif
#	Line 5568 | Line 12855 | if test "$ac_test_CXXFLAGS" != "set"; then
12855		CXXFLAGS="-O"
12856		fi;;
12857		sparc-solaris2*) if test "$CXX" = CC; then
12858	<	CXXFLAGS="-native -fast -xO5 -dalign"
12858	>	CXXFLAGS="-features=extensions -O -dalign"
12859		fi;;
12860		rs6000*-aix*)  if test "$CXX" = xlC; then
12861		CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
#	Line 5587 | Line 12874 | if test "$ac_test_CXXFLAGS" != "set"; then
12874		echo "*******************************************************"
12875		fi;;
12876		*darwin*)
12877	<	if test "$CXX" = xlc++; then
12878	<	CXXFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12877	>	if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12878	>	CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12879	>	fi
12880	>	if test "$CXX" = icpc; then
12881	>	CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12882		fi;;
12883		esac
12884
#	Line 5602 | Line 12892 | if test "$ac_test_CXXFLAGS" != "set"; then
12892		# -malign-double for x86 systems
12893
12894
12895	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896	>	echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897		if test "${ac_align_double+set}" = set; then
12898		echo $ECHO_N "(cached) $ECHO_C" >&6
12899		else
12900		echo 'void f(){}' > conftest.cpp
12901	<	if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901	>	if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902		ac_align_double=yes
12903		else
12904		ac_align_double=no
#	Line 5629 | Line 12919 | fi
12919		# -fstrict-aliasing for gcc-2.95+
12920
12921
12922	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923	>	echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924		if test "${ac_fstrict_aliasing+set}" = set; then
12925		echo $ECHO_N "(cached) $ECHO_C" >&6
12926		else
12927		echo 'void f(){}' > conftest.cpp
12928	<	if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928	>	if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929		ac_fstrict_aliasing=yes
12930		else
12931		ac_fstrict_aliasing=no
#	Line 5660 | Line 12950 | fi
12950		case "${host_cpu}" in
12951		i586*)
12952
12953	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955		if test "${ac_cpu_pentium+set}" = set; then
12956		echo $ECHO_N "(cached) $ECHO_C" >&6
12957		else
12958		echo 'void f(){}' > conftest.cpp
12959	<	if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959	>	if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960		ac_cpu_pentium=yes
12961		else
12962		ac_cpu_pentium=no
#	Line 5683 | Line 12973 | else
12973		:
12974
12975
12976	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978		if test "${ac_pentium+set}" = set; then
12979		echo $ECHO_N "(cached) $ECHO_C" >&6
12980		else
12981		echo 'void f(){}' > conftest.cpp
12982	<	if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982	>	if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983		ac_pentium=yes
12984		else
12985		ac_pentium=no
#	Line 5712 | Line 13002 | fi
13002		;;
13003		i686*)
13004
13005	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007		if test "${ac_cpu_pentiumpro+set}" = set; then
13008		echo $ECHO_N "(cached) $ECHO_C" >&6
13009		else
13010		echo 'void f(){}' > conftest.cpp
13011	<	if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011	>	if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012		ac_cpu_pentiumpro=yes
13013		else
13014		ac_cpu_pentiumpro=no
#	Line 5735 | Line 13025 | else
13025		:
13026
13027
13028	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030		if test "${ac_pentiumpro+set}" = set; then
13031		echo $ECHO_N "(cached) $ECHO_C" >&6
13032		else
13033		echo 'void f(){}' > conftest.cpp
13034	<	if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034	>	if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035		ac_pentiumpro=yes
13036		else
13037		ac_pentiumpro=no
#	Line 5768 | Line 13058 | fi
13058		if test -n "$is60x"; then
13059
13060
13061	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063		if test "${ac_m_cpu_60x+set}" = set; then
13064		echo $ECHO_N "(cached) $ECHO_C" >&6
13065		else
13066		echo 'void f(){}' > conftest.cpp
13067	<	if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13067	>	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068		ac_m_cpu_60x=yes
13069		else
13070		ac_m_cpu_60x=no
#	Line 5826 | Line 13116 | if test "$ac_cv_prog_gxx_2_95" = yes; then
13116		:
13117
13118
13119	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
13120	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
13119	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121		if test "${ac_m_cpu_750+set}" = set; then
13122		echo $ECHO_N "(cached) $ECHO_C" >&6
13123		else
13124		echo 'void f(){}' > conftest.cpp
13125	<	if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13125	>	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126		ac_m_cpu_750=yes
13127		else
13128		ac_m_cpu_750=no
#	Line 5859 | Line 13149 | fi
13149		if test -z "$CPU_FLAGS"; then
13150
13151
13152	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
13153	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
13152	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154		if test "${ac_m_cpu_powerpc+set}" = set; then
13155		echo $ECHO_N "(cached) $ECHO_C" >&6
13156		else
13157		echo 'void f(){}' > conftest.cpp
13158	<	if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13158	>	if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159		ac_m_cpu_powerpc=yes
13160		else
13161		ac_m_cpu_powerpc=no
#	Line 5887 | Line 13177 | fi
13177		if test -z "$CPU_FLAGS"; then
13178
13179
13180	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
13181	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
13180	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13181	>	echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13182		if test "${ac_m_powerpc+set}" = set; then
13183		echo $ECHO_N "(cached) $ECHO_C" >&6
13184		else
13185		echo 'void f(){}' > conftest.cpp
13186	<	if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
13186	>	if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13187		ac_m_powerpc=yes
13188		else
13189		ac_m_powerpc=no
#	Line 5932 | Line 13222 | fi
13222
13223
13224
13225	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
13226	<	echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
13225	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13226	>	echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13227		if test "${ac_guessed_cxxflags+set}" = set; then
13228		echo $ECHO_N "(cached) $ECHO_C" >&6
13229		else
13230		echo 'void f(){}' > conftest.cpp
13231	<	if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13231	>	if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232		ac_guessed_cxxflags=yes
13233		else
13234		ac_guessed_cxxflags=no
#	Line 5965 | Line 13255 | fi
13255
13256		fi
13257
5968	–
5969	–	fi
5970	–
5971	–
5972	–
5973	–
5974	–
5975	–	# Try to determine "good" native compiler flags if none specified on command
5976	–	# line
5977	–
5978	–	if test x"$F90FLAGS" = x ; then
5979	–	F90FLAGS=""
5980	–	case "${host_cpu}-${host_os}" in
5981	–
5982	–	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
5983	–	F90FLAGS="-O"
5984	–	fi;;
5985	–	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
5986	–	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
5987	–	fi;;
5988	–	powerpc*-aix*)
5989	–	if test "$F90" = f90 -o "$F90" = xlf90; then
5990	–	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
5991	–	echo "*******************************************************"
5992	–	echo "*  You have AIX on an unknown powerpc system.  It is  *"
5993	–	echo "*  recommended that you use                           *"
5994	–	echo "*                                                     *"
5995	–	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
5996	–	echo "*                                 ^^^                 *"
5997	–	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
5998	–	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
5999	–	echo "*******************************************************"
6000	–	fi;;
6001	–	*darwin*)
6002	–	if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6003	–	F90FLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto"
6004	–	fi;;
6005	–	esac
6006	–
6007	–	if test -n "$CPU_FLAGS"; then
6008	–	F90FLAGS="$F90FLAGS $CPU_FLAGS"
6009	–	fi
6010	–
6011	–	if test -z "$F90FLAGS"; then
6012	–	echo ""
6013	–	echo "**********************************************************"
6014	–	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6015	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6016	–	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6017	–	echo "**********************************************************"
6018	–	echo ""
6019	–	F90FLAGS="-O3"
6020	–	fi
6021	–
6022	–
6023	–	echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6024	–	echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6025	–	if test "${ac_guessed_f90flags+set}" = set; then
6026	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6027	–	else
6028	–
6029	–
6030	–
6031	–	ac_ext=f90
6032	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6033	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6035	–
6036	–	echo 'program main' > conftest.$ac_ext
6037	–	echo 'end program main' >> conftest.$ac_ext
6038	–	ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6039	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6040	–	(eval $ac_compile) 2>&5
6041	–	ac_status=$?
6042	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6043	–	(exit $ac_status); }; then
6044	–	ac_guessed_f90flags=yes
6045	–	else
6046	–	ac_guessed_f90flags=no
6047	–	fi
6048	–	rm -f conftest*
6049	–	ac_ext=c
6050	–	ac_cpp='$CPP $CPPFLAGS'
6051	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6052	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6053	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6054	–
6055	–
6056	–	fi
6057	–	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6058	–	echo "${ECHO_T}$ac_guessed_f90flags" >&6
6059	–	if test "$ac_guessed_f90flags" = yes; then
6060	–	:
6061	–
6062	–	else
6063	–	:
6064	–
6065	–	echo ""
6066	–	echo "**********************************************************"
6067	–	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6068	–	echo "* your compiler.                                         *"
6069	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6070	–	echo "**********************************************************"
6071	–	echo ""
6072	–	F90FLAGS=""
6073	–
6074	–	fi
6075	–
6076	–
6077	–	fi
6078	–
6079	–	;;
6080	–	esac
6081	–
6082	–	# Find a good install program.  We prefer a C program (faster),
6083	–	# so one script is as good as another.  But avoid the broken or
6084	–	# incompatible versions:
6085	–	# SysV /etc/install, /usr/sbin/install
6086	–	# SunOS /usr/etc/install
6087	–	# IRIX /sbin/install
6088	–	# AIX /bin/install
6089	–	# AmigaOS /C/install, which installs bootblocks on floppy discs
6090	–	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6091	–	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
6092	–	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6093	–	# OS/2's system install, which has a completely different semantic
6094	–	# ./install, which can be erroneously created by make from ./install.sh.
6095	–	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6096	–	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6097	–	if test -z "$INSTALL"; then
6098	–	if test "${ac_cv_path_install+set}" = set; then
6099	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6100	–	else
6101	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6102	–	for as_dir in $PATH
6103	–	do
6104	–	IFS=$as_save_IFS
6105	–	test -z "$as_dir" && as_dir=.
6106	–	# Account for people who put trailing slashes in PATH elements.
6107	–	case $as_dir/ in
6108	–	./ | .// | /cC/* | \
6109	–	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6110	–	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6111	–	/usr/ucb/* ) ;;
6112	–	*)
6113	–	# OSF1 and SCO ODT 3.0 have their own names for install.
6114	–	# Don't use installbsd from OSF since it installs stuff as root
6115	–	# by default.
6116	–	for ac_prog in ginstall scoinst install; do
6117	–	for ac_exec_ext in '' $ac_executable_extensions; do
6118	–	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6119	–	if test $ac_prog = install &&
6120	–	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6121	–	# AIX install.  It has an incompatible calling convention.
6122	–	:
6123	–	elif test $ac_prog = install &&
6124	–	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6125	–	# program-specific install script used by HP pwplus--don't use.
6126	–	:
6127	–	else
6128	–	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6129	–	break 3
6130	–	fi
6131	–	fi
6132	–	done
6133	–	done
6134	–	;;
6135	–	esac
6136	–	done
6137	–
6138	–
6139	–	fi
6140	–	if test "${ac_cv_path_install+set}" = set; then
6141	–	INSTALL=$ac_cv_path_install
6142	–	else
6143	–	# As a last resort, use the slow shell script.  We don't cache a
6144	–	# path for INSTALL within a source directory, because that will
6145	–	# break other packages using the cache if that directory is
6146	–	# removed, or if the path is relative.
6147	–	INSTALL=$ac_install_sh
6148	–	fi
6149	–	fi
6150	–	echo "$as_me:$LINENO: result: $INSTALL" >&5
6151	–	echo "${ECHO_T}$INSTALL" >&6
6152	–
6153	–	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6154	–	# It thinks the first close brace ends the variable substitution.
6155	–	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6156	–
6157	–	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6158	–
6159	–	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6160	–
6161	–	echo "$as_me:$LINENO: checking whether ln -s works" >&5
6162	–	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6163	–	LN_S=$as_ln_s
6164	–	if test "$LN_S" = "ln -s"; then
6165	–	echo "$as_me:$LINENO: result: yes" >&5
6166	–	echo "${ECHO_T}yes" >&6
6167	–	else
6168	–	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6169	–	echo "${ECHO_T}no, using $LN_S" >&6
6170	–	fi
6171	–
6172	–	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6173	–	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6174	–	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6175	–	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6176	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6177	–	else
6178	–	cat >conftest.make <<\_ACEOF
6179	–	all:
6180	–	@echo 'ac_maketemp="$(MAKE)"'
6181	–	_ACEOF
6182	–	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6183	–	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6184	–	if test -n "$ac_maketemp"; then
6185	–	eval ac_cv_prog_make_${ac_make}_set=yes
6186	–	else
6187	–	eval ac_cv_prog_make_${ac_make}_set=no
6188	–	fi
6189	–	rm -f conftest.make
6190	–	fi
6191	–	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6192	–	echo "$as_me:$LINENO: result: yes" >&5
6193	–	echo "${ECHO_T}yes" >&6
6194	–	SET_MAKE=
6195	–	else
6196	–	echo "$as_me:$LINENO: result: no" >&5
6197	–	echo "${ECHO_T}no" >&6
6198	–	SET_MAKE="MAKE=${MAKE-make}"
6199	–	fi
6200	–
6201	–	if test -n "$ac_tool_prefix"; then
6202	–	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6203	–	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6204	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6205	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6206	–	if test "${ac_cv_prog_RANLIB+set}" = set; then
6207	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6208	–	else
6209	–	if test -n "$RANLIB"; then
6210	–	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6211	–	else
6212	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6213	–	for as_dir in $PATH
6214	–	do
6215	–	IFS=$as_save_IFS
6216	–	test -z "$as_dir" && as_dir=.
6217	–	for ac_exec_ext in '' $ac_executable_extensions; do
6218	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6219	–	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6220	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6221	–	break 2
6222	–	fi
6223	–	done
6224	–	done
6225	–
6226	–	fi
6227	–	fi
6228	–	RANLIB=$ac_cv_prog_RANLIB
6229	–	if test -n "$RANLIB"; then
6230	–	echo "$as_me:$LINENO: result: $RANLIB" >&5
6231	–	echo "${ECHO_T}$RANLIB" >&6
6232	–	else
6233	–	echo "$as_me:$LINENO: result: no" >&5
6234	–	echo "${ECHO_T}no" >&6
6235	–	fi
6236	–
6237	–	fi
6238	–	if test -z "$ac_cv_prog_RANLIB"; then
6239	–	ac_ct_RANLIB=$RANLIB
6240	–	# Extract the first word of "ranlib", so it can be a program name with args.
6241	–	set dummy ranlib; ac_word=$2
6242	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6243	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6244	–	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6245	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6246	–	else
6247	–	if test -n "$ac_ct_RANLIB"; then
6248	–	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6249	–	else
6250	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6251	–	for as_dir in $PATH
6252	–	do
6253	–	IFS=$as_save_IFS
6254	–	test -z "$as_dir" && as_dir=.
6255	–	for ac_exec_ext in '' $ac_executable_extensions; do
6256	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6257	–	ac_cv_prog_ac_ct_RANLIB="ranlib"
6258	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6259	–	break 2
6260	–	fi
6261	–	done
6262	–	done
6263	–
6264	–	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6265	–	fi
6266	–	fi
6267	–	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6268	–	if test -n "$ac_ct_RANLIB"; then
6269	–	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6270	–	echo "${ECHO_T}$ac_ct_RANLIB" >&6
6271	–	else
6272	–	echo "$as_me:$LINENO: result: no" >&5
6273	–	echo "${ECHO_T}no" >&6
6274	–	fi
6275	–
6276	–	RANLIB=$ac_ct_RANLIB
6277	–	else
6278	–	RANLIB="$ac_cv_prog_RANLIB"
6279	–	fi
6280	–
6281	–	for ac_prog in 'bison -y' byacc
6282	–	do
6283	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6284	–	set dummy $ac_prog; ac_word=$2
6285	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6286	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6287	–	if test "${ac_cv_prog_YACC+set}" = set; then
6288	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6289	–	else
6290	–	if test -n "$YACC"; then
6291	–	ac_cv_prog_YACC="$YACC" # Let the user override the test.
6292	–	else
6293	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6294	–	for as_dir in $PATH
6295	–	do
6296	–	IFS=$as_save_IFS
6297	–	test -z "$as_dir" && as_dir=.
6298	–	for ac_exec_ext in '' $ac_executable_extensions; do
6299	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6300	–	ac_cv_prog_YACC="$ac_prog"
6301	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6302	–	break 2
6303	–	fi
6304	–	done
6305	–	done
6306	–
6307	–	fi
6308	–	fi
6309	–	YACC=$ac_cv_prog_YACC
6310	–	if test -n "$YACC"; then
6311	–	echo "$as_me:$LINENO: result: $YACC" >&5
6312	–	echo "${ECHO_T}$YACC" >&6
6313	–	else
6314	–	echo "$as_me:$LINENO: result: no" >&5
6315	–	echo "${ECHO_T}no" >&6
6316	–	fi
6317	–
6318	–	test -n "$YACC" && break
6319	–	done
6320	–	test -n "$YACC" || YACC="yacc"
6321	–
6322	–	for ac_prog in flex lex
6323	–	do
6324	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6325	–	set dummy $ac_prog; ac_word=$2
6326	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6327	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6328	–	if test "${ac_cv_prog_LEX+set}" = set; then
6329	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6330	–	else
6331	–	if test -n "$LEX"; then
6332	–	ac_cv_prog_LEX="$LEX" # Let the user override the test.
6333	–	else
6334	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6335	–	for as_dir in $PATH
6336	–	do
6337	–	IFS=$as_save_IFS
6338	–	test -z "$as_dir" && as_dir=.
6339	–	for ac_exec_ext in '' $ac_executable_extensions; do
6340	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6341	–	ac_cv_prog_LEX="$ac_prog"
6342	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6343	–	break 2
6344	–	fi
6345	–	done
6346	–	done
6347	–
6348	–	fi
6349	–	fi
6350	–	LEX=$ac_cv_prog_LEX
6351	–	if test -n "$LEX"; then
6352	–	echo "$as_me:$LINENO: result: $LEX" >&5
6353	–	echo "${ECHO_T}$LEX" >&6
6354	–	else
6355	–	echo "$as_me:$LINENO: result: no" >&5
6356	–	echo "${ECHO_T}no" >&6
6357	–	fi
6358	–
6359	–	test -n "$LEX" && break
6360	–	done
6361	–	test -n "$LEX" || LEX=":"
6362	–
6363	–	if test -z "$LEXLIB"
6364	–	then
6365	–	echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6366	–	echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6367	–	if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6368	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6369	–	else
6370	–	ac_check_lib_save_LIBS=$LIBS
6371	–	LIBS="-lfl  $LIBS"
6372	–	cat >conftest.$ac_ext <<_ACEOF
6373	–	/* confdefs.h.  */
6374	–	_ACEOF
6375	–	cat confdefs.h >>conftest.$ac_ext
6376	–	cat >>conftest.$ac_ext <<_ACEOF
6377	–	/* end confdefs.h.  */
6378	–
6379	–	/* Override any gcc2 internal prototype to avoid an error.  */
6380	–	#ifdef __cplusplus
6381	–	extern "C"
6382	–	#endif
6383	–	/* We use char because int might match the return type of a gcc2
6384	–	builtin and then its argument prototype would still apply.  */
6385	–	char yywrap ();
6386	–	int
6387	–	main ()
6388	–	{
6389	–	yywrap ();
6390	–	;
6391	–	return 0;
6392	–	}
6393	–	_ACEOF
6394	–	rm -f conftest.$ac_objext conftest$ac_exeext
6395	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6396	–	(eval $ac_link) 2>conftest.er1
6397	–	ac_status=$?
6398	–	grep -v '^ *+' conftest.er1 >conftest.err
6399	–	rm -f conftest.er1
6400	–	cat conftest.err >&5
6401	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6402	–	(exit $ac_status); } &&
6403	–	{ ac_try='test -z "$ac_c_werror_flag"
6404	–	|| test ! -s conftest.err'
6405	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6406	–	(eval $ac_try) 2>&5
6407	–	ac_status=$?
6408	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6409	–	(exit $ac_status); }; } &&
6410	–	{ ac_try='test -s conftest$ac_exeext'
6411	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6412	–	(eval $ac_try) 2>&5
6413	–	ac_status=$?
6414	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6415	–	(exit $ac_status); }; }; then
6416	–	ac_cv_lib_fl_yywrap=yes
6417	–	else
6418	–	echo "$as_me: failed program was:" >&5
6419	–	sed 's/^/| /' conftest.$ac_ext >&5
6420	–
6421	–	ac_cv_lib_fl_yywrap=no
6422	–	fi
6423	–	rm -f conftest.err conftest.$ac_objext \
6424	–	conftest$ac_exeext conftest.$ac_ext
6425	–	LIBS=$ac_check_lib_save_LIBS
6426	–	fi
6427	–	echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6428	–	echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6429	–	if test $ac_cv_lib_fl_yywrap = yes; then
6430	–	LEXLIB="-lfl"
6431	–	else
6432	–	echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6433	–	echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6434	–	if test "${ac_cv_lib_l_yywrap+set}" = set; then
6435	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6436	–	else
6437	–	ac_check_lib_save_LIBS=$LIBS
6438	–	LIBS="-ll  $LIBS"
6439	–	cat >conftest.$ac_ext <<_ACEOF
6440	–	/* confdefs.h.  */
6441	–	_ACEOF
6442	–	cat confdefs.h >>conftest.$ac_ext
6443	–	cat >>conftest.$ac_ext <<_ACEOF
6444	–	/* end confdefs.h.  */
6445	–
6446	–	/* Override any gcc2 internal prototype to avoid an error.  */
6447	–	#ifdef __cplusplus
6448	–	extern "C"
6449	–	#endif
6450	–	/* We use char because int might match the return type of a gcc2
6451	–	builtin and then its argument prototype would still apply.  */
6452	–	char yywrap ();
6453	–	int
6454	–	main ()
6455	–	{
6456	–	yywrap ();
6457	–	;
6458	–	return 0;
6459	–	}
6460	–	_ACEOF
6461	–	rm -f conftest.$ac_objext conftest$ac_exeext
6462	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6463	–	(eval $ac_link) 2>conftest.er1
6464	–	ac_status=$?
6465	–	grep -v '^ *+' conftest.er1 >conftest.err
6466	–	rm -f conftest.er1
6467	–	cat conftest.err >&5
6468	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6469	–	(exit $ac_status); } &&
6470	–	{ ac_try='test -z "$ac_c_werror_flag"
6471	–	|| test ! -s conftest.err'
6472	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6473	–	(eval $ac_try) 2>&5
6474	–	ac_status=$?
6475	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6476	–	(exit $ac_status); }; } &&
6477	–	{ ac_try='test -s conftest$ac_exeext'
6478	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6479	–	(eval $ac_try) 2>&5
6480	–	ac_status=$?
6481	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6482	–	(exit $ac_status); }; }; then
6483	–	ac_cv_lib_l_yywrap=yes
6484	–	else
6485	–	echo "$as_me: failed program was:" >&5
6486	–	sed 's/^/| /' conftest.$ac_ext >&5
6487	–
6488	–	ac_cv_lib_l_yywrap=no
6489	–	fi
6490	–	rm -f conftest.err conftest.$ac_objext \
6491	–	conftest$ac_exeext conftest.$ac_ext
6492	–	LIBS=$ac_check_lib_save_LIBS
6493	–	fi
6494	–	echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6495	–	echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6496	–	if test $ac_cv_lib_l_yywrap = yes; then
6497	–	LEXLIB="-ll"
6498	–	fi
6499	–
6500	–	fi
6501	–
6502	–	fi
6503	–
6504	–	if test "x$LEX" != "x:"; then
6505	–	echo "$as_me:$LINENO: checking lex output file root" >&5
6506	–	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6507	–	if test "${ac_cv_prog_lex_root+set}" = set; then
6508	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6509	–	else
6510	–	# The minimal lex program is just a single line: %%.  But some broken lexes
6511	–	# (Solaris, I think it was) want two %% lines, so accommodate them.
6512	–	cat >conftest.l <<_ACEOF
6513	–	%%
6514	–	%%
6515	–	_ACEOF
6516	–	{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6517	–	(eval $LEX conftest.l) 2>&5
6518	–	ac_status=$?
6519	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6520	–	(exit $ac_status); }
6521	–	if test -f lex.yy.c; then
6522	–	ac_cv_prog_lex_root=lex.yy
6523	–	elif test -f lexyy.c; then
6524	–	ac_cv_prog_lex_root=lexyy
6525	–	else
6526	–	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6527	–	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6528	–	{ (exit 1); exit 1; }; }
6529	–	fi
6530	–	fi
6531	–	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6532	–	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6533	–	rm -f conftest.l
6534	–	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6535	–
6536	–	echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6537	–	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6538	–	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6539	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6540	–	else
6541	–	# POSIX says lex can declare yytext either as a pointer or an array; the
6542	–	# default is implementation-dependent. Figure out which it is, since
6543	–	# not all implementations provide the %pointer and %array declarations.
6544	–	ac_cv_prog_lex_yytext_pointer=no
6545	–	echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6546	–	ac_save_LIBS=$LIBS
6547	–	LIBS="$LIBS $LEXLIB"
6548	–	cat >conftest.$ac_ext <<_ACEOF
6549	–	`cat $LEX_OUTPUT_ROOT.c`
6550	–	_ACEOF
6551	–	rm -f conftest.$ac_objext conftest$ac_exeext
6552	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6553	–	(eval $ac_link) 2>conftest.er1
6554	–	ac_status=$?
6555	–	grep -v '^ *+' conftest.er1 >conftest.err
6556	–	rm -f conftest.er1
6557	–	cat conftest.err >&5
6558	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6559	–	(exit $ac_status); } &&
6560	–	{ ac_try='test -z "$ac_c_werror_flag"
6561	–	|| test ! -s conftest.err'
6562	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6563	–	(eval $ac_try) 2>&5
6564	–	ac_status=$?
6565	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6566	–	(exit $ac_status); }; } &&
6567	–	{ ac_try='test -s conftest$ac_exeext'
6568	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6569	–	(eval $ac_try) 2>&5
6570	–	ac_status=$?
6571	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6572	–	(exit $ac_status); }; }; then
6573	–	ac_cv_prog_lex_yytext_pointer=yes
6574	–	else
6575	–	echo "$as_me: failed program was:" >&5
6576	–	sed 's/^/| /' conftest.$ac_ext >&5
6577	–
6578	–	fi
6579	–	rm -f conftest.err conftest.$ac_objext \
6580	–	conftest$ac_exeext conftest.$ac_ext
6581	–	LIBS=$ac_save_LIBS
6582	–	rm -f "${LEX_OUTPUT_ROOT}.c"
6583	–
6584	–	fi
6585	–	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6586	–	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6587	–	if test $ac_cv_prog_lex_yytext_pointer = yes; then
6588	–
6589	–	cat >>confdefs.h <<\_ACEOF
6590	–	#define YYTEXT_POINTER 1
6591	–	_ACEOF
6592	–
6593	–	fi
6594	–
6595	–	fi
6596	–	# Extract the first word of "ar", so it can be a program name with args.
6597	–	set dummy ar; ac_word=$2
6598	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6599	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6600	–	if test "${ac_cv_prog_AR+set}" = set; then
6601	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6602	–	else
6603	–	if test -n "$AR"; then
6604	–	ac_cv_prog_AR="$AR" # Let the user override the test.
6605	–	else
6606	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607	–	for as_dir in $PATH
6608	–	do
6609	–	IFS=$as_save_IFS
6610	–	test -z "$as_dir" && as_dir=.
6611	–	for ac_exec_ext in '' $ac_executable_extensions; do
6612	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613	–	ac_cv_prog_AR="ar"
6614	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6615	–	break 2
6616	–	fi
6617	–	done
6618	–	done
13258
6620	–	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13259		fi
6622	–	fi
6623	–	AR=$ac_cv_prog_AR
6624	–	if test -n "$AR"; then
6625	–	echo "$as_me:$LINENO: result: $AR" >&5
6626	–	echo "${ECHO_T}$AR" >&6
6627	–	else
6628	–	echo "$as_me:$LINENO: result: no" >&5
6629	–	echo "${ECHO_T}no" >&6
6630	–	fi
13260
13261	<	if test "$AR" = "NONE"; then
13262	<	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6634	<	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6635	<	{ (exit 1); exit 1; }; }
6636	<	cat >confcache <<\_ACEOF
6637	<	# This file is a shell script that caches the results of configure
6638	<	# tests run on this system so they can be shared between configure
6639	<	# scripts and configure runs, see configure's option --config-cache.
6640	<	# It is not useful on other systems.  If it contains results you don't
6641	<	# want to keep, you may remove or edit it.
6642	<	#
6643	<	# config.status only pays attention to the cache file if you give it
6644	<	# the --recheck option to rerun configure.
6645	<	#
6646	<	# `ac_cv_env_foo' variables (set or unset) will be overridden when
6647	<	# loading this file, other *unset* `ac_cv_foo' will be assigned the
6648	<	# following values.
13261	>	;;
13262	>	esac
13263
13264	+
13265	+	cat >>confdefs.h <<\_ACEOF
13266	+	#define OBAPI
13267		_ACEOF
13268
6652	–	# The following way of writing the cache mishandles newlines in values,
6653	–	# but we know of no workaround that is simple, portable, and efficient.
6654	–	# So, don't put newlines in cache variables' values.
6655	–	# Ultrix sh set writes to stderr and can't be redirected directly,
6656	–	# and sets the high bit in the cache file unless we assign to the vars.
6657	–	{
6658	–	(set) 2>&1 |
6659	–	case `(ac_space=' '; set | grep ac_space) 2>&1` in
6660	–	*ac_space=\ *)
6661	–	# `set' does not quote correctly, so add quotes (double-quote
6662	–	# substitution turns \\\\ into \\, and sed turns \\ into \).
6663	–	sed -n \
6664	–	"s/'/'\\\\''/g;
6665	–	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6666	–	;;
6667	–	*)
6668	–	# `set' quotes correctly as required by POSIX, so do not add quotes.
6669	–	sed -n \
6670	–	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6671	–	;;
6672	–	esac;
6673	–	} |
6674	–	sed '
6675	–	t clear
6676	–	: clear
6677	–	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6678	–	t end
6679	–	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6680	–	: end' >>confcache
6681	–	if diff $cache_file confcache >/dev/null 2>&1; then :; else
6682	–	if test -w $cache_file; then
6683	–	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6684	–	cat confcache >$cache_file
6685	–	else
6686	–	echo "not updating unwritable cache $cache_file"
6687	–	fi
6688	–	fi
6689	–	rm -f confcache
6690	–	exit 1
6691	–	fi
13269
13270
13271
#	Line 6720 | Line 13297 | have_mpi_h=0
13297		echo "$as_me:$LINENO: checking for mpi.h" >&5
13298		echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13299		have_mpi_h=0
13300	+	rm -f conftest*
13301		echo '#include <mpi.h>' > conftest.cc
13302	<	if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13302	>	if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13303		echo "$as_me:$LINENO: result: yes" >&5
13304		echo "${ECHO_T}yes" >&6
13305		have_mpi_h=1
13306		else
13307	+	if test -s conftest.out ; then
13308	+	cat conftest.out >> config.log
13309	+	fi
13310		echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13311		echo "${ECHO_T}no! Check MPI include paths" >&6
13312		USE_MPI="no"
#	Line 6743 | Line 13324 | rm -f conftest*
13324		echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325		have_mpif_h=0
13326		rm -f conftest*
13327	<	cat >conftest.f90 <<EOF
13327	>	cat >conftest.$ac_ext <<EOF
13328		program main
13329		include 'mpif.h'
13330		end
13331		EOF
13332	<	if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332	>	if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333		echo "$as_me:$LINENO: result: yes" >&5
13334		echo "${ECHO_T}yes" >&6
13335		MPI_F90_INC="$MPI_INC_DIR"
#	Line 6802 | Line 13383 | char MPI_Init ();
13383		/* We use char because int might match the return type of a gcc2
13384		builtin and then its argument prototype would still apply.  */
13385		char MPI_Init ();
13386	+	#ifdef FC_DUMMY_MAIN
13387	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13388	+	#  ifdef __cplusplus
13389	+	extern "C"
13390	+	#  endif
13391	+	int FC_DUMMY_MAIN() { return 1; }
13392	+	#endif
13393	+	#endif
13394		int
13395		main ()
13396		{
#	Line 6872 | Line 13461 | char MPI_Init ();
13461		/* We use char because int might match the return type of a gcc2
13462		builtin and then its argument prototype would still apply.  */
13463		char MPI_Init ();
13464	+	#ifdef FC_DUMMY_MAIN
13465	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13466	+	#  ifdef __cplusplus
13467	+	extern "C"
13468	+	#  endif
13469	+	int FC_DUMMY_MAIN() { return 1; }
13470	+	#endif
13471	+	#endif
13472		int
13473		main ()
13474		{
#	Line 6943 | Line 13540 | char MPI_Init ();
13540		/* We use char because int might match the return type of a gcc2
13541		builtin and then its argument prototype would still apply.  */
13542		char MPI_Init ();
13543	+	#ifdef FC_DUMMY_MAIN
13544	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13545	+	#  ifdef __cplusplus
13546	+	extern "C"
13547	+	#  endif
13548	+	int FC_DUMMY_MAIN() { return 1; }
13549	+	#endif
13550	+	#endif
13551		int
13552		main ()
13553		{
#	Line 6991 | Line 13596 | fi
13596		fi
13597
13598		fi
13599	<
6995	<	$as_unset ac_cv_lib_mpi_MPI_Init
13599	>	$as_unset ac_cv_lib_mpich_MPI_Init
13600		if test x = x"$MPI_LIB"; then
13601	<	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13602	<	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13603	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13601	>	echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13602	>	echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13603	>	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13604		echo $ECHO_N "(cached) $ECHO_C" >&6
13605		else
13606		ac_check_lib_save_LIBS=$LIBS
13607	<	LIBS="-lmpi -llam -lpthread $LIBS"
13607	>	LIBS="-lmpich "-lpmpich" $LIBS"
13608		cat >conftest.$ac_ext <<_ACEOF
13609		/* confdefs.h.  */
13610		_ACEOF
#	Line 7015 | Line 13619 | char MPI_Init ();
13619		/* We use char because int might match the return type of a gcc2
13620		builtin and then its argument prototype would still apply.  */
13621		char MPI_Init ();
13622	+	#ifdef FC_DUMMY_MAIN
13623	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13624	+	#  ifdef __cplusplus
13625	+	extern "C"
13626	+	#  endif
13627	+	int FC_DUMMY_MAIN() { return 1; }
13628	+	#endif
13629	+	#endif
13630		int
13631		main ()
13632		{
#	Line 7045 | Line 13657 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13657		ac_status=$?
13658		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13659		(exit $ac_status); }; }; then
13660	<	ac_cv_lib_mpi_MPI_Init=yes
13660	>	ac_cv_lib_mpich_MPI_Init=yes
13661		else
13662		echo "$as_me: failed program was:" >&5
13663		sed 's/^/| /' conftest.$ac_ext >&5
13664
13665	<	ac_cv_lib_mpi_MPI_Init=no
13665	>	ac_cv_lib_mpich_MPI_Init=no
13666		fi
13667		rm -f conftest.err conftest.$ac_objext \
13668		conftest$ac_exeext conftest.$ac_ext
13669		LIBS=$ac_check_lib_save_LIBS
13670		fi
13671	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13672	<	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13673	<	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13674	<	MPI_LIB="-lmpi -llam -lpthread"
7063	<	else
7064	<
7065	<	{ { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7066	<	echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7067	<	{ (exit 1); exit 1; }; }
7068	<	USE_MPI="no"
7069	<
13671	>	echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13672	>	echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13673	>	if test $ac_cv_lib_mpich_MPI_Init = yes; then
13674	>	MPI_LIB="-lpmpich -lmpich"
13675		fi
13676
13677		fi
13678
13679	<
13680	<
13681	<	echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13682	<	echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13683	<	MPI_F90_LIB=""
7079	<	if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7080	<	MPI_F90_LIB="-lfmpich"
7081	<	elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7082	<	MPI_F90_LIB="-llamf77mpi"
7083	<	else
7084	<	MPI_F90_LIB="  "
7085	<	fi
7086	<	echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7087	<	echo "${ECHO_T}found $MPI_F90_LIB" >&6
7088	<
7089	<
7090	<	fi
7091	<
7092	<
7093	<
7094	<	# Check whether --with-sprng or --without-sprng was given.
7095	<	if test "${with_sprng+set}" = set; then
7096	<	withval="$with_sprng"
7097	<	with_sprng=$withval
7098	<	else
7099	<	with_sprng="/usr/local"
7100	<	fi;
7101	<
7102	<	case "x$with_sprng" in
7103	<	xyes | "x")  USE_SPRNG=yes;;
7104	<	xno) USE_SPRNG=no ;;
7105	<	*) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7106	<	esac
7107	<	if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7108	<	SPRNG="/usr/local"
7109	<	fi
7110	<	if test "$USE_SPRNG" = "yes"; then
7111	<
7112	<
7113	<	# Set variables...
7114	<	SPRNG_LIB_DIR="$SPRNG/lib"
7115	<	SPRNG_INC_DIR="$SPRNG/include"
7116	<
7117	<
7118	<
7119	<	echo "$as_me:$LINENO: checking for sprng.h" >&5
7120	<	echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7121	<	have_sprng_h=0
7122	<	echo '#include <sprng.h>' > conftest.cc
7123	<	if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7124	<	echo "$as_me:$LINENO: result: yes" >&5
7125	<	echo "${ECHO_T}yes" >&6
7126	<	have_sprng_h=1
7127	<	else
7128	<	echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7129	<	echo "${ECHO_T}no! Check SPRNG include path!" >&6
7130	<	USE_SPRNG="no"
7131	<	fi
7132	<	rm -f conftest*
7133	<	if test "$have_sprng_h" = 1; then
7134	<
7135	<	cat >>confdefs.h <<\_ACEOF
7136	<	#define HAVE_SPRNG_H 1
7137	<	_ACEOF
7138	<
7139	<	fi
7140	<
7141	<	ac_ext=c
7142	<	ac_cpp='$CPP $CPPFLAGS'
7143	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7144	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7145	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
7146	<
7147	<	ac_save_LDFLAGS=$LDFLAGS
7148	<	LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
7149	<
7150	<	echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
7151	<	echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
7152	<	if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
13679	>	$as_unset ac_cv_lib_mpi_MPI_Init
13680	>	if test x = x"$MPI_LIB"; then
13681	>	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13682	>	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13683	>	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13684		echo $ECHO_N "(cached) $ECHO_C" >&6
13685		else
13686		ac_check_lib_save_LIBS=$LIBS
13687	<	LIBS="-lsprng  $LIBS"
13687	>	LIBS="-lmpi -llam -lpthread $LIBS"
13688		cat >conftest.$ac_ext <<_ACEOF
13689		/* confdefs.h.  */
13690		_ACEOF
#	Line 7167 | Line 13698 | extern "C"
13698		#endif
13699		/* We use char because int might match the return type of a gcc2
13700		builtin and then its argument prototype would still apply.  */
13701	<	char init_rng ();
13701	>	char MPI_Init ();
13702	>	#ifdef FC_DUMMY_MAIN
13703	>	#ifndef FC_DUMMY_MAIN_EQ_F77
13704	>	#  ifdef __cplusplus
13705	>	extern "C"
13706	>	#  endif
13707	>	int FC_DUMMY_MAIN() { return 1; }
13708	>	#endif
13709	>	#endif
13710		int
13711		main ()
13712		{
13713	<	init_rng ();
13713	>	MPI_Init ();
13714		;
13715		return 0;
13716		}
#	Line 7198 | Line 13737 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13737		ac_status=$?
13738		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13739		(exit $ac_status); }; }; then
13740	<	ac_cv_lib_sprng_init_rng=yes
13740	>	ac_cv_lib_mpi_MPI_Init=yes
13741		else
13742		echo "$as_me: failed program was:" >&5
13743		sed 's/^/| /' conftest.$ac_ext >&5
13744
13745	<	ac_cv_lib_sprng_init_rng=no
13745	>	ac_cv_lib_mpi_MPI_Init=no
13746		fi
13747		rm -f conftest.err conftest.$ac_objext \
13748		conftest$ac_exeext conftest.$ac_ext
13749		LIBS=$ac_check_lib_save_LIBS
13750		fi
13751	<	echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
13752	<	echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
13753	<	if test $ac_cv_lib_sprng_init_rng = yes; then
13754	<	SPRNG_LIB="-lsprng"
13751	>	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13752	>	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13753	>	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13754	>	MPI_LIB="-lmpi -llam -lpthread"
13755		else
13756
13757	<	{ { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13758	<	echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13757	>	{ { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13758	>	echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13759		{ (exit 1); exit 1; }; }
13760	<	USE_SPRNG="no"
13760	>	USE_MPI="no"
13761
13762		fi
13763
13764	+	fi
13765
13766	<	if test "$USE_SPRNG" = "no"; then
13767	<	{ { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
13768	<	echo "$as_me: error: No working SPRNG library found" >&2;}
13769	<	{ (exit 1); exit 1; }; }
13766	>
13767	>
13768	>	echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13769	>	echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13770	>	MPI_F90_LIB=""
13771	>	if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13772	>	MPI_F90_LIB="-lfmpich"
13773	>	elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13774	>	MPI_F90_LIB="-llamf77mpi"
13775	>	else
13776	>	MPI_F90_LIB="  "
13777		fi
13778	+	echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13779	+	echo "${ECHO_T}found $MPI_F90_LIB" >&6
13780
13781
13782		fi
13783
13784
13785
7237	–	echo "$as_me:$LINENO: checking if MKL is wanted" >&5
7238	–	echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13786
13787	<	# Check whether --with-mkl or --without-mkl was given.
13788	<	if test "${with_mkl+set}" = set; then
13789	<	withval="$with_mkl"
13790	<	echo "$as_me:$LINENO: result: yes" >&5
13791	<	echo "${ECHO_T}yes" >&6
13792	<	for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
13793	<	mkldir="$dir"
13794	<	if test -f "$dir/include/mkl.h"; then
13795	<	found_mkl="yes";
13796	<	break;
13797	<	fi
13798	<	done
13799	<	if test x_$found_mkl != x_yes; then
13800	<	{ { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
13801	<	echo "$as_me: error: Cannot find MKL includes" >&2;}
13802	<	{ (exit 1); exit 1; }; }
13803	<	else
13804	<	printf "MKL includes found in $mkldir/include\n";
13787	>	USE_CGAL=no
13788	>	cgal_makefile=auto
13789	>
13790	>	# Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13791	>	if test "${with_cgal_makefile+set}" = set; then
13792	>	withval="$with_cgal_makefile"
13793	>	cgal_makefile="$withval"
13794	>	fi;
13795	>
13796	>	if test "x$cgal_makefile" != xno; then
13797	>
13798	>	if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13799	>	cgal_makefile="$CGAL_MAKEFILE"
13800	>	fi
13801	>
13802	>	echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13803	>	echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13804	>
13805	>	if test -f "$cgal_makefile"; then
13806	>
13807	>	cat >config.tmp.Makefile <<EOF
13808	>	include $cgal_makefile
13809	>	default:
13810	>	@echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13811	>	@echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13812	>	@echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13813	>	@echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13814	>	@echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13815	>	@echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13816	>	@echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13817	>	@echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13818	>	@echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13819	>	@echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13820	>	@echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13821	>	@echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13822	>	EOF
13823	>
13824	>	make -s -f config.tmp.Makefile
13825	>	. config.tmp.cgalvariables
13826	>
13827	>	rm -f config.tmp.Makefile config.tmp.cgalvariables
13828	>
13829	>	if test "x$CGAL_INCLDIR" = "x"; then
13830	>	CGAL_INCLDIR=""
13831		fi
13832
13833	+	if test "x$CGAL_LIBDIR" = "x"; then
13834	+	CGAL_LIBDIR=""
13835	+	fi
13836
13837	+	if test "x$CGAL_RLIBDIR" = "x"; then
13838	+	CGAL_RLIBDIR=""
13839	+	fi
13840
13841	<	ac_ext=c
13842	<	ac_cpp='$CPP $CPPFLAGS'
13843	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7265	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7266	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13841	>	if test "x$LEDA_INCLDIR" = "x"; then
13842	>	LEDA_INCLDIR=""
13843	>	fi
13844
13845	<	ac_save_CPPFLAGS=$CPPFLAGS
13846	<	CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
13847	<	ac_save_LDFLAGS=$LDFLAGS
13848	<	LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
13849	<	if test "${ac_cv_header_mkl_h+set}" = set; then
13850	<	echo "$as_me:$LINENO: checking for mkl.h" >&5
13851	<	echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13852	<	if test "${ac_cv_header_mkl_h+set}" = set; then
13845	>	if test "x$LEDA_LIBDIR" = "x"; then
13846	>	LEDA_LIBDIR=""
13847	>	fi
13848	>
13849	>	if test "x$LEDA_RLIBDIR" = "x"; then
13850	>	LEDA_RLIBDIR=""
13851	>	fi
13852	>
13853	>	if test "x$GMP_INCLDIR" = "x"; then
13854	>	GMP_INCLDIR=""
13855	>	fi
13856	>
13857	>	if test "x$GMP_LIBDIR" = "x"; then
13858	>	GMP_LIBDIR=""
13859	>	fi
13860	>
13861	>	if test "x$GMP_RLIBDIR" = "x"; then
13862	>	GMP_RLIBDIR=""
13863	>	fi
13864	>
13865	>	echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13866	>	echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13867	>	echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13868	>	echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13869	>	echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13870	>	echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13871	>	echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13872	>	echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13873	>	echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13874	>	echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13875	>	echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13876	>	echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13877	>	echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13878	>	echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13879	>	echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13880	>	echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13881	>	echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13882	>	echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13883	>
13884	>	ac_ext=cc
13885	>	ac_cpp='$CXXCPP $CPPFLAGS'
13886	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13887	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13888	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13889	>
13890	>	save_CXXFLAGS="$CXXFLAGS"
13891	>	CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13892	>	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13893	>	echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13894	>	echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13895	>	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13896		echo $ECHO_N "(cached) $ECHO_C" >&6
13897		fi
13898	<	echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13899	<	echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13898	>	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13899	>	echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13900		else
13901		# Is the header compilable?
13902	<	echo "$as_me:$LINENO: checking mkl.h usability" >&5
13903	<	echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13902	>	echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13903	>	echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13904		cat >conftest.$ac_ext <<_ACEOF
13905		/* confdefs.h.  */
13906		_ACEOF
#	Line 7288 | Line 13908 | $ac_includes_default
13908		cat >>conftest.$ac_ext <<_ACEOF
13909		/* end confdefs.h.  */
13910		$ac_includes_default
13911	<	#include <mkl.h>
13911	>	#include <CGAL/Cartesian.h>
13912		_ACEOF
13913		rm -f conftest.$ac_objext
13914		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 7299 | Line 13919 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13919		cat conftest.err >&5
13920		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13921		(exit $ac_status); } &&
13922	<	{ ac_try='test -z "$ac_c_werror_flag"
13922	>	{ ac_try='test -z "$ac_cxx_werror_flag"
13923		|| test ! -s conftest.err'
13924		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13925		(eval $ac_try) 2>&5
#	Line 7324 | Line 13944 | echo "${ECHO_T}$ac_header_compiler" >&6
13944		echo "${ECHO_T}$ac_header_compiler" >&6
13945
13946		# Is the header present?
13947	<	echo "$as_me:$LINENO: checking mkl.h presence" >&5
13948	<	echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13947	>	echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13948	>	echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13949		cat >conftest.$ac_ext <<_ACEOF
13950		/* confdefs.h.  */
13951		_ACEOF
13952		cat confdefs.h >>conftest.$ac_ext
13953		cat >>conftest.$ac_ext <<_ACEOF
13954		/* end confdefs.h.  */
13955	<	#include <mkl.h>
13955	>	#include <CGAL/Cartesian.h>
13956		_ACEOF
13957		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13958		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 7343 | Line 13963 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13963		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13964		(exit $ac_status); } >/dev/null; then
13965		if test -s conftest.err; then
13966	<	ac_cpp_err=$ac_c_preproc_warn_flag
13967	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13966	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
13967	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13968		else
13969		ac_cpp_err=
13970		fi
#	Line 7364 | Line 13984 | echo "${ECHO_T}$ac_header_preproc" >&6
13984		echo "${ECHO_T}$ac_header_preproc" >&6
13985
13986		# So?  What about this header?
13987	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13987	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13988		yes:no: )
13989	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13990	<	echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13991	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13992	<	echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13989	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13990	>	echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13991	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13992	>	echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13993		ac_header_preproc=yes
13994		;;
13995		no:yes:* )
13996	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13997	<	echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13998	<	{ echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13999	<	echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
14000	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
14001	<	echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
14002	<	{ echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
14003	<	echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14004	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
14005	<	echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
14006	<	{ echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
14007	<	echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13996	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13997	>	echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13998	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13999	>	echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
14000	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
14001	>	echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
14002	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
14003	>	echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14004	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
14005	>	echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
14006	>	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
14007	>	echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
14008		(
14009		cat <<\_ASBOX
14010		## ------------------------------ ##
#	Line 7395 | Line 14015 | esac
14015		sed "s/^/$as_me: WARNING:     /" >&2
14016		;;
14017		esac
14018	<	echo "$as_me:$LINENO: checking for mkl.h" >&5
14019	<	echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
14020	<	if test "${ac_cv_header_mkl_h+set}" = set; then
14018	>	echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
14019	>	echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
14020	>	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
14021		echo $ECHO_N "(cached) $ECHO_C" >&6
14022		else
14023	<	ac_cv_header_mkl_h=$ac_header_preproc
14023	>	ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
14024		fi
14025	<	echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
14026	<	echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
14025	>	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
14026	>	echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
14027
14028		fi
14029	<	if test $ac_cv_header_mkl_h = yes; then
14029	>	if test $ac_cv_header_CGAL_Cartesian_h = yes; then
14030	>	cgal=yes
14031	>	else
14032	>	cgal=no
14033	>	fi
14034
14035	<	echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
14036	<	echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
14037	<	if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
14038	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14039	<	else
14040	<	ac_check_lib_save_LIBS=$LIBS
14041	<	LIBS="-lmkl  $LIBS"
14035	>
14036	>	CXXFLAGS="$save_CXXFLAGS"
14037	>
14038	>	if test "x$cgal" = xyes; then
14039	>	echo "$as_me:$LINENO: checking for CGAL version" >&5
14040	>	echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
14041	>	LOCATION=${CGAL_INCLDIR}
14042	>	LOCATION=${LOCATION:-/usr/include}
14043	>	if test -f $LOCATION/CGAL/version.h; then
14044	>	CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
14045	>	else
14046	>	CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
14047	>	fi
14048	>	if echo $CGAL_VERSION | grep -q "^[3456789]"; then
14049	>	echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
14050	>	echo "${ECHO_T}($CGAL_VERSION) yes" >&6
14051	>	else
14052	>	echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
14053	>	echo "${ECHO_T}($CGAL_VERSION) no" >&6
14054	>	cgal=no
14055	>	fi
14056	>	fi
14057	>
14058	>	if test "x$cgal" = xyes; then
14059	>	CGAL_LIBS="-lCGAL"
14060	>	echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
14061	>	echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
14062	>	if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
14063	>	CGAL_USES_LEDA=yes
14064	>	echo "$as_me:$LINENO: result: yes" >&5
14065	>	echo "${ECHO_T}yes" >&6
14066	>	CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
14067	>	else
14068	>	echo "$as_me:$LINENO: result: no" >&5
14069	>	echo "${ECHO_T}no" >&6
14070	>	CGAL_USES_LEDA=no
14071	>	fi
14072	>
14073	>	echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
14074	>	echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
14075	>	if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
14076	>	CGAL_USES_GMP=yes
14077	>	echo "$as_me:$LINENO: result: yes" >&5
14078	>	echo "${ECHO_T}yes" >&6
14079	>	CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
14080	>	else
14081	>	echo "$as_me:$LINENO: result: no" >&5
14082	>	echo "${ECHO_T}no" >&6
14083	>	CGAL_USES_GMP=no
14084	>	fi
14085	>
14086	>	CGAL_LIBS="$CGAL_LIBS -lm"
14087	>
14088	>	CGAL_CXXFLAGS="-ftemplate-depth-50"
14089	>
14090	>	echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
14091	>	echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
14092	>	echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
14093	>	echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
14094	>	echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
14095	>	echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
14096	>	echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
14097	>	echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
14098	>	echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
14099	>	echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
14100	>	echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
14101	>	echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
14102	>	echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
14103	>	echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
14104	>	fi
14105	>
14106	>	if test "x$cgal" = xyes; then
14107	>	save_LIBS="$LIBS"
14108	>	LIBS="$LIBS -L$CGAL_LIBDIR"
14109	>	if test "x$CGAL_USES_LEDA" = xyes; then
14110	>	LIBS="-lL $LIBS -L$LEDA_LIBDIR"
14111	>	fi
14112	>	# if test "x$CGAL_USES_GMP" = xyes; then
14113	>	#   LIBS="-lgmp $LIBS $GMP_LIBDIR"
14114	>	# fi
14115	>	echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
14116	>	echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
14117	>	save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
14118	>	CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
14119	>	save_LIBS_CHECK_CXX_LIB="$LIBS"
14120	>	LIBS="-lCGAL  $LIBS"
14121		cat >conftest.$ac_ext <<_ACEOF
14122		/* confdefs.h.  */
14123		_ACEOF
14124		cat confdefs.h >>conftest.$ac_ext
14125		cat >>conftest.$ac_ext <<_ACEOF
14126		/* end confdefs.h.  */
14127	<
14128	<	/* Override any gcc2 internal prototype to avoid an error.  */
14129	<	#ifdef __cplusplus
14130	<	extern "C"
14127	>	#include <CGAL/Cartesian.h>
14128	>	#ifdef FC_DUMMY_MAIN
14129	>	#ifndef FC_DUMMY_MAIN_EQ_F77
14130	>	#  ifdef __cplusplus
14131	>	extern "C"
14132	>	#  endif
14133	>	int FC_DUMMY_MAIN() { return 1; }
14134		#endif
14135	<	/* We use char because int might match the return type of a gcc2
7430	<	builtin and then its argument prototype would still apply.  */
7431	<	char vslNewStream ();
14135	>	#endif
14136		int
14137		main ()
14138		{
14139	<	vslNewStream ();
14139	>	::CGAL::Cartesian<int>::Point_2 P
14140		;
14141		return 0;
14142		}
#	Line 7446 | Line 14150 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14150		cat conftest.err >&5
14151		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14152		(exit $ac_status); } &&
14153	<	{ ac_try='test -z "$ac_c_werror_flag"
14153	>	{ ac_try='test -z "$ac_cxx_werror_flag"
14154		|| test ! -s conftest.err'
14155		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14156		(eval $ac_try) 2>&5
#	Line 7459 | Line 14163 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14163		ac_status=$?
14164		echo "$as_me:$LINENO: \$? = $ac_status" >&5
14165		(exit $ac_status); }; }; then
14166	<	ac_cv_lib_mkl_vslNewStream=yes
14166	>	echo "$as_me:$LINENO: result: yes" >&5
14167	>	echo "${ECHO_T}yes" >&6
14168	>	cgal=yes
14169		else
14170		echo "$as_me: failed program was:" >&5
14171		sed 's/^/| /' conftest.$ac_ext >&5
14172
14173	<	ac_cv_lib_mkl_vslNewStream=no
14173	>	echo "$as_me:$LINENO: result: no" >&5
14174	>	echo "${ECHO_T}no" >&6
14175	>	cgal=no
14176		fi
14177		rm -f conftest.err conftest.$ac_objext \
14178		conftest$ac_exeext conftest.$ac_ext
14179	<	LIBS=$ac_check_lib_save_LIBS
14180	<	fi
14181	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
14182	<	echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
7475	<	if test $ac_cv_lib_mkl_vslNewStream = yes; then
7476	<	MKL_LIBDIR="${mkldir}/lib/32",
7477	<	MKL_LIB="-lmkl -lvml -lguide",
7478	<	HAVE_MKL="yes"
7479	<	fi
14179	>	CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
14180	>	LIBS="$save_LIBS_CHECK_CXX_LIB"
14181	>	LIBS="$save_LIBS"
14182	>	fi
14183
14184	<
7482	<	else
7483	<	MKL_INC="-I${mkldir}/include"
7484	<	fi
7485	<
7486	<
7487	<	CPPFLAGS=$ac_save_CPPFLAGS
7488	<	LDFLAGS=$ac_save_LDFLAGS
14184	>	fi
14185		ac_ext=c
14186		ac_cpp='$CPP $CPPFLAGS'
14187		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 7493 | Line 14189 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
14189		ac_compiler_gnu=$ac_cv_c_compiler_gnu
14190
14191
14192	<	if test x_$HAVE_MKL != x_yes; then
7497	<	{ { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7498	<	echo "$as_me: error: Can't build with MKL" >&2;}
7499	<	{ (exit 1); exit 1; }; }
7500	<	fi
14192	>	fi
14193
14194	+	if test "x$cgal" = xyes; then
14195	+	USE_CGAL=yes
14196
14197	+	cat >>confdefs.h <<\_ACEOF
14198	+	#define HAVE_CGAL 1
14199	+	_ACEOF
14200
14201
14202	+	cat >>confdefs.h <<_ACEOF
14203	+	#define CGAL_VERSION $CGAL_VERSION
14204	+	_ACEOF
14205
14206	+	if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14207	+	{ echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14208	+	echo "$as_me: WARNING: *****************************************************" >&2;}
14209	+	{ echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14210	+	echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14211	+	{ echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14212	+	echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14213	+	{ echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14214	+	echo "$as_me: WARNING: *****************************************************" >&2;}
14215	+	fi
14216		else
14217	+	if test "x$cgal_makefile" != xno; then
14218	+	echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14219	+	echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14220	+	fi
14221	+	CGAL_INCLDIR=
14222	+	CGAL_LIBDIR=
14223	+	CGAL_RLIBDIR=
14224	+	CGAL_DEFINES=
14225	+	CGAL_CXXFLAGS=
14226	+	CGAL_LIBS=
14227	+	fi
14228
7508	–	echo "$as_me:$LINENO: result: no" >&5
7509	–	echo "${ECHO_T}no" >&6
14229
14230	<	fi;
14230	>	CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14231
14232	+	CGAL_LIB_DIR=${CGAL_LIBDIR}
14233
14234	+	CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14235
14236
14237
7517	–	OBJEXT=".$OBJEXT"
14238
7519	–	OOPSE=oopse
14239
14240	<	if test "x${prefix}" = "xNONE"
14241	<	then
14242	<	OOPSE_HOME=${ac_default_prefix}/oopse
14240	>
14241	>
14242	>	# Check whether --enable-doxygen or --disable-doxygen was given.
14243	>	if test "${enable_doxygen+set}" = set; then
14244	>	enableval="$enable_doxygen"
14245	>
14246	>	fi;
14247	>	# Check whether --enable-dot or --disable-dot was given.
14248	>	if test "${enable_dot+set}" = set; then
14249	>	enableval="$enable_dot"
14250	>
14251	>	fi;
14252	>	# Check whether --enable-html-docs or --disable-html-docs was given.
14253	>	if test "${enable_html_docs+set}" = set; then
14254	>	enableval="$enable_html_docs"
14255	>
14256		else
14257	<	OOPSE_HOME=${prefix}/oopse
7526	<	fi
7527	<	# Check whether --enable-oopse-home or --disable-oopse-home was given.
7528	<	if test "${enable_oopse_home+set}" = set; then
7529	<	enableval="$enable_oopse_home"
7530	<	OOPSE_HOME="${enableval}"
14257	>	enable_html_docs=yes
14258		fi;
14259	+	# Check whether --enable-latex-docs or --disable-latex-docs was given.
14260	+	if test "${enable_latex_docs+set}" = set; then
14261	+	enableval="$enable_latex_docs"
14262
14263	<	case "x$INSTALL" in
14264	<	x/*) ;;
14265	<	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
14263	>	else
14264	>	enable_latex_docs=no
14265	>	fi;
14266	>	if test "x$enable_doxygen" = xno; then
14267	>	enable_doc=no
14268	>	else
14269	>	# Extract the first word of "doxygen", so it can be a program name with args.
14270	>	set dummy doxygen; ac_word=$2
14271	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
14272	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
14273	>	if test "${ac_cv_path_DOXYGEN+set}" = set; then
14274	>	echo $ECHO_N "(cached) $ECHO_C" >&6
14275	>	else
14276	>	case $DOXYGEN in
14277	>	[\\/]* | ?:[\\/]*)
14278	>	ac_cv_path_DOXYGEN="$DOXYGEN" # Let the user override the test with a path.
14279	>	;;
14280	>	*)
14281	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14282	>	for as_dir in $PATH
14283	>	do
14284	>	IFS=$as_save_IFS
14285	>	test -z "$as_dir" && as_dir=.
14286	>	for ac_exec_ext in '' $ac_executable_extensions; do
14287	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14288	>	ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
14289	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
14290	>	break 2
14291	>	fi
14292	>	done
14293	>	done
14294	>
14295	>	;;
14296		esac
14297	+	fi
14298	+	DOXYGEN=$ac_cv_path_DOXYGEN
14299
14300	<	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14300	>	if test -n "$DOXYGEN"; then
14301	>	echo "$as_me:$LINENO: result: $DOXYGEN" >&5
14302	>	echo "${ECHO_T}$DOXYGEN" >&6
14303	>	else
14304	>	echo "$as_me:$LINENO: result: no" >&5
14305	>	echo "${ECHO_T}no" >&6
14306	>	fi
14307
14308	<	SUBDIRS="libBASS libmdtools src forceFields samples utils utils/sysbuilder third-party "
14309	<
14310	<	CFLAGS=${CFLAGS-""}
14311	<	CXXFLAGS=${CXXFLAGS-""}
14312	<	CPPFLAGS=${CPPFLAGS-""}
14313	<	FFLAGS=${FFLAGS-""}
14314	<	F90FLAGS=${F90FLAGS-""}
14315	<	LDFLAGS=${LDFLAGS-""}
14316	<	DEBUG=${DEBUG-"-g"}
14317	<
14318	<	case $debug in
14319	<	1)
14320	<	FFLAGS="$DEBUG $FFLAGS"
14321	<	F90FLAGS="$DEBUG $F90FLAGS"
14322	<	;;
14308	>	if test "x$DOXYGEN" = x; then
14309	>	if test "x$enable_doxygen" = xyes; then
14310	>	{ { echo "$as_me:$LINENO: error: could not find doxygen" >&5
14311	>	echo "$as_me: error: could not find doxygen" >&2;}
14312	>	{ (exit 1); exit 1; }; }
14313	>	fi
14314	>	enable_doc=no
14315	>	else
14316	>	enable_doc=yes
14317	>	# Extract the first word of "dot", so it can be a program name with args.
14318	>	set dummy dot; ac_word=$2
14319	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
14320	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
14321	>	if test "${ac_cv_path_DOT+set}" = set; then
14322	>	echo $ECHO_N "(cached) $ECHO_C" >&6
14323	>	else
14324	>	case $DOT in
14325	>	[\\/]* | ?:[\\/]*)
14326	>	ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
14327	>	;;
14328		*)
14329	<	;;
14329	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14330	>	for as_dir in $PATH
14331	>	do
14332	>	IFS=$as_save_IFS
14333	>	test -z "$as_dir" && as_dir=.
14334	>	for ac_exec_ext in '' $ac_executable_extensions; do
14335	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14336	>	ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
14337	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
14338	>	break 2
14339	>	fi
14340	>	done
14341	>	done
14342	>
14343	>	;;
14344		esac
14345	+	fi
14346	+	DOT=$ac_cv_path_DOT
14347
14348	+	if test -n "$DOT"; then
14349	+	echo "$as_me:$LINENO: result: $DOT" >&5
14350	+	echo "${ECHO_T}$DOT" >&6
14351	+	else
14352	+	echo "$as_me:$LINENO: result: no" >&5
14353	+	echo "${ECHO_T}no" >&6
14354	+	fi
14355
14356	+	fi
14357	+	fi
14358
14359	+	if test "x$enable_doc" = xyes; then
14360	+	DOC=1
14361	+	else
14362	+	DOC=0
14363	+	fi
14364
14365
14366	+	if test x$DOT = x; then
14367	+	if test "x$enable_dot" = xyes; then
14368	+	{ { echo "$as_me:$LINENO: error: could not find dot" >&5
14369	+	echo "$as_me: error: could not find dot" >&2;}
14370	+	{ (exit 1); exit 1; }; }
14371	+	fi
14372	+	enable_dot=no
14373	+	else
14374	+	enable_dot=yes
14375	+	fi
14376
14377
14378
#	Line 7572 | Line 14385 | esac
14385
14386
14387
7575	–	ac_config_headers="$ac_config_headers libBASS/config.h libmdtools/config.h"
14388
7577	–	ac_config_files="$ac_config_files Makefile libBASS/Makefile libmdtools/Makefile src/Makefile utils/Makefile utils/sysbuilder/Makefile forceFields/Makefile samples/Makefile third-party/Makefile samples/alkane/Makefile samples/argon/Makefile samples/lipid/Makefile samples/minimizer/Makefile samples/metals/Makefile samples/water/Makefile samples/water/dimer/Makefile samples/water/spce/Makefile samples/water/ssd/Makefile samples/water/ssde/Makefile samples/water/tip4p/Makefile samples/water/tip3p_ice/Makefile samples/zcons/Makefile"
14389
14390
14391	+
14392	+
14393	+
14394	+
14395	+	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396	+
14397	+
14398		cat >confcache <<\_ACEOF
14399		# This file is a shell script that caches the results of configure
14400		# tests run on this system so they can be shared between configure
#	Line 7939 | Line 14757 | cat >&5 <<_CSEOF
14757		} >&5
14758		cat >&5 <<_CSEOF
14759
14760	<	This file was extended by OOPSE $as_me 1.0, which was
14760	>	This file was extended by OOPSE $as_me 3.0, which was
14761		generated by GNU Autoconf 2.59.  Invocation command line was
14762
14763		CONFIG_FILES    = $CONFIG_FILES
#	Line 8002 | Line 14820 | ac_cs_version="\\
14820
14821		cat >>$CONFIG_STATUS <<_ACEOF
14822		ac_cs_version="\\
14823	<	OOPSE config.status 1.0
14823	>	OOPSE config.status 3.0
14824		configured by $0, generated by GNU Autoconf 2.59,
14825		with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826
#	Line 8105 | Line 14923 | do
14923		do
14924		case "$ac_config_target" in
14925		# Handling of arguments.
14926	<	"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
14927	<	"libBASS/Makefile" ) CONFIG_FILES="$CONFIG_FILES libBASS/Makefile" ;;
14928	<	"libmdtools/Makefile" ) CONFIG_FILES="$CONFIG_FILES libmdtools/Makefile" ;;
14929	<	"src/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
14930	<	"utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES utils/Makefile" ;;
14931	<	"utils/sysbuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES utils/sysbuilder/Makefile" ;;
8114	<	"forceFields/Makefile" ) CONFIG_FILES="$CONFIG_FILES forceFields/Makefile" ;;
8115	<	"samples/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/Makefile" ;;
8116	<	"third-party/Makefile" ) CONFIG_FILES="$CONFIG_FILES third-party/Makefile" ;;
8117	<	"samples/alkane/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/alkane/Makefile" ;;
8118	<	"samples/argon/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/argon/Makefile" ;;
8119	<	"samples/lipid/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/lipid/Makefile" ;;
8120	<	"samples/minimizer/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/minimizer/Makefile" ;;
8121	<	"samples/metals/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/metals/Makefile" ;;
8122	<	"samples/water/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/Makefile" ;;
8123	<	"samples/water/dimer/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/dimer/Makefile" ;;
8124	<	"samples/water/spce/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/spce/Makefile" ;;
8125	<	"samples/water/ssd/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/ssd/Makefile" ;;
8126	<	"samples/water/ssde/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/ssde/Makefile" ;;
8127	<	"samples/water/tip4p/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/tip4p/Makefile" ;;
8128	<	"samples/water/tip3p_ice/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/water/tip3p_ice/Makefile" ;;
8129	<	"samples/zcons/Makefile" ) CONFIG_FILES="$CONFIG_FILES samples/zcons/Makefile" ;;
8130	<	"utils/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS utils/getopt.h:utils/gnugetopt.h" ;;
8131	<	"libBASS/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS libBASS/config.h" ;;
8132	<	"libmdtools/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS libmdtools/config.h" ;;
14926	>	"make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14927	>	"src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14928	>	"src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14929	>	"scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14930	>	"src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14931	>	"src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14932		*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
14933		echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
14934		{ (exit 1); exit 1; }; };;
#	Line 8215 | Line 15014 | s,@LIBS@,$LIBS,;t t
15014		s,@ECHO_N@,$ECHO_N,;t t
15015		s,@ECHO_T@,$ECHO_T,;t t
15016		s,@LIBS@,$LIBS,;t t
8218	–	s,@PROGNAME@,$PROGNAME,;t t
8219	–	s,@debug@,$debug,;t t
15017		s,@build@,$build,;t t
15018		s,@build_cpu@,$build_cpu,;t t
15019		s,@build_vendor@,$build_vendor,;t t
#	Line 8225 | Line 15022 | s,@host_os@,$host_os,;t t
15022		s,@host_cpu@,$host_cpu,;t t
15023		s,@host_vendor@,$host_vendor,;t t
15024		s,@host_os@,$host_os,;t t
15025	<	s,@CC@,$CC,;t t
15026	<	s,@CFLAGS@,$CFLAGS,;t t
15025	>	s,@PROGNAME@,$PROGNAME,;t t
15026	>	s,@debug@,$debug,;t t
15027	>	s,@CXX@,$CXX,;t t
15028	>	s,@CXXFLAGS@,$CXXFLAGS,;t t
15029		s,@LDFLAGS@,$LDFLAGS,;t t
15030		s,@CPPFLAGS@,$CPPFLAGS,;t t
15031	<	s,@ac_ct_CC@,$ac_ct_CC,;t t
15031	>	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032		s,@EXEEXT@,$EXEEXT,;t t
15033		s,@OBJEXT@,$OBJEXT,;t t
15034	<	s,@CXX@,$CXX,;t t
15035	<	s,@CXXFLAGS@,$CXXFLAGS,;t t
15036	<	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15037	<	s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15038	<	s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15039	<	s,@F90@,$F90,;t t
8241	<	s,@F90FLAGS@,$F90FLAGS,;t t
8242	<	s,@ac_ct_F90@,$ac_ct_F90,;t t
8243	<	s,@PREPFLAG@,$PREPFLAG,;t t
8244	<	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8245	<	s,@F90LIBS@,$F90LIBS,;t t
8246	<	s,@F90_FUNC@,$F90_FUNC,;t t
8247	<	s,@F90_FUNC_@,$F90_FUNC_,;t t
8248	<	s,@MOD@,$MOD,;t t
8249	<	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8250	<	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8251	<	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15034	>	s,@CC@,$CC,;t t
15035	>	s,@CFLAGS@,$CFLAGS,;t t
15036	>	s,@ac_ct_CC@,$ac_ct_CC,;t t
15037	>	s,@FC@,$FC,;t t
15038	>	s,@FCFLAGS@,$FCFLAGS,;t t
15039	>	s,@ac_ct_FC@,$ac_ct_FC,;t t
15040		s,@CPP@,$CPP,;t t
15041		s,@EGREP@,$EGREP,;t t
8254	–	s,@LIBOBJS@,$LIBOBJS,;t t
8255	–	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8256	–	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8257	–	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042		s,@LN_S@,$LN_S,;t t
15043		s,@SET_MAKE@,$SET_MAKE,;t t
15044		s,@RANLIB@,$RANLIB,;t t
15045		s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15046	<	s,@YACC@,$YACC,;t t
15047	<	s,@LEX@,$LEX,;t t
15048	<	s,@LEXLIB@,$LEXLIB,;t t
15049	<	s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046	>	s,@PERLINTERP@,$PERLINTERP,;t t
15047	>	s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048	>	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049	>	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050	>	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051		s,@AR@,$AR,;t t
15052	+	s,@PS@,$PS,;t t
15053	+	s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054	+	s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055	+	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056	+	s,@FCLIBS@,$FCLIBS,;t t
15057	+	s,@FC_FUNC@,$FC_FUNC,;t t
15058	+	s,@FC_FUNC_@,$FC_FUNC_,;t t
15059	+	s,@MOD@,$MOD,;t t
15060	+	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061	+	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062	+	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063	+	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064	+	s,@LIBOBJS@,$LIBOBJS,;t t
15065	+	s,@POW_LIB@,$POW_LIB,;t t
15066	+	s,@CXXCPP@,$CXXCPP,;t t
15067	+	s,@__func__@,$__func__,;t t
15068		s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069		s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070		s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15071		s,@MPI_LIB@,$MPI_LIB,;t t
15072		s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15073		s,@USE_MPI@,$USE_MPI,;t t
15074	<	s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
15075	<	s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
15076	<	s,@SPRNG_LIB@,$SPRNG_LIB,;t t
15077	<	s,@USE_SPRNG@,$USE_SPRNG,;t t
15078	<	s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
15079	<	s,@MKL_LIB@,$MKL_LIB,;t t
15080	<	s,@MKL_INC@,$MKL_INC,;t t
15081	<	s,@HAVE_MKL@,$HAVE_MKL,;t t
15074	>	s,@USE_CGAL@,$USE_CGAL,;t t
15075	>	s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
15076	>	s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
15077	>	s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
15078	>	s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
15079	>	s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080	>	s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15081	>	s,@DOXYGEN@,$DOXYGEN,;t t
15082	>	s,@DOT@,$DOT,;t t
15083	>	s,@DOC@,$DOC,;t t
15084	>	s,@enable_dot@,$enable_dot,;t t
15085	>	s,@enable_html_docs@,$enable_html_docs,;t t
15086	>	s,@enable_latex_docs@,$enable_latex_docs,;t t
15087		s,@BATEXT@,$BATEXT,;t t
15088		s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
15089		s,@OOPSE@,$OOPSE,;t t
15090		s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091		s,@SUBDIRS@,$SUBDIRS,;t t
8286	–	s,@FFLAGS@,$FFLAGS,;t t
15092		s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093		CEOF
15094
#	Line 8521 | Line 15326 | s,@INSTALL@,$ac_INSTALL,;t t
15326		rm -f $tmp/out
15327		fi
15328
15329	+	# Run the commands associated with the file.
15330	+	case $ac_file in
15331	+	make/Makefile ) chmod 0755 scripts/* ;;
15332	+	src/utils/Makefile ) chmod 0755 scripts/* ;;
15333	+	src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15334	+	scripts/filepp ) chmod 0755 scripts/* ;;
15335	+	esac
15336		done
15337		_ACEOF
15338		cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

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