ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 768 by chuckv, Tue Nov 29 22:54:21 2005 UTC vs.
Revision 1036 by gezelter, Mon Sep 4 13:37:15 2006 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3	>	# Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4		#
5		# Report bugs to <gezelter@nd.edu>.
6		#
#	Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269		# Identity of this package.
270		PACKAGE_NAME='OOPSE'
271		PACKAGE_TARNAME='oopse'
272	<	PACKAGE_VERSION='2.0'
273	<	PACKAGE_STRING='OOPSE 2.0'
272	>	PACKAGE_VERSION='3.0'
273	>	PACKAGE_STRING='OOPSE 3.0'
274		PACKAGE_BUGREPORT='gezelter@nd.edu'
275
276		ac_unique_file="src/applications/oopse/oopse.cpp"
#	Line 312 | Line 312 | ac_includes_default="\
312		# include <unistd.h>
313		#endif"
314
315	<	ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315	>	ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_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}
#	Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801		# Omit some internal or obsolete options to make the list less imposing.
802		# This message is too long to be a string in the A/UX 3.1 sh.
803		cat <<_ACEOF
804	<	\`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804	>	\`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805
806		Usage: $0 [OPTION]... [VAR=VALUE]...
807
#	Line 862 | Line 862 | if test -n "$ac_init_help"; then
862
863		if test -n "$ac_init_help"; then
864		case $ac_init_help in
865	<	short | recursive ) echo "Configuration of OOPSE 2.0:";;
865	>	short | recursive ) echo "Configuration of OOPSE 3.0:";;
866		esac
867		cat <<\_ACEOF
868
869		Optional Features:
870		--disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871		--enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872	+	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873		--enable-debug          Compile OOPSE in debug mode
874	+	--enable-single         compile OOPSE in single precision
875	+	--enable-float          synonym for --enable-single
876		--enable-doxygen        enable documentation generation with doxygen (auto)
877		--enable-dot            use 'dot' to generate graphs in doxygen (auto)
878		--enable-html-docs      enable HTML generation with doxygen (yes)
879		--enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877	–	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880
881		Optional Packages:
882		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882	–	--with-zlib=DIR root directory path of zlib installation defaults to
883	–	/usr/local or /usr if not found in /usr/local
884	–	--without-zlib to disable zlib usage completely
884		--with-perl-shebang     override what perl thinks is the way for the kernel
885		to start it (seldom needed)
886	+	--with-zlib=DIR         root directory path of zlib installation (defaults
887	+	to /usr/local or /usr if not found in /usr/local)
888	+	--with-fftw=DIR         root directory path of fftw installation (defaults
889	+	to /usr/local or /usr if not found in /usr/local)
890		--with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891		--with-cgal-makefile=FILE  CGAL makefile that should be used
892
893		Some influential environment variables:
894	<	CC          C compiler command
895	<	CFLAGS      C compiler flags
894	>	CXX         C++ compiler command
895	>	CXXFLAGS    C++ compiler flags
896		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
897		nonstandard directory <lib dir>
898		CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
899		headers in a nonstandard directory <include dir>
900	<	CXX         C++ compiler command
901	<	CXXFLAGS    C++ compiler flags
902	<	F90         Fortran 90 compiler command
903	<	F90FLAGS    Fortran 90 compiler flags
900	>	CC          C compiler command
901	>	CFLAGS      C compiler flags
902	>	FC          Fortran compiler command
903	>	FCFLAGS     Fortran compiler flags
904		CPP         C preprocessor
905		CXXCPP      C++ preprocessor
906
#	Line 993 | Line 996 | esac
996		else
997		echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
998		fi
999	<	cd "$ac_popdir"
999	>	cd $ac_popdir
1000		done
1001		fi
1002
1003		test -n "$ac_init_help" && exit 0
1004		if $ac_init_version; then
1005		cat <<\_ACEOF
1006	<	OOPSE configure 2.0
1006	>	OOPSE configure 3.0
1007		generated by GNU Autoconf 2.59
1008
1009		Copyright (C) 2003 Free Software Foundation, Inc.
#	Line 1014 | Line 1017 | running configure, to aid debugging if configure makes
1017		This file contains any messages produced by compilers while
1018		running configure, to aid debugging if configure makes a mistake.
1019
1020	<	It was created by OOPSE $as_me 2.0, which was
1020	>	It was created by OOPSE $as_me 3.0, which was
1021		generated by GNU Autoconf 2.59.  Invocation command line was
1022
1023		$ $0 $@
#	Line 1374 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377		ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1378		ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1379		ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1377	–
1378	–
1379	–	# This file is part of Autoconf.                       -*- Autoconf -*-
1380	–	# Programming languages support.
1381	–	# Copyright 2000, 2001
1382	–	# Free Software Foundation, Inc.
1383	–	#
1384	–	# This program is free software; you can redistribute it and/or modify
1385	–	# it under the terms of the GNU General Public License as published by
1386	–	# the Free Software Foundation; either version 2, or (at your option)
1387	–	# any later version.
1388	–	#
1389	–	# This program is distributed in the hope that it will be useful,
1390	–	# but WITHOUT ANY WARRANTY; without even the implied warranty of
1391	–	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392	–	# GNU General Public License for more details.
1393	–	#
1394	–	# You should have received a copy of the GNU General Public License
1395	–	# along with this program; if not, write to the Free Software
1396	–	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397	–	# 02111-1307, USA.
1398	–	#
1399	–	# As a special exception, the Free Software Foundation gives unlimited
1400	–	# permission to copy, distribute and modify the configure scripts that
1401	–	# are the output of Autoconf.  You need not follow the terms of the GNU
1402	–	# General Public License when using or distributing such scripts, even
1403	–	# though portions of the text of Autoconf appear in them.  The GNU
1404	–	# General Public License (GPL) does govern all other use of the material
1405	–	# that constitutes the Autoconf program.
1406	–	#
1407	–	# Certain portions of the Autoconf source text are designed to be copied
1408	–	# (in certain cases, depending on the input) into the output of
1409	–	# Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410	–	# source text consists of comments plus executable code that decides which
1411	–	# of the data portions to output in any given case.  We call these
1412	–	# comments and executable code the "non-data" portions.  Autoconf never
1413	–	# copies any of the non-data portions into its output.
1414	–	#
1415	–	# This special exception to the GPL applies to versions of Autoconf
1416	–	# released by the Free Software Foundation.  When you make and
1417	–	# distribute a modified version of Autoconf, you may extend this special
1418	–	# exception to the GPL to apply to your modified version as well, *unless*
1419	–	# your modified version has the potential to copy into its output some
1420	–	# of the text that was the non-data portion of the version that you started
1421	–	# with.  (In other words, unless your change moves or copies text from
1422	–	# the non-data portions to the data portions.)  If your modification has
1423	–	# such potential, you must delete any notice of this special exception
1424	–	# to the GPL from your modified version.
1425	–	#
1426	–	# Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427	–	# many others).
1380
1381
1382	<	# Table of Contents:
1431	<	#
1432	<	# 1. Language selection
1433	<	#    and routines to produce programs in a given language.
1434	<	#  a. Fortran 77 (to be moved from aclang.m4)
1435	<	#  b. Fortran 90
1436	<	#  c. Fortran 95
1437	<	#
1438	<	# 2. Producing programs in a given language.
1439	<	#  a. Fortran 77 (to be moved from aclang.m4)
1440	<	#  b. Fortran 90
1441	<	#  c. Fortran 95
1442	<	#
1443	<	# 3. Looking for a compiler
1444	<	#    And possibly the associated preprocessor.
1445	<	#  a. Fortran 77 (to be moved from aclang.m4)
1446	<	#  b. Fortran 90
1447	<	#  c. Fortran 95
1448	<	#
1449	<	# 4. Compilers' characteristics.
1450	<	#  a. Fortran 77 (to be moved from aclang.m4)
1451	<	#  b. Fortran 90
1452	<	#  c. Fortran 95
1382	>	ac_config_headers="$ac_config_headers src/config.h"
1383
1454	–	# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455	–	# ---------------------------------------------------------------------------
1456	–	#
1457	–	# Processing the elements of a list is tedious in shell programming,
1458	–	# as lists tend to be implemented as space delimited strings.
1459	–	#
1460	–	# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461	–	# if ELEMENT is a member of LIST, otherwise it executes
1462	–	# ACTION-IF-NOT-FOUND.
1463	–	# _AC_LIST_MEMBER_IF
1384
1385
1386
1467	–	# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468	–	# -------------------------------------------------
1469	–	#
1470	–	# Specifying options to the compiler (whether it be the C, C++ or
1471	–	# Fortran 77 compiler) that are meant for the linker is compiler
1472	–	# dependent.  This macro lets you give options to the compiler that
1473	–	# are meant for the linker in a portable, compiler-independent way.
1474	–	#
1475	–	# This macro take two arguments, a list of linker options that the
1476	–	# compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477	–	# a shell variable (SHELL-VARIABLE).  The list of linker options are
1478	–	# appended to the shell variable in a compiler-dependent way.
1479	–	#
1480	–	# For example, if the selected language is C, then this:
1481	–	#
1482	–	#   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483	–	#
1484	–	# will expand into this if the selected C compiler is gcc:
1485	–	#
1486	–	#   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487	–	#
1488	–	# otherwise, it will expand into this:
1489	–	#
1490	–	#   foo_LDFLAGS"-R /usr/local/lib/foo"
1491	–	#
1492	–	# You are encouraged to add support for compilers that this macro
1493	–	# doesn't currently support.
1494	–	# FIXME: Get rid of this macro.
1495	–	# _AC_LINKER_OPTION
1387
1388
1389
1499	–	## ----------------------- ##
1500	–	## 1. Language selection.  ##
1501	–	## ----------------------- ##
1390
1503	–	# ----------------------------- #
1504	–	# 1b. The Fortran 90 language.  #
1505	–	# ----------------------------- #
1391
1507	–	# AC_LANG(Fortran 90)
1508	–	# -------------------
1392
1393
1394
1512	–	# _AC_LANG_ABBREV(Fortran 90)
1513	–	# ---------------------------
1395
1396
1397
1517	–	# ----------------------------- #
1518	–	# 1c. The Fortran 95 language.  #
1519	–	# ----------------------------- #
1398
1521	–	# AC_LANG(Fortran 95)
1522	–	# -------------------
1399
1400
1401
1526	–	# _AC_LANG_ABBREV(Fortran 95)
1527	–	# ---------------------------
1402
1403
1404
1531	–	## ---------------------- ##
1532	–	## 2.Producing programs.  ##
1533	–	## ---------------------- ##
1405
1535	–	# ------------------------ #
1536	–	# 2b. Fortran 90 sources.  #
1537	–	# ------------------------ #
1406
1539	–	# AC_LANG_SOURCE(Fortran 90)(BODY)
1540	–	# --------------------------------
1407
1408
1409
1544	–	# AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545	–	# -----------------------------------------------
1410
1411
1548	–	# AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549	–	# --------------------------------------------
1412
1413
1414
1553	–	# ------------------------ #
1554	–	# 2c. Fortran 95 sources.  #
1555	–	# ------------------------ #
1415
1557	–	# AC_LANG_SOURCE(Fortran 95)(BODY)
1558	–	# --------------------------------
1416
1417
1561	–	# AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562	–	# -----------------------------------------------
1418
1419
1565	–	# AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566	–	# --------------------------------------------
1420
1421
1422
1570	–	## -------------------------------------------- ##
1571	–	## 3. Looking for Compilers and Preprocessors.  ##
1572	–	## -------------------------------------------- ##
1423
1574	–	# ----------------------------- #
1575	–	# 3b. The Fortran 90 compiler.  #
1576	–	# ----------------------------- #
1424
1425
1579	–	# AC_LANG_PREPROC(Fortran 90)
1580	–	# ---------------------------
1581	–	# Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1426
1583	–
1584	–
1585	–	# AC_LANG_COMPILER(Fortran 90)
1586	–	# ----------------------------
1587	–	# Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588	–	# AC_REQUIRE'able.
1589	–
1590	–
1591	–
1592	–	# AC_PROG_F90([COMPILERS...])
1593	–	# ---------------------------
1594	–	# COMPILERS is a space separated list of Fortran 90 compilers to search
1595	–	# for.
1427		#
1597	–	# Compilers are ordered by
1598	–	#  1. F90, F95
1599	–	#  2. Good/tested native compilers, bad/untested native compilers
1428		#
1601	–	# pgf90 is the Portland Group F90 compilers.
1602	–	# xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603	–	# lf95 is the Lahey-Fujitsu compiler.
1604	–	# epcf90 is the "Edinburgh Portable Compiler" F90.
1605	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606	–	# AC_PROG_F90
1607	–
1608	–
1609	–	# ----------------------------- #
1610	–	# 3c. The Fortran 95 compiler.  #
1611	–	# ----------------------------- #
1612	–
1613	–
1614	–	# AC_LANG_PREPROC(Fortran 95)
1615	–	# ---------------------------
1616	–	# Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1617	–
1618	–
1619	–
1620	–	# AC_LANG_COMPILER(Fortran 95)
1621	–	# ----------------------------
1622	–	# Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623	–	# AC_REQUIRE'able.
1624	–
1625	–
1626	–
1627	–	# AC_PROG_F95([COMPILERS...])
1628	–	# ---------------------------
1629	–	# COMPILERS is a space separated list of Fortran 95 compilers to search
1630	–	# for.
1429		#
1632	–	# Compilers are ordered by
1633	–	#  1. Good/tested native compilers, bad/untested native compilers
1634	–	#
1635	–	# xlf95 is the IBM (AIX) F95 compiler.
1636	–	# lf95 is the Lahey-Fujitsu compiler.
1637	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638	–	# AC_PROG_F95
1430
1431
1641	–	## ------------------------------- ##
1642	–	## 4. Compilers' characteristics.  ##
1643	–	## ------------------------------- ##
1432
1433
1646	–	# ---------------------------------------- #
1647	–	# 4b. Fortan 90 compiler characteristics.  #
1648	–	# ---------------------------------------- #
1434
1435
1436	<	# _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1437	<	# -------------------------------------------------
1653	<	# Link a trivial Fortran program, compiling with a verbose output FLAG
1654	<	# (which default value, $ac_cv_prog_f90_v, is computed by
1655	<	# _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656	<	# output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657	<	# so that any link flags that are echoed by the compiler appear as
1658	<	# space-separated items.
1659	<	# _AC_PROG_F90_V_OUTPUT
1660	<
1661	<
1662	<	# _AC_PROG_F90_V
1663	<	# --------------
1436	>	# AC_F90_MODULE_NAMES
1437	>	# -------------------
1438		#
1439	<	# Determine the flag that causes the Fortran 90 compiler to print
1666	<	# information of library and object files (normally -v)
1667	<	# Needed for AC_F90_LIBRARY_FLAGS
1668	<	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669	<	# _AC_PROG_F90_V
1670	<
1671	<
1672	<	# AC_F90_LIBRARY_LDFLAGS
1673	<	# ----------------------
1439	>	# Figure out how the Fortran 90 compiler constructs module file names
1440		#
1441	<	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676	<	# intrinsic and run-time libraries that are required to successfully
1677	<	# link a Fortran 90 program or shared library.  The output variable
1678	<	# F90LIBS is set to these flags.
1679	<	#
1680	<	# This macro is intended to be used in those situations when it is
1681	<	# necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682	<	# program or shared library.
1683	<	#
1684	<	# For example, if object files from a C++ and Fortran 90 compiler must
1685	<	# be linked together, then the C++ compiler/linker must be used for
1686	<	# linking (since special C++-ish things need to happen at link time
1687	<	# like calling global constructors, instantiating templates, enabling
1688	<	# exception support, etc.).
1689	<	#
1690	<	# However, the Fortran 90 intrinsic and run-time libraries must be
1691	<	# linked in as well, but the C++ compiler/linker doesn't know how to
1692	<	# add these Fortran 90 libraries.  Hence, the macro
1693	<	# "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694	<	# libraries.
1695	<	#
1696	<	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697	<	# AC_F90_LIBRARY_LDFLAGS
1441	>	# AC_F90_MODULE_NAMES
1442
1443
1700	–	# _AC_F90_NAME_MANGLING
1701	–	# ---------------------
1702	–	# Test for the name mangling scheme used by the Fortran 90 compiler.
1703	–	#
1704	–	# Sets ac_cv_f90_mangling. The value contains three fields, separated
1705	–	# by commas:
1706	–	#
1707	–	# lower case / upper case:
1708	–	#    case translation of the Fortan 90 symbols
1709	–	# underscore / no underscore:
1710	–	#    whether the compiler appends "_" to symbol names
1711	–	# extra underscore / no extra underscore:
1712	–	#    whether the compiler appends an extra "_" to symbol names already
1713	–	#    containing at least one underscore
1714	–	#
1715	–	# _AC_F90_NAME_MANGLING
1444
1717	–	# The replacement is empty.
1445
1446
1447
1721	–	# AC_F90_WRAPPERS
1722	–	# ---------------
1723	–	# Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1724	–	# properly mangle the names of C identifiers, and C identifiers with
1725	–	# underscores, respectively, so that they match the name mangling
1726	–	# scheme used by the Fortran 90 compiler.
1727	–	# AC_F90_WRAPPERS
1448
1449
1730	–	# AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1731	–	# ------------------------------------
1732	–	# For a Fortran subroutine of given NAME, define a shell variable
1733	–	# $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1734	–	# argument is not supplied, it defaults to NAME.
1735	–	# AC_F90_FUNC
1450
1451
1738	–	# ---------------------------------------- #
1739	–	# 4c. Fortan 95 compiler characteristics.  #
1740	–	# ---------------------------------------- #
1452
1453
1743	–	# _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1744	–	# -------------------------------------------------
1745	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1746	–	# (which default value, $ac_cv_prog_f95_v, is computed by
1747	–	# _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1748	–	# output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1749	–	# so that any link flags that are echoed by the compiler appear as
1750	–	# space-separated items.
1751	–	# _AC_PROG_F95_V_OUTPUT
1454
1455
1754	–	# _AC_PROG_F95_V
1755	–	# --------------
1756	–	#
1757	–	# Determine the flag that causes the Fortran 95 compiler to print
1758	–	# information of library and object files (normally -v)
1759	–	# Needed for AC_F95_LIBRARY_FLAGS
1760	–	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761	–	# _AC_PROG_F95_V
1456
1457
1764	–	# AC_F95_LIBRARY_LDFLAGS
1765	–	# ----------------------
1766	–	#
1767	–	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768	–	# intrinsic and run-time libraries that are required to successfully
1769	–	# link a Fortran 95 program or shared library.  The output variable
1770	–	# F95LIBS is set to these flags.
1771	–	#
1772	–	# This macro is intended to be used in those situations when it is
1773	–	# necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774	–	# program or shared library.
1775	–	#
1776	–	# For example, if object files from a C++ and Fortran 95 compiler must
1777	–	# be linked together, then the C++ compiler/linker must be used for
1778	–	# linking (since special C++-ish things need to happen at link time
1779	–	# like calling global constructors, instantiating templates, enabling
1780	–	# exception support, etc.).
1781	–	#
1782	–	# However, the Fortran 95 intrinsic and run-time libraries must be
1783	–	# linked in as well, but the C++ compiler/linker doesn't know how to
1784	–	# add these Fortran 95 libraries.  Hence, the macro
1785	–	# "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786	–	# libraries.
1787	–	#
1788	–	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789	–	# AC_F95_LIBRARY_LDFLAGS
1458
1459
1792	–	# _AC_F95_NAME_MANGLING
1793	–	# ---------------------
1794	–	# Test for the name mangling scheme used by the Fortran 95 compiler.
1795	–	#
1796	–	# Sets ac_cv_f95_mangling. The value contains three fields, separated
1797	–	# by commas:
1798	–	#
1799	–	# lower case / upper case:
1800	–	#    case translation of the Fortan 95 symbols
1801	–	# underscore / no underscore:
1802	–	#    whether the compiler appends "_" to symbol names
1803	–	# extra underscore / no extra underscore:
1804	–	#    whether the compiler appends an extra "_" to symbol names already
1805	–	#    containing at least one underscore
1806	–	#
1807	–	# _AC_F95_NAME_MANGLING
1460
1809	–	# The replacement is empty.
1461
1462
1463
1813	–	# AC_F95_WRAPPERS
1814	–	# ---------------
1815	–	# Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816	–	# properly mangle the names of C identifiers, and C identifiers with
1817	–	# underscores, respectively, so that they match the name mangling
1818	–	# scheme used by the Fortran 95 compiler.
1819	–	# AC_F95_WRAPPERS
1464
1465
1822	–	# AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823	–	# ------------------------------------
1824	–	# For a Fortran subroutine of given NAME, define a shell variable
1825	–	# $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826	–	# argument is not supplied, it defaults to NAME.
1827	–	# AC_F95_FUNC
1466
1829	–	# AC_F90_MODULE_NAMES
1830	–	# -------------------
1831	–	#
1832	–	# Figure out how the Fortran 90 compiler constructs module file names
1833	–	#
1834	–	# AC_F90_MODULE_NAMES
1467
1468
1469
#	Line 1885 | Line 1517 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1517
1518
1519
1888	–	#
1889	–	#
1890	–	#
1520
1521
1522
#	Line 1896 | Line 1525 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1525
1526
1527
1899	–	# set program name
1900	–	PROGNAME="oopse"
1528
1529
1903	–	# there are two ways to do debugging.  One with the --enable-debug flag
1904	–	# and one using the DEBUG environment variable
1905	–
1906	–	debug=0
1907	–	# Check whether --enable-debug or --disable-debug was given.
1908	–	if test "${enable_debug+set}" = set; then
1909	–	enableval="$enable_debug"
1910	–	debug=1
1911	–	fi;
1912	–	if test "${DEBUG}"; then
1913	–
1914	–	cat >>confdefs.h <<\_ACEOF
1915	–	#define debug 1
1916	–	_ACEOF
1917	–
1918	–	msg="$msg, debug mode"
1919	–	fi
1920	–
1921	–
1530		# who am i
1531		# Make sure we can run config.sub.
1532		$ac_config_sub sun4 >/dev/null 2>&1 ||
#	Line 1977 | Line 1585 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1585
1586
1587
1588	<	ac_ext=c
1589	<	ac_cpp='$CPP $CPPFLAGS'
1590	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1591	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1592	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
1588	>	# set program name
1589	>	PROGNAME="oopse"
1590	>
1591	>
1592	>
1593	>
1594	>	OBJEXT=".$OBJEXT"
1595	>
1596	>	OOPSE=oopse
1597	>
1598	>	if test "x${prefix}" = "xNONE"
1599	>	then
1600	>	OOPSE_HOME=${ac_default_prefix}/oopse
1601	>	else
1602	>	OOPSE_HOME=${prefix}/oopse
1603	>	fi
1604	>	# Check whether --enable-oopse-home or --disable-oopse-home was given.
1605	>	if test "${enable_oopse_home+set}" = set; then
1606	>	enableval="$enable_oopse_home"
1607	>	OOPSE_HOME="${enableval}"
1608	>	fi;
1609	>
1610	>	# there are two ways to do debugging.  One with the --enable-debug flag
1611	>	# and one using the DEBUG environment variable
1612	>
1613	>	debug=0
1614	>	# Check whether --enable-debug or --disable-debug was given.
1615	>	if test "${enable_debug+set}" = set; then
1616	>	enableval="$enable_debug"
1617	>	debug=1
1618	>	fi;
1619	>	if test "${DEBUG}"; then
1620	>
1621	>	cat >>confdefs.h <<\_ACEOF
1622	>	#define debug 1
1623	>	_ACEOF
1624	>
1625	>	msg="$msg, debug mode"
1626	>	fi
1627	>
1628	>
1629	>	# Check whether --enable-single or --disable-single was given.
1630	>	if test "${enable_single+set}" = set; then
1631	>	enableval="$enable_single"
1632	>	ok=$enableval
1633	>	else
1634	>	ok=no
1635	>	fi;
1636	>	# Check whether --enable-float or --disable-float was given.
1637	>	if test "${enable_float+set}" = set; then
1638	>	enableval="$enable_float"
1639	>	ok=$enableval
1640	>	fi;
1641	>	if test "$ok" = "yes"; then
1642	>
1643	>	cat >>confdefs.h <<\_ACEOF
1644	>	#define SINGLE_PRECISION 1
1645	>	_ACEOF
1646	>
1647	>	USE_SINGLE_PRECISION=yes
1648	>
1649	>	fi
1650	>
1651	>	# Checks for programs.
1652	>	ac_ext=cc
1653	>	ac_cpp='$CXXCPP $CPPFLAGS'
1654	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1655	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1656	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1657		if test -n "$ac_tool_prefix"; then
1658	<	for ac_prog in icc xlc gcc cc
1658	>	for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1659		do
1660		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1661		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1662		echo "$as_me:$LINENO: checking for $ac_word" >&5
1663		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1664	<	if test "${ac_cv_prog_CC+set}" = set; then
1664	>	if test "${ac_cv_prog_CXX+set}" = set; then
1665		echo $ECHO_N "(cached) $ECHO_C" >&6
1666		else
1667	<	if test -n "$CC"; then
1668	<	ac_cv_prog_CC="$CC" # Let the user override the test.
1667	>	if test -n "$CXX"; then
1668	>	ac_cv_prog_CXX="$CXX" # Let the user override the test.
1669		else
1670		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1671		for as_dir in $PATH
#	Line 2002 | Line 1674 | do
1674		test -z "$as_dir" && as_dir=.
1675		for ac_exec_ext in '' $ac_executable_extensions; do
1676		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1677	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1677	>	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1678		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1679		break 2
1680		fi
#	Line 2011 | Line 1683 | fi
1683
1684		fi
1685		fi
1686	<	CC=$ac_cv_prog_CC
1687	<	if test -n "$CC"; then
1688	<	echo "$as_me:$LINENO: result: $CC" >&5
1689	<	echo "${ECHO_T}$CC" >&6
1686	>	CXX=$ac_cv_prog_CXX
1687	>	if test -n "$CXX"; then
1688	>	echo "$as_me:$LINENO: result: $CXX" >&5
1689	>	echo "${ECHO_T}$CXX" >&6
1690		else
1691		echo "$as_me:$LINENO: result: no" >&5
1692		echo "${ECHO_T}no" >&6
1693		fi
1694
1695	<	test -n "$CC" && break
1695	>	test -n "$CXX" && break
1696		done
1697		fi
1698	<	if test -z "$CC"; then
1699	<	ac_ct_CC=$CC
1700	<	for ac_prog in icc xlc gcc cc
1698	>	if test -z "$CXX"; then
1699	>	ac_ct_CXX=$CXX
1700	>	for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1701		do
1702		# Extract the first word of "$ac_prog", so it can be a program name with args.
1703		set dummy $ac_prog; ac_word=$2
1704		echo "$as_me:$LINENO: checking for $ac_word" >&5
1705		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1706	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1706	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1707		echo $ECHO_N "(cached) $ECHO_C" >&6
1708		else
1709	<	if test -n "$ac_ct_CC"; then
1710	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1709	>	if test -n "$ac_ct_CXX"; then
1710	>	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1711		else
1712		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1713		for as_dir in $PATH
#	Line 2044 | Line 1716 | do
1716		test -z "$as_dir" && as_dir=.
1717		for ac_exec_ext in '' $ac_executable_extensions; do
1718		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1719	<	ac_cv_prog_ac_ct_CC="$ac_prog"
1719	>	ac_cv_prog_ac_ct_CXX="$ac_prog"
1720		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1721		break 2
1722		fi
#	Line 2053 | Line 1725 | fi
1725
1726		fi
1727		fi
1728	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
1729	<	if test -n "$ac_ct_CC"; then
1730	<	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1731	<	echo "${ECHO_T}$ac_ct_CC" >&6
1728	>	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1729	>	if test -n "$ac_ct_CXX"; then
1730	>	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1731	>	echo "${ECHO_T}$ac_ct_CXX" >&6
1732		else
1733		echo "$as_me:$LINENO: result: no" >&5
1734		echo "${ECHO_T}no" >&6
1735		fi
1736
1737	<	test -n "$ac_ct_CC" && break
1737	>	test -n "$ac_ct_CXX" && break
1738		done
1739	+	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1740
1741	<	CC=$ac_ct_CC
1741	>	CXX=$ac_ct_CXX
1742		fi
1743
1744
2072	–	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073	–	See \`config.log' for more details." >&5
2074	–	echo "$as_me: error: no acceptable C compiler found in \$PATH
2075	–	See \`config.log' for more details." >&2;}
2076	–	{ (exit 1); exit 1; }; }
2077	–
1745		# Provide some information about the compiler.
1746		echo "$as_me:$LINENO:" \
1747	<	"checking for C compiler version" >&5
1747	>	"checking for C++ compiler version" >&5
1748		ac_compiler=`set X $ac_compile; echo $2`
1749		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1750		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2115 | Line 1782 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1782		# Try to create an executable without -o first, disregard a.out.
1783		# It will help us diagnose broken compilers, and finding out an intuition
1784		# of exeext.
1785	<	echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1786	<	echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1785	>	echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1786	>	echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1787		ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1788		if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1789		(eval $ac_link_default) 2>&5
#	Line 2159 | Line 1826 | sed 's/^/| /' conftest.$ac_ext >&5
1826		echo "$as_me: failed program was:" >&5
1827		sed 's/^/| /' conftest.$ac_ext >&5
1828
1829	<	{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
1829	>	{ { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1830		See \`config.log' for more details." >&5
1831	<	echo "$as_me: error: C compiler cannot create executables
1831	>	echo "$as_me: error: C++ compiler cannot create executables
1832		See \`config.log' for more details." >&2;}
1833		{ (exit 77); exit 77; }; }
1834		fi
#	Line 2172 | Line 1839 | echo "${ECHO_T}$ac_file" >&6
1839
1840		# Check the compiler produces executables we can run.  If not, either
1841		# the compiler is broken, or we cross compile.
1842	<	echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1843	<	echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1842	>	echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1843	>	echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1844		# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1845		# If not cross compiling, check that we can run a simple program.
1846		if test "$cross_compiling" != yes; then
#	Line 2188 | Line 1855 | if test "$cross_compiling" != yes; then
1855		if test "$cross_compiling" = maybe; then
1856		cross_compiling=yes
1857		else
1858	<	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1858	>	{ { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1859		If you meant to cross compile, use \`--host'.
1860		See \`config.log' for more details." >&5
1861	<	echo "$as_me: error: cannot run C compiled programs.
1861	>	echo "$as_me: error: cannot run C++ compiled programs.
1862		If you meant to cross compile, use \`--host'.
1863		See \`config.log' for more details." >&2;}
1864		{ (exit 1); exit 1; }; }
#	Line 2296 | Line 1963 | ac_objext=$OBJEXT
1963		echo "${ECHO_T}$ac_cv_objext" >&6
1964		OBJEXT=$ac_cv_objext
1965		ac_objext=$OBJEXT
1966	<	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1967	<	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1968	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then
1966	>	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1967	>	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1968	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1969		echo $ECHO_N "(cached) $ECHO_C" >&6
1970		else
1971		cat >conftest.$ac_ext <<_ACEOF
#	Line 2328 | Line 1995 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1995		cat conftest.err >&5
1996		echo "$as_me:$LINENO: \$? = $ac_status" >&5
1997		(exit $ac_status); } &&
1998	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
1998	>	{ ac_try='test -z "$ac_cxx_werror_flag"
1999	>	|| test ! -s conftest.err'
2000		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2001		(eval $ac_try) 2>&5
2002		ac_status=$?
#	Line 2348 | Line 2016 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2016		ac_compiler_gnu=no
2017		fi
2018		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2019	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2019	>	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2020
2021		fi
2022	<	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2023	<	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2024	<	GCC=`test $ac_compiler_gnu = yes && echo yes`
2025	<	ac_test_CFLAGS=${CFLAGS+set}
2026	<	ac_save_CFLAGS=$CFLAGS
2027	<	CFLAGS="-g"
2028	<	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2029	<	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2030	<	if test "${ac_cv_prog_cc_g+set}" = set; then
2022	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2023	>	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2024	>	GXX=`test $ac_compiler_gnu = yes && echo yes`
2025	>	ac_test_CXXFLAGS=${CXXFLAGS+set}
2026	>	ac_save_CXXFLAGS=$CXXFLAGS
2027	>	CXXFLAGS="-g"
2028	>	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2029	>	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2030	>	if test "${ac_cv_prog_cxx_g+set}" = set; then
2031		echo $ECHO_N "(cached) $ECHO_C" >&6
2032		else
2033		cat >conftest.$ac_ext <<_ACEOF
#	Line 2386 | Line 2054 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2054		cat conftest.err >&5
2055		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056		(exit $ac_status); } &&
2057	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2057	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2058	>	|| test ! -s conftest.err'
2059		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060		(eval $ac_try) 2>&5
2061		ac_status=$?
#	Line 2398 | Line 2067 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2067		ac_status=$?
2068		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2069		(exit $ac_status); }; }; then
2070	<	ac_cv_prog_cc_g=yes
2070	>	ac_cv_prog_cxx_g=yes
2071		else
2072		echo "$as_me: failed program was:" >&5
2073		sed 's/^/| /' conftest.$ac_ext >&5
2074
2075	<	ac_cv_prog_cc_g=no
2075	>	ac_cv_prog_cxx_g=no
2076		fi
2077		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078		fi
2079	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2080	<	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2081	<	if test "$ac_test_CFLAGS" = set; then
2082	<	CFLAGS=$ac_save_CFLAGS
2083	<	elif test $ac_cv_prog_cc_g = yes; then
2084	<	if test "$GCC" = yes; then
2085	<	CFLAGS="-g -O2"
2079	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2080	>	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2081	>	if test "$ac_test_CXXFLAGS" = set; then
2082	>	CXXFLAGS=$ac_save_CXXFLAGS
2083	>	elif test $ac_cv_prog_cxx_g = yes; then
2084	>	if test "$GXX" = yes; then
2085	>	CXXFLAGS="-g -O2"
2086		else
2087	<	CFLAGS="-g"
2087	>	CXXFLAGS="-g"
2088		fi
2089		else
2090	<	if test "$GCC" = yes; then
2091	<	CFLAGS="-O2"
2090	>	if test "$GXX" = yes; then
2091	>	CXXFLAGS="-O2"
2092		else
2093	<	CFLAGS=
2093	>	CXXFLAGS=
2094		fi
2095		fi
2096	<	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2428	<	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2429	<	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2430	<	echo $ECHO_N "(cached) $ECHO_C" >&6
2431	<	else
2432	<	ac_cv_prog_cc_stdc=no
2433	<	ac_save_CC=$CC
2434	<	cat >conftest.$ac_ext <<_ACEOF
2435	<	/* confdefs.h.  */
2436	<	_ACEOF
2437	<	cat confdefs.h >>conftest.$ac_ext
2438	<	cat >>conftest.$ac_ext <<_ACEOF
2439	<	/* end confdefs.h.  */
2440	<	#include <stdarg.h>
2441	<	#include <stdio.h>
2442	<	#include <sys/types.h>
2443	<	#include <sys/stat.h>
2444	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2445	<	struct buf { int x; };
2446	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2447	<	static char *e (p, i)
2448	<	char **p;
2449	<	int i;
2450	<	{
2451	<	return p[i];
2452	<	}
2453	<	static char *f (char * (*g) (char **, int), char **p, ...)
2454	<	{
2455	<	char *s;
2456	<	va_list v;
2457	<	va_start (v,p);
2458	<	s = g (p, va_arg (v,int));
2459	<	va_end (v);
2460	<	return s;
2461	<	}
2462	<
2463	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2464	<	function prototypes and stuff, but not '\xHH' hex character constants.
2465	<	These don't provoke an error unfortunately, instead are silently treated
2466	<	as 'x'.  The following induces an error, until -std1 is added to get
2467	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2468	<	array size at least.  It's necessary to write '\x00'==0 to get something
2469	<	that's true only with -std1.  */
2470	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2471	<
2472	<	int test (int i, double x);
2473	<	struct s1 {int (*f) (int a);};
2474	<	struct s2 {int (*f) (double a);};
2475	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2476	<	int argc;
2477	<	char **argv;
2478	<	int
2479	<	main ()
2480	<	{
2481	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2482	<	;
2483	<	return 0;
2484	<	}
2485	<	_ACEOF
2486	<	# Don't try gcc -ansi; that turns off useful extensions and
2487	<	# breaks some systems' header files.
2488	<	# AIX                   -qlanglvl=ansi
2489	<	# Ultrix and OSF/1      -std1
2490	<	# HP-UX 10.20 and later -Ae
2491	<	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2492	<	# SVR4                  -Xc -D__EXTENSIONS__
2493	<	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2494	<	do
2495	<	CC="$ac_save_CC $ac_arg"
2496	<	rm -f conftest.$ac_objext
2497	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2498	<	(eval $ac_compile) 2>conftest.er1
2499	<	ac_status=$?
2500	<	grep -v '^ *+' conftest.er1 >conftest.err
2501	<	rm -f conftest.er1
2502	<	cat conftest.err >&5
2503	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2504	<	(exit $ac_status); } &&
2505	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2506	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2507	<	(eval $ac_try) 2>&5
2508	<	ac_status=$?
2509	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2510	<	(exit $ac_status); }; } &&
2511	<	{ ac_try='test -s conftest.$ac_objext'
2512	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2513	<	(eval $ac_try) 2>&5
2514	<	ac_status=$?
2515	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2516	<	(exit $ac_status); }; }; then
2517	<	ac_cv_prog_cc_stdc=$ac_arg
2518	<	break
2519	<	else
2520	<	echo "$as_me: failed program was:" >&5
2521	<	sed 's/^/| /' conftest.$ac_ext >&5
2522	<
2523	<	fi
2524	<	rm -f conftest.err conftest.$ac_objext
2525	<	done
2526	<	rm -f conftest.$ac_ext conftest.$ac_objext
2527	<	CC=$ac_save_CC
2528	<
2529	<	fi
2530	<
2531	<	case "x$ac_cv_prog_cc_stdc" in
2532	<	x|xno)
2533	<	echo "$as_me:$LINENO: result: none needed" >&5
2534	<	echo "${ECHO_T}none needed" >&6 ;;
2535	<	*)
2536	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2537	<	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2538	<	CC="$CC $ac_cv_prog_cc_stdc" ;;
2539	<	esac
2540	<
2541	<	# Some people use a C++ compiler to compile C.  Since we use `exit',
2542	<	# in C++ we need to declare it.  In case someone uses the same compiler
2543	<	# for both compiling C and C++ we need to have the C++ compiler decide
2544	<	# the declaration of exit, since it's the most demanding environment.
2545	<	cat >conftest.$ac_ext <<_ACEOF
2546	<	#ifndef __cplusplus
2547	<	choke me
2548	<	#endif
2549	<	_ACEOF
2550	<	rm -f conftest.$ac_objext
2551	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2552	<	(eval $ac_compile) 2>conftest.er1
2553	<	ac_status=$?
2554	<	grep -v '^ *+' conftest.er1 >conftest.err
2555	<	rm -f conftest.er1
2556	<	cat conftest.err >&5
2557	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2558	<	(exit $ac_status); } &&
2559	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2560	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2561	<	(eval $ac_try) 2>&5
2562	<	ac_status=$?
2563	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2564	<	(exit $ac_status); }; } &&
2565	<	{ ac_try='test -s conftest.$ac_objext'
2566	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2567	<	(eval $ac_try) 2>&5
2568	<	ac_status=$?
2569	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2570	<	(exit $ac_status); }; }; then
2571	<	for ac_declaration in \
2096	>	for ac_declaration in \
2097		'' \
2098		'extern "C" void std::exit (int) throw (); using std::exit;' \
2099		'extern "C" void std::exit (int); using std::exit;' \
#	Line 2601 | Line 2126 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2126		cat conftest.err >&5
2127		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128		(exit $ac_status); } &&
2129	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2129	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2130	>	|| test ! -s conftest.err'
2131		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2132		(eval $ac_try) 2>&5
2133		ac_status=$?
#	Line 2645 | Line 2171 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2171		cat conftest.err >&5
2172		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2173		(exit $ac_status); } &&
2174	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2174	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2175	>	|| test ! -s conftest.err'
2176		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2177		(eval $ac_try) 2>&5
2178		ac_status=$?
#	Line 2672 | Line 2199 | fi
2199		echo '#endif'             >>confdefs.h
2200		fi
2201
2675	–	else
2676	–	echo "$as_me: failed program was:" >&5
2677	–	sed 's/^/| /' conftest.$ac_ext >&5
2678	–
2679	–	fi
2680	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2202		ac_ext=c
2203		ac_cpp='$CPP $CPPFLAGS'
2204		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2205		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2206		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2207
2208	<
2209	<	ac_ext=cc
2210	<	ac_cpp='$CXXCPP $CPPFLAGS'
2211	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2212	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2692	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2208	>	ac_ext=c
2209	>	ac_cpp='$CPP $CPPFLAGS'
2210	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2211	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2212	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2213		if test -n "$ac_tool_prefix"; then
2214	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2214	>	for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2215		do
2216		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2217		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2218		echo "$as_me:$LINENO: checking for $ac_word" >&5
2219		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2220	<	if test "${ac_cv_prog_CXX+set}" = set; then
2220	>	if test "${ac_cv_prog_CC+set}" = set; then
2221		echo $ECHO_N "(cached) $ECHO_C" >&6
2222		else
2223	<	if test -n "$CXX"; then
2224	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
2223	>	if test -n "$CC"; then
2224	>	ac_cv_prog_CC="$CC" # Let the user override the test.
2225		else
2226		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2227		for as_dir in $PATH
#	Line 2710 | Line 2230 | do
2230		test -z "$as_dir" && as_dir=.
2231		for ac_exec_ext in '' $ac_executable_extensions; do
2232		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2233	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2233	>	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2234		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2235		break 2
2236		fi
#	Line 2719 | Line 2239 | fi
2239
2240		fi
2241		fi
2242	<	CXX=$ac_cv_prog_CXX
2243	<	if test -n "$CXX"; then
2244	<	echo "$as_me:$LINENO: result: $CXX" >&5
2245	<	echo "${ECHO_T}$CXX" >&6
2242	>	CC=$ac_cv_prog_CC
2243	>	if test -n "$CC"; then
2244	>	echo "$as_me:$LINENO: result: $CC" >&5
2245	>	echo "${ECHO_T}$CC" >&6
2246		else
2247		echo "$as_me:$LINENO: result: no" >&5
2248		echo "${ECHO_T}no" >&6
2249		fi
2250
2251	<	test -n "$CXX" && break
2251	>	test -n "$CC" && break
2252		done
2253		fi
2254	<	if test -z "$CXX"; then
2255	<	ac_ct_CXX=$CXX
2256	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2254	>	if test -z "$CC"; then
2255	>	ac_ct_CC=$CC
2256	>	for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2257		do
2258		# Extract the first word of "$ac_prog", so it can be a program name with args.
2259		set dummy $ac_prog; ac_word=$2
2260		echo "$as_me:$LINENO: checking for $ac_word" >&5
2261		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2262	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2262	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2263		echo $ECHO_N "(cached) $ECHO_C" >&6
2264		else
2265	<	if test -n "$ac_ct_CXX"; then
2266	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2265	>	if test -n "$ac_ct_CC"; then
2266	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2267		else
2268		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2269		for as_dir in $PATH
#	Line 2752 | Line 2272 | do
2272		test -z "$as_dir" && as_dir=.
2273		for ac_exec_ext in '' $ac_executable_extensions; do
2274		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2275	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
2275	>	ac_cv_prog_ac_ct_CC="$ac_prog"
2276		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2277		break 2
2278		fi
#	Line 2761 | Line 2281 | fi
2281
2282		fi
2283		fi
2284	<	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2285	<	if test -n "$ac_ct_CXX"; then
2286	<	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2287	<	echo "${ECHO_T}$ac_ct_CXX" >&6
2284	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
2285	>	if test -n "$ac_ct_CC"; then
2286	>	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2287	>	echo "${ECHO_T}$ac_ct_CC" >&6
2288		else
2289		echo "$as_me:$LINENO: result: no" >&5
2290		echo "${ECHO_T}no" >&6
2291		fi
2292
2293	<	test -n "$ac_ct_CXX" && break
2293	>	test -n "$ac_ct_CC" && break
2294		done
2775	–	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2295
2296	<	CXX=$ac_ct_CXX
2296	>	CC=$ac_ct_CC
2297		fi
2298
2299
2300	+	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2301	+	See \`config.log' for more details." >&5
2302	+	echo "$as_me: error: no acceptable C compiler found in \$PATH
2303	+	See \`config.log' for more details." >&2;}
2304	+	{ (exit 1); exit 1; }; }
2305	+
2306		# Provide some information about the compiler.
2307		echo "$as_me:$LINENO:" \
2308	<	"checking for C++ compiler version" >&5
2308	>	"checking for C compiler version" >&5
2309		ac_compiler=`set X $ac_compile; echo $2`
2310		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2311		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2798 | Line 2323 | ac_compiler=`set X $ac_compile; echo $2`
2323		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2324		(exit $ac_status); }
2325
2326	<	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2327	<	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2328	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2326	>	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2327	>	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2328	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then
2329		echo $ECHO_N "(cached) $ECHO_C" >&6
2330		else
2331		cat >conftest.$ac_ext <<_ACEOF
#	Line 2830 | Line 2355 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2355		cat conftest.err >&5
2356		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2357		(exit $ac_status); } &&
2358	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2358	>	{ ac_try='test -z "$ac_c_werror_flag"
2359	>	|| test ! -s conftest.err'
2360		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2361		(eval $ac_try) 2>&5
2362		ac_status=$?
#	Line 2850 | Line 2376 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2376		ac_compiler_gnu=no
2377		fi
2378		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2379	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2379	>	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2380
2381		fi
2382	<	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2383	<	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2384	<	GXX=`test $ac_compiler_gnu = yes && echo yes`
2385	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
2386	<	ac_save_CXXFLAGS=$CXXFLAGS
2387	<	CXXFLAGS="-g"
2388	<	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2389	<	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2390	<	if test "${ac_cv_prog_cxx_g+set}" = set; then
2382	>	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2383	>	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2384	>	GCC=`test $ac_compiler_gnu = yes && echo yes`
2385	>	ac_test_CFLAGS=${CFLAGS+set}
2386	>	ac_save_CFLAGS=$CFLAGS
2387	>	CFLAGS="-g"
2388	>	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2389	>	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2390	>	if test "${ac_cv_prog_cc_g+set}" = set; then
2391		echo $ECHO_N "(cached) $ECHO_C" >&6
2392		else
2393		cat >conftest.$ac_ext <<_ACEOF
#	Line 2888 | Line 2414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2414		cat conftest.err >&5
2415		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2416		(exit $ac_status); } &&
2417	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2417	>	{ ac_try='test -z "$ac_c_werror_flag"
2418	>	|| test ! -s conftest.err'
2419		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2420		(eval $ac_try) 2>&5
2421		ac_status=$?
#	Line 2900 | Line 2427 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2427		ac_status=$?
2428		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2429		(exit $ac_status); }; }; then
2430	<	ac_cv_prog_cxx_g=yes
2430	>	ac_cv_prog_cc_g=yes
2431		else
2432		echo "$as_me: failed program was:" >&5
2433		sed 's/^/| /' conftest.$ac_ext >&5
2434
2435	<	ac_cv_prog_cxx_g=no
2435	>	ac_cv_prog_cc_g=no
2436		fi
2437		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2438		fi
2439	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2440	<	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2441	<	if test "$ac_test_CXXFLAGS" = set; then
2442	<	CXXFLAGS=$ac_save_CXXFLAGS
2443	<	elif test $ac_cv_prog_cxx_g = yes; then
2444	<	if test "$GXX" = yes; then
2445	<	CXXFLAGS="-g -O2"
2439	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2440	>	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2441	>	if test "$ac_test_CFLAGS" = set; then
2442	>	CFLAGS=$ac_save_CFLAGS
2443	>	elif test $ac_cv_prog_cc_g = yes; then
2444	>	if test "$GCC" = yes; then
2445	>	CFLAGS="-g -O2"
2446		else
2447	<	CXXFLAGS="-g"
2447	>	CFLAGS="-g"
2448		fi
2449		else
2450	<	if test "$GXX" = yes; then
2451	<	CXXFLAGS="-O2"
2450	>	if test "$GCC" = yes; then
2451	>	CFLAGS="-O2"
2452		else
2453	<	CXXFLAGS=
2453	>	CFLAGS=
2454		fi
2455		fi
2456	<	for ac_declaration in \
2457	<	'' \
2458	<	'extern "C" void std::exit (int) throw (); using std::exit;' \
2459	<	'extern "C" void std::exit (int); using std::exit;' \
2460	<	'extern "C" void exit (int) throw ();' \
2461	<	'extern "C" void exit (int);' \
2462	<	'void exit (int);'
2463	<	do
2937	<	cat >conftest.$ac_ext <<_ACEOF
2456	>	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2457	>	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2458	>	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2459	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2460	>	else
2461	>	ac_cv_prog_cc_stdc=no
2462	>	ac_save_CC=$CC
2463	>	cat >conftest.$ac_ext <<_ACEOF
2464		/* confdefs.h.  */
2465		_ACEOF
2466		cat confdefs.h >>conftest.$ac_ext
2467		cat >>conftest.$ac_ext <<_ACEOF
2468		/* end confdefs.h.  */
2469	<	$ac_declaration
2470	<	#include <stdlib.h>
2471	<	int
2472	<	main ()
2469	>	#include <stdarg.h>
2470	>	#include <stdio.h>
2471	>	#include <sys/types.h>
2472	>	#include <sys/stat.h>
2473	>	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2474	>	struct buf { int x; };
2475	>	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2476	>	static char *e (p, i)
2477	>	char **p;
2478	>	int i;
2479		{
2480	<	exit (42);
2949	<	;
2950	<	return 0;
2480	>	return p[i];
2481		}
2482	<	_ACEOF
2483	<	rm -f conftest.$ac_objext
2484	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2485	<	(eval $ac_compile) 2>conftest.er1
2486	<	ac_status=$?
2487	<	grep -v '^ *+' conftest.er1 >conftest.err
2488	<	rm -f conftest.er1
2489	<	cat conftest.err >&5
2490	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2491	<	(exit $ac_status); } &&
2492	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2482	>	static char *f (char * (*g) (char **, int), char **p, ...)
2483	>	{
2484	>	char *s;
2485	>	va_list v;
2486	>	va_start (v,p);
2487	>	s = g (p, va_arg (v,int));
2488	>	va_end (v);
2489	>	return s;
2490	>	}
2491	>
2492	>	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2493	>	function prototypes and stuff, but not '\xHH' hex character constants.
2494	>	These don't provoke an error unfortunately, instead are silently treated
2495	>	as 'x'.  The following induces an error, until -std1 is added to get
2496	>	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2497	>	array size at least.  It's necessary to write '\x00'==0 to get something
2498	>	that's true only with -std1.  */
2499	>	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2500	>
2501	>	int test (int i, double x);
2502	>	struct s1 {int (*f) (int a);};
2503	>	struct s2 {int (*f) (double a);};
2504	>	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2505	>	int argc;
2506	>	char **argv;
2507	>	int
2508	>	main ()
2509	>	{
2510	>	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2511	>	;
2512	>	return 0;
2513	>	}
2514	>	_ACEOF
2515	>	# Don't try gcc -ansi; that turns off useful extensions and
2516	>	# breaks some systems' header files.
2517	>	# AIX                   -qlanglvl=ansi
2518	>	# Ultrix and OSF/1      -std1
2519	>	# HP-UX 10.20 and later -Ae
2520	>	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2521	>	# SVR4                  -Xc -D__EXTENSIONS__
2522	>	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2523	>	do
2524	>	CC="$ac_save_CC $ac_arg"
2525	>	rm -f conftest.$ac_objext
2526	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2527	>	(eval $ac_compile) 2>conftest.er1
2528	>	ac_status=$?
2529	>	grep -v '^ *+' conftest.er1 >conftest.err
2530	>	rm -f conftest.er1
2531	>	cat conftest.err >&5
2532	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2533	>	(exit $ac_status); } &&
2534	>	{ ac_try='test -z "$ac_c_werror_flag"
2535	>	|| test ! -s conftest.err'
2536		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2537		(eval $ac_try) 2>&5
2538		ac_status=$?
#	Line 2971 | Line 2544 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2544		ac_status=$?
2545		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2546		(exit $ac_status); }; }; then
2547	+	ac_cv_prog_cc_stdc=$ac_arg
2548	+	break
2549	+	else
2550	+	echo "$as_me: failed program was:" >&5
2551	+	sed 's/^/| /' conftest.$ac_ext >&5
2552	+
2553	+	fi
2554	+	rm -f conftest.err conftest.$ac_objext
2555	+	done
2556	+	rm -f conftest.$ac_ext conftest.$ac_objext
2557	+	CC=$ac_save_CC
2558	+
2559	+	fi
2560	+
2561	+	case "x$ac_cv_prog_cc_stdc" in
2562	+	x|xno)
2563	+	echo "$as_me:$LINENO: result: none needed" >&5
2564	+	echo "${ECHO_T}none needed" >&6 ;;
2565	+	*)
2566	+	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2567	+	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2568	+	CC="$CC $ac_cv_prog_cc_stdc" ;;
2569	+	esac
2570	+
2571	+	# Some people use a C++ compiler to compile C.  Since we use `exit',
2572	+	# in C++ we need to declare it.  In case someone uses the same compiler
2573	+	# for both compiling C and C++ we need to have the C++ compiler decide
2574	+	# the declaration of exit, since it's the most demanding environment.
2575	+	cat >conftest.$ac_ext <<_ACEOF
2576	+	#ifndef __cplusplus
2577	+	choke me
2578	+	#endif
2579	+	_ACEOF
2580	+	rm -f conftest.$ac_objext
2581	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2582	+	(eval $ac_compile) 2>conftest.er1
2583	+	ac_status=$?
2584	+	grep -v '^ *+' conftest.er1 >conftest.err
2585	+	rm -f conftest.er1
2586	+	cat conftest.err >&5
2587	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2588	+	(exit $ac_status); } &&
2589	+	{ ac_try='test -z "$ac_c_werror_flag"
2590	+	|| test ! -s conftest.err'
2591	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2592	+	(eval $ac_try) 2>&5
2593	+	ac_status=$?
2594	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2595	+	(exit $ac_status); }; } &&
2596	+	{ ac_try='test -s conftest.$ac_objext'
2597	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2598	+	(eval $ac_try) 2>&5
2599	+	ac_status=$?
2600	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2601	+	(exit $ac_status); }; }; then
2602	+	for ac_declaration in \
2603	+	'' \
2604	+	'extern "C" void std::exit (int) throw (); using std::exit;' \
2605	+	'extern "C" void std::exit (int); using std::exit;' \
2606	+	'extern "C" void exit (int) throw ();' \
2607	+	'extern "C" void exit (int);' \
2608	+	'void exit (int);'
2609	+	do
2610	+	cat >conftest.$ac_ext <<_ACEOF
2611	+	/* confdefs.h.  */
2612	+	_ACEOF
2613	+	cat confdefs.h >>conftest.$ac_ext
2614	+	cat >>conftest.$ac_ext <<_ACEOF
2615	+	/* end confdefs.h.  */
2616	+	$ac_declaration
2617	+	#include <stdlib.h>
2618	+	int
2619	+	main ()
2620	+	{
2621	+	exit (42);
2622	+	;
2623	+	return 0;
2624	+	}
2625	+	_ACEOF
2626	+	rm -f conftest.$ac_objext
2627	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2628	+	(eval $ac_compile) 2>conftest.er1
2629	+	ac_status=$?
2630	+	grep -v '^ *+' conftest.er1 >conftest.err
2631	+	rm -f conftest.er1
2632	+	cat conftest.err >&5
2633	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2634	+	(exit $ac_status); } &&
2635	+	{ ac_try='test -z "$ac_c_werror_flag"
2636	+	|| test ! -s conftest.err'
2637	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2638	+	(eval $ac_try) 2>&5
2639	+	ac_status=$?
2640	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2641	+	(exit $ac_status); }; } &&
2642	+	{ ac_try='test -s conftest.$ac_objext'
2643	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2644	+	(eval $ac_try) 2>&5
2645	+	ac_status=$?
2646	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2647	+	(exit $ac_status); }; }; then
2648		:
2649		else
2650		echo "$as_me: failed program was:" >&5
#	Line 3003 | Line 2677 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2677		cat conftest.err >&5
2678		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2679		(exit $ac_status); } &&
2680	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2680	>	{ ac_try='test -z "$ac_c_werror_flag"
2681	>	|| test ! -s conftest.err'
2682		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2683		(eval $ac_try) 2>&5
2684		ac_status=$?
#	Line 3030 | Line 2705 | fi
2705		echo '#endif'             >>confdefs.h
2706		fi
2707
2708	+	else
2709	+	echo "$as_me: failed program was:" >&5
2710	+	sed 's/^/| /' conftest.$ac_ext >&5
2711	+
2712	+	fi
2713	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2714		ac_ext=c
2715		ac_cpp='$CPP $CPPFLAGS'
2716		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2717		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2718		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2719
2720	<
2721	<	OOPSE_TEMPLATE_FLAGS=""
2722	<	if test $ac_cv_cxx_compiler_gnu = no; then
2723	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3043	<	echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3044	<	echo 'void f(){}' > conftest.cc
3045	<	if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3046	<	echo "$as_me:$LINENO: result: yes" >&5
3047	<	echo "${ECHO_T}yes" >&6
3048	<	OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3049	<	else
3050	<	echo "$as_me:$LINENO: result: no" >&5
3051	<	echo "${ECHO_T}no" >&6
3052	<	fi
3053	<	rm -f conftest*
3054	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3055	<	echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3056	<	echo 'void f(){}' > conftest.cc
3057	<	if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3058	<	echo "$as_me:$LINENO: result: yes" >&5
3059	<	echo "${ECHO_T}yes" >&6
3060	<	OOPSE_TEMPLATE_FLAGS="-instances=static"
3061	<	else
3062	<	echo "$as_me:$LINENO: result: no" >&5
3063	<	echo "${ECHO_T}no" >&6
3064	<	fi
3065	<	rm -f conftest*
3066	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3067	<	echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3068	<	echo 'void f(){}' > conftest.cc
3069	<	if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3070	<	echo "$as_me:$LINENO: result: yes" >&5
3071	<	echo "${ECHO_T}yes" >&6
3072	<	OOPSE_TEMPLATE_FLAGS="-pto"
3073	<	else
3074	<	echo "$as_me:$LINENO: result: no" >&5
3075	<	echo "${ECHO_T}no" >&6
3076	<	fi
3077	<	rm -f conftest*
3078	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3079	<	echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3080	<	echo 'void f(){}' > conftest.cc
3081	<	if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3082	<	echo "$as_me:$LINENO: result: yes" >&5
3083	<	echo "${ECHO_T}yes" >&6
3084	<
3085	<
3086	<	EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3087	<	else
3088	<	echo "$as_me:$LINENO: result: no" >&5
3089	<	echo "${ECHO_T}no" >&6
3090	<	fi
3091	<	fi
3092	<
3093	<
3094	<
3095	<
3096	<	ac_ext=f90
3097	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3098	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3099	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2720	>	ac_ext=${FC_SRCEXT-f}
2721	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2722	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2723	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2724		if test -n "$ac_tool_prefix"; then
2725	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2725	>	for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2726		do
2727		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2728		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2729		echo "$as_me:$LINENO: checking for $ac_word" >&5
2730		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2731	<	if test "${ac_cv_prog_F90+set}" = set; then
2731	>	if test "${ac_cv_prog_FC+set}" = set; then
2732		echo $ECHO_N "(cached) $ECHO_C" >&6
2733		else
2734	<	if test -n "$F90"; then
2735	<	ac_cv_prog_F90="$F90" # Let the user override the test.
2734	>	if test -n "$FC"; then
2735	>	ac_cv_prog_FC="$FC" # Let the user override the test.
2736		else
2737		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2738		for as_dir in $PATH
#	Line 3117 | Line 2741 | do
2741		test -z "$as_dir" && as_dir=.
2742		for ac_exec_ext in '' $ac_executable_extensions; do
2743		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2744	<	ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2744	>	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2745		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2746		break 2
2747		fi
#	Line 3126 | Line 2750 | fi
2750
2751		fi
2752		fi
2753	<	F90=$ac_cv_prog_F90
2754	<	if test -n "$F90"; then
2755	<	echo "$as_me:$LINENO: result: $F90" >&5
2756	<	echo "${ECHO_T}$F90" >&6
2753	>	FC=$ac_cv_prog_FC
2754	>	if test -n "$FC"; then
2755	>	echo "$as_me:$LINENO: result: $FC" >&5
2756	>	echo "${ECHO_T}$FC" >&6
2757		else
2758		echo "$as_me:$LINENO: result: no" >&5
2759		echo "${ECHO_T}no" >&6
2760		fi
2761
2762	<	test -n "$F90" && break
2762	>	test -n "$FC" && break
2763		done
2764		fi
2765	<	if test -z "$F90"; then
2766	<	ac_ct_F90=$F90
2767	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2765	>	if test -z "$FC"; then
2766	>	ac_ct_FC=$FC
2767	>	for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2768		do
2769		# Extract the first word of "$ac_prog", so it can be a program name with args.
2770		set dummy $ac_prog; ac_word=$2
2771		echo "$as_me:$LINENO: checking for $ac_word" >&5
2772		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2773	<	if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2773	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2774		echo $ECHO_N "(cached) $ECHO_C" >&6
2775		else
2776	<	if test -n "$ac_ct_F90"; then
2777	<	ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2776	>	if test -n "$ac_ct_FC"; then
2777	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2778		else
2779		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2780		for as_dir in $PATH
#	Line 3159 | Line 2783 | do
2783		test -z "$as_dir" && as_dir=.
2784		for ac_exec_ext in '' $ac_executable_extensions; do
2785		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2786	<	ac_cv_prog_ac_ct_F90="$ac_prog"
2786	>	ac_cv_prog_ac_ct_FC="$ac_prog"
2787		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2788		break 2
2789		fi
#	Line 3168 | Line 2792 | fi
2792
2793		fi
2794		fi
2795	<	ac_ct_F90=$ac_cv_prog_ac_ct_F90
2796	<	if test -n "$ac_ct_F90"; then
2797	<	echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2798	<	echo "${ECHO_T}$ac_ct_F90" >&6
2795	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
2796	>	if test -n "$ac_ct_FC"; then
2797	>	echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2798	>	echo "${ECHO_T}$ac_ct_FC" >&6
2799		else
2800		echo "$as_me:$LINENO: result: no" >&5
2801		echo "${ECHO_T}no" >&6
2802		fi
2803
2804	<	test -n "$ac_ct_F90" && break
2804	>	test -n "$ac_ct_FC" && break
2805		done
2806
2807	<	F90=$ac_ct_F90
2807	>	FC=$ac_ct_FC
2808		fi
2809
2810
2811	<	# If we don't use `.F90' as extension, the preprocessor is not run on the
2812	<	# input file.
2811	>	# Provide some information about the compiler.
2812	>	echo "$as_me:2812:" \
2813	>	"checking for Fortran compiler version" >&5
2814	>	ac_compiler=`set X $ac_compile; echo $2`
2815	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2816	>	(eval $ac_compiler --version </dev/null >&5) 2>&5
2817	>	ac_status=$?
2818	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2819	>	(exit $ac_status); }
2820	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2821	>	(eval $ac_compiler -v </dev/null >&5) 2>&5
2822	>	ac_status=$?
2823	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2824	>	(exit $ac_status); }
2825	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2826	>	(eval $ac_compiler -V </dev/null >&5) 2>&5
2827	>	ac_status=$?
2828	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2829	>	(exit $ac_status); }
2830	>	rm -f a.out
2831	>
2832	>	# If we don't use `.F' as extension, the preprocessor is not run on the
2833	>	# input file.  (Note that this only needs to work for GNU compilers.)
2834		ac_save_ext=$ac_ext
2835	<	ac_ext=F90
2836	<	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2837	<	echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2838	<	if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2835	>	ac_ext=F
2836	>	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2837	>	echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2838	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2839		echo $ECHO_N "(cached) $ECHO_C" >&6
2840		else
2841		cat >conftest.$ac_ext <<_ACEOF
2842	<
3198	<	program main
3199	<
2842	>	program main
2843		#ifndef __GNUC__
2844		choke me
2845		#endif
2846
2847	<	end program main
3205	<
2847	>	end
2848		_ACEOF
2849		rm -f conftest.$ac_objext
2850		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3213 | Line 2855 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2855		cat conftest.err >&5
2856		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2857		(exit $ac_status); } &&
2858	<	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
2858	>	{ ac_try='test -z "$ac_fc_werror_flag"
2859	>	|| test ! -s conftest.err'
2860		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2861		(eval $ac_try) 2>&5
2862		ac_status=$?
#	Line 3233 | Line 2876 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2876		ac_compiler_gnu=no
2877		fi
2878		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2879	<	ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2879	>	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2880
2881		fi
2882	<	echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2883	<	echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2882	>	echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2883	>	echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2884		ac_ext=$ac_save_ext
2885	<	G95=`test $ac_compiler_gnu = yes && echo yes`
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
2885	>	ac_test_FFLAGS=${FCFLAGS+set}
2886	>	ac_save_FFLAGS=$FCFLAGS
2887	>	FCFLAGS=
2888	>	echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2889	>	echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2890	>	if test "${ac_cv_prog_fc_g+set}" = set; then
2891	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2892	>	else
2893	>	FCFLAGS=-g
2894	>	cat >conftest.$ac_ext <<_ACEOF
2895	>	program main
2896
2897	<
3250	<
3251	<
3252	<
3253	<	# Try to determine native compiler flags that allow us to use F90 suffix
3254	<	# for preprocessed f90 source.
3255	<
3256	<	if test "$ac_test_PREPFLAG" != "set"; then
3257	<	PREPFLAG=""
3258	<	case "${host_cpu}-${host_os}" in
3259	<
3260	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3261	<	PREPFLAG="-fpp1 "
3262	<	fi;;
3263	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3264	<	PREPFLAG="-qsuffix=cpp=F90 "
3265	<	fi;;
3266	<	*darwin*)
3267	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3268	<	PREPFLAG="-qsuffix=cpp=F90 "
3269	<	fi;;
3270	<	esac
3271	<
3272	<	if test -z "$PREPFLAG"; then
3273	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3274	<	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3275	<	PREPFLAG=""
3276	<	fi
3277	<
3278	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3279	<	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3280	<
3281	<
3282	<	ac_ext=f90
3283	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3284	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3285	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3286	<
3287	<	ac_save_ext=$ac_ext
3288	<	ac_ext=F90
3289	<	ac_save_F90FLAGS=$F90FLAGS
3290	<
3291	<	if test "$PREPFLAG"; then
3292	<	F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3293	<	fi
3294	<
3295	<	cat >conftest.$ac_ext <<_ACEOF
3296	<
3297	<
3298	<	program main
3299	<
3300	<	integer :: i
3301	<	i = 1
3302	<
3303	<
3304	<	end program main
3305	<
2897	>	end
2898		_ACEOF
2899		rm -f conftest.$ac_objext
2900		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3313 | Line 2905 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2905		cat conftest.err >&5
2906		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2907		(exit $ac_status); } &&
2908	<	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
2908	>	{ ac_try='test -z "$ac_fc_werror_flag"
2909	>	|| test ! -s conftest.err'
2910		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2911		(eval $ac_try) 2>&5
2912		ac_status=$?
#	Line 3325 | Line 2918 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2918		ac_status=$?
2919		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920		(exit $ac_status); }; }; then
2921	<	prepflagworks=1
2921	>	ac_cv_prog_fc_g=yes
2922		else
2923		echo "$as_me: failed program was:" >&5
2924		sed 's/^/| /' conftest.$ac_ext >&5
2925
2926	<	prepflagworks=0
2926	>	ac_cv_prog_fc_g=no
2927		fi
2928		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2929
2930	<	F90FLAGS=$ac_save_F90FLAGS
2931	<	ac_ext=$ac_save_ext
2932	<	ac_ext=c
2930	>	fi
2931	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2932	>	echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2933	>	if test "$ac_test_FFLAGS" = set; then
2934	>	FCFLAGS=$ac_save_FFLAGS
2935	>	elif test $ac_cv_prog_fc_g = yes; then
2936	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2937	>	FCFLAGS="-g -O2"
2938	>	else
2939	>	FCFLAGS="-g"
2940	>	fi
2941	>	else
2942	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2943	>	FCFLAGS="-O2"
2944	>	else
2945	>	FCFLAGS=
2946	>	fi
2947	>	fi
2948	>
2949	>	ac_ext=c
2950		ac_cpp='$CPP $CPPFLAGS'
2951		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2952		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2953		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2954
2955	+	ac_ext=c
2956	+	ac_cpp='$CPP $CPPFLAGS'
2957	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2958	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2959	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2960	+	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2961	+	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2962	+	# On Suns, sometimes $CPP names a directory.
2963	+	if test -n "$CPP" && test -d "$CPP"; then
2964	+	CPP=
2965	+	fi
2966	+	if test -z "$CPP"; then
2967	+	if test "${ac_cv_prog_CPP+set}" = set; then
2968	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2969	+	else
2970	+	# Double quotes because CPP needs to be expanded
2971	+	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2972	+	do
2973	+	ac_preproc_ok=false
2974	+	for ac_c_preproc_warn_flag in '' yes
2975	+	do
2976	+	# Use a header file that comes with gcc, so configuring glibc
2977	+	# with a fresh cross-compiler works.
2978	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2979	+	# <limits.h> exists even on freestanding compilers.
2980	+	# On the NeXT, cc -E runs the code through the compiler's parser,
2981	+	# not just through cpp. "Syntax error" is here to catch this case.
2982	+	cat >conftest.$ac_ext <<_ACEOF
2983	+	/* confdefs.h.  */
2984	+	_ACEOF
2985	+	cat confdefs.h >>conftest.$ac_ext
2986	+	cat >>conftest.$ac_ext <<_ACEOF
2987	+	/* end confdefs.h.  */
2988	+	#ifdef __STDC__
2989	+	# include <limits.h>
2990	+	#else
2991	+	# include <assert.h>
2992	+	#endif
2993	+	Syntax error
2994	+	_ACEOF
2995	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2996	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2997	+	ac_status=$?
2998	+	grep -v '^ *+' conftest.er1 >conftest.err
2999	+	rm -f conftest.er1
3000	+	cat conftest.err >&5
3001	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3002	+	(exit $ac_status); } >/dev/null; then
3003	+	if test -s conftest.err; then
3004	+	ac_cpp_err=$ac_c_preproc_warn_flag
3005	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3006	+	else
3007	+	ac_cpp_err=
3008	+	fi
3009	+	else
3010	+	ac_cpp_err=yes
3011	+	fi
3012	+	if test -z "$ac_cpp_err"; then
3013	+	:
3014	+	else
3015	+	echo "$as_me: failed program was:" >&5
3016	+	sed 's/^/| /' conftest.$ac_ext >&5
3017
3018	<	if test "$prepflagworks" = 1; then
3019	<	echo "$as_me:$LINENO: result: yes" >&5
3020	<	echo "${ECHO_T}yes" >&6
3018	>	# Broken: fails on valid input.
3019	>	continue
3020	>	fi
3021	>	rm -f conftest.err conftest.$ac_ext
3022
3023	+	# OK, works on sane cases.  Now check whether non-existent headers
3024	+	# can be detected and how.
3025	+	cat >conftest.$ac_ext <<_ACEOF
3026	+	/* confdefs.h.  */
3027	+	_ACEOF
3028	+	cat confdefs.h >>conftest.$ac_ext
3029	+	cat >>conftest.$ac_ext <<_ACEOF
3030	+	/* end confdefs.h.  */
3031	+	#include <ac_nonexistent.h>
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	<	echo "$as_me:$LINENO: result: no" >&5
3352	<	echo "${ECHO_T}no" >&6
3353	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3354	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3355	<	{ (exit 1); exit 1; }; }
3045	>	ac_cpp_err=
3046		fi
3047	+	else
3048	+	ac_cpp_err=yes
3049		fi
3050	+	if test -z "$ac_cpp_err"; then
3051	+	# Broken: success on invalid input.
3052	+	continue
3053	+	else
3054	+	echo "$as_me: failed program was:" >&5
3055	+	sed 's/^/| /' conftest.$ac_ext >&5
3056
3057	+	# Passes both tests.
3058	+	ac_preproc_ok=:
3059	+	break
3060	+	fi
3061	+	rm -f conftest.err conftest.$ac_ext
3062
3063	<
3064	<
3065	<
3066	<	# Try to determine native compiler flags that allow us to use F90 suffix
3067	<	# for preprocessed f90 source with -D type defines
3365	<
3366	<	if test "$ac_test_PREPDEFFLAG" != "set"; then
3367	<	PREPDEFFLAG=""
3368	<	case "${host_cpu}-${host_os}" in
3369	<
3370	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3371	<	PREPDEFFLAG=" "
3372	<	fi;;
3373	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3374	<	PREPDEFFLAG="-WF,"
3375	<	fi;;
3376	<	*darwin*)
3377	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3378	<	PREPDEFFLAG="-WF,"
3379	<	fi;;
3380	<	esac
3381	<
3382	<	if test -z "$PREPDEFFLAG"; then
3383	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3384	<	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3385	<	PREPDEFFLAG=" "
3386	<	fi
3387	<
3388	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3389	<	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3390	<
3391	<
3392	<	ac_ext=f90
3393	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3394	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3395	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3396	<
3397	<	ac_save_ext=$ac_ext
3398	<	ac_ext=F90
3399	<	ac_save_F90FLAGS=$F90FLAGS
3400	<
3401	<	if test "$PREPDEFFLAG"; then
3402	<	F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3063	>	done
3064	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3065	>	rm -f conftest.err conftest.$ac_ext
3066	>	if $ac_preproc_ok; then
3067	>	break
3068		fi
3069
3070	<	cat >conftest.$ac_ext <<_ACEOF
3070	>	done
3071	>	ac_cv_prog_CPP=$CPP
3072
3073	<
3074	<	program main
3075	<
3076	<	integer :: i
3077	<	#ifdef TEST
3078	<	i = 1
3073	>	fi
3074	>	CPP=$ac_cv_prog_CPP
3075	>	else
3076	>	ac_cv_prog_CPP=$CPP
3077	>	fi
3078	>	echo "$as_me:$LINENO: result: $CPP" >&5
3079	>	echo "${ECHO_T}$CPP" >&6
3080	>	ac_preproc_ok=false
3081	>	for ac_c_preproc_warn_flag in '' yes
3082	>	do
3083	>	# Use a header file that comes with gcc, so configuring glibc
3084	>	# with a fresh cross-compiler works.
3085	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3086	>	# <limits.h> exists even on freestanding compilers.
3087	>	# On the NeXT, cc -E runs the code through the compiler's parser,
3088	>	# not just through cpp. "Syntax error" is here to catch this case.
3089	>	cat >conftest.$ac_ext <<_ACEOF
3090	>	/* confdefs.h.  */
3091	>	_ACEOF
3092	>	cat confdefs.h >>conftest.$ac_ext
3093	>	cat >>conftest.$ac_ext <<_ACEOF
3094	>	/* end confdefs.h.  */
3095	>	#ifdef __STDC__
3096	>	# include <limits.h>
3097		#else
3098	<	choke me
3098	>	# include <assert.h>
3099		#endif
3100	+	Syntax error
3101	+	_ACEOF
3102	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3103	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3104	+	ac_status=$?
3105	+	grep -v '^ *+' conftest.er1 >conftest.err
3106	+	rm -f conftest.er1
3107	+	cat conftest.err >&5
3108	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3109	+	(exit $ac_status); } >/dev/null; then
3110	+	if test -s conftest.err; then
3111	+	ac_cpp_err=$ac_c_preproc_warn_flag
3112	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3113	+	else
3114	+	ac_cpp_err=
3115	+	fi
3116	+	else
3117	+	ac_cpp_err=yes
3118	+	fi
3119	+	if test -z "$ac_cpp_err"; then
3120	+	:
3121	+	else
3122	+	echo "$as_me: failed program was:" >&5
3123	+	sed 's/^/| /' conftest.$ac_ext >&5
3124
3125	+	# Broken: fails on valid input.
3126	+	continue
3127	+	fi
3128	+	rm -f conftest.err conftest.$ac_ext
3129
3130	<	end program main
3131	<
3130	>	# OK, works on sane cases.  Now check whether non-existent headers
3131	>	# can be detected and how.
3132	>	cat >conftest.$ac_ext <<_ACEOF
3133	>	/* confdefs.h.  */
3134		_ACEOF
3135	<	rm -f conftest.$ac_objext
3136	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3137	<	(eval $ac_compile) 2>conftest.er1
3135	>	cat confdefs.h >>conftest.$ac_ext
3136	>	cat >>conftest.$ac_ext <<_ACEOF
3137	>	/* end confdefs.h.  */
3138	>	#include <ac_nonexistent.h>
3139	>	_ACEOF
3140	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3141	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3142		ac_status=$?
3143		grep -v '^ *+' conftest.er1 >conftest.err
3144		rm -f conftest.er1
3145		cat conftest.err >&5
3146		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3147	<	(exit $ac_status); } &&
3148	<	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3149	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3150	<	(eval $ac_try) 2>&5
3151	<	ac_status=$?
3152	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3153	<	(exit $ac_status); }; } &&
3436	<	{ ac_try='test -s conftest.$ac_objext'
3437	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3438	<	(eval $ac_try) 2>&5
3439	<	ac_status=$?
3440	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3441	<	(exit $ac_status); }; }; then
3442	<	prepdefflagworks=1
3147	>	(exit $ac_status); } >/dev/null; then
3148	>	if test -s conftest.err; then
3149	>	ac_cpp_err=$ac_c_preproc_warn_flag
3150	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3151	>	else
3152	>	ac_cpp_err=
3153	>	fi
3154		else
3155	+	ac_cpp_err=yes
3156	+	fi
3157	+	if test -z "$ac_cpp_err"; then
3158	+	# Broken: success on invalid input.
3159	+	continue
3160	+	else
3161		echo "$as_me: failed program was:" >&5
3162		sed 's/^/| /' conftest.$ac_ext >&5
3163
3164	<	prepdefflagworks=0
3164	>	# Passes both tests.
3165	>	ac_preproc_ok=:
3166	>	break
3167		fi
3168	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3168	>	rm -f conftest.err conftest.$ac_ext
3169
3170	<	F90FLAGS=$ac_save_F90FLAGS
3171	<	ac_ext=$ac_save_ext
3172	<	ac_ext=c
3170	>	done
3171	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3172	>	rm -f conftest.err conftest.$ac_ext
3173	>	if $ac_preproc_ok; then
3174	>	:
3175	>	else
3176	>	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3177	>	See \`config.log' for more details." >&5
3178	>	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3179	>	See \`config.log' for more details." >&2;}
3180	>	{ (exit 1); exit 1; }; }
3181	>	fi
3182	>
3183	>	ac_ext=c
3184		ac_cpp='$CPP $CPPFLAGS'
3185		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3186		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3187		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3188
3189	+	echo "$as_me:$LINENO: checking for egrep" >&5
3190	+	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3191	+	if test "${ac_cv_prog_egrep+set}" = set; then
3192	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3193	+	else
3194	+	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3195	+	then ac_cv_prog_egrep='grep -E'
3196	+	else ac_cv_prog_egrep='egrep'
3197	+	fi
3198	+	fi
3199	+	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3200	+	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3201	+	EGREP=$ac_cv_prog_egrep
3202
3203
3204	<	if test "$prepdefflagworks" = 1; then
3205	<	echo "$as_me:$LINENO: result: yes" >&5
3204	>	echo "$as_me:$LINENO: checking whether ln -s works" >&5
3205	>	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3206	>	LN_S=$as_ln_s
3207	>	if test "$LN_S" = "ln -s"; then
3208	>	echo "$as_me:$LINENO: result: yes" >&5
3209		echo "${ECHO_T}yes" >&6
3210	+	else
3211	+	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3212	+	echo "${ECHO_T}no, using $LN_S" >&6
3213	+	fi
3214
3215	<	else
3216	<	echo "$as_me:$LINENO: result: no" >&5
3215	>	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3216	>	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3217	>	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3218	>	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3219	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3220	>	else
3221	>	cat >conftest.make <<\_ACEOF
3222	>	all:
3223	>	@echo 'ac_maketemp="$(MAKE)"'
3224	>	_ACEOF
3225	>	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3226	>	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3227	>	if test -n "$ac_maketemp"; then
3228	>	eval ac_cv_prog_make_${ac_make}_set=yes
3229	>	else
3230	>	eval ac_cv_prog_make_${ac_make}_set=no
3231	>	fi
3232	>	rm -f conftest.make
3233	>	fi
3234	>	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3235	>	echo "$as_me:$LINENO: result: yes" >&5
3236	>	echo "${ECHO_T}yes" >&6
3237	>	SET_MAKE=
3238	>	else
3239	>	echo "$as_me:$LINENO: result: no" >&5
3240		echo "${ECHO_T}no" >&6
3241	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3469	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3470	<	{ (exit 1); exit 1; }; }
3471	<	fi
3241	>	SET_MAKE="MAKE=${MAKE-make}"
3242		fi
3243
3244	<	ac_ext=f90
3245	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3246	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3247	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3244	>	if test -n "$ac_tool_prefix"; then
3245	>	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3246	>	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3247	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3248	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3249	>	if test "${ac_cv_prog_RANLIB+set}" = set; then
3250	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3251	>	else
3252	>	if test -n "$RANLIB"; then
3253	>	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3254	>	else
3255	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3256	>	for as_dir in $PATH
3257	>	do
3258	>	IFS=$as_save_IFS
3259	>	test -z "$as_dir" && as_dir=.
3260	>	for ac_exec_ext in '' $ac_executable_extensions; do
3261	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3262	>	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3263	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3264	>	break 2
3265	>	fi
3266	>	done
3267	>	done
3268
3479	–
3480	–
3481	–	ac_ext=f90
3482	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485	–	echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486	–	echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487	–	if test "${ac_cv_prog_f90_v+set}" = set; then
3488	–	echo $ECHO_N "(cached) $ECHO_C" >&6
3489	–	else
3490	–
3491	–	cat >conftest.$ac_ext <<_ACEOF
3492	–
3493	–	program main
3494	–
3495	–
3496	–	end program main
3497	–
3498	–	_ACEOF
3499	–	rm -f conftest.$ac_objext
3500	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3501	–	(eval $ac_compile) 2>conftest.er1
3502	–	ac_status=$?
3503	–	grep -v '^ *+' conftest.er1 >conftest.err
3504	–	rm -f conftest.er1
3505	–	cat conftest.err >&5
3506	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3507	–	(exit $ac_status); } &&
3508	–	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3509	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3510	–	(eval $ac_try) 2>&5
3511	–	ac_status=$?
3512	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513	–	(exit $ac_status); }; } &&
3514	–	{ ac_try='test -s conftest.$ac_objext'
3515	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3516	–	(eval $ac_try) 2>&5
3517	–	ac_status=$?
3518	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3519	–	(exit $ac_status); }; }; then
3520	–	ac_cv_prog_f90_v=
3521	–	# Try some options frequently used verbose output
3522	–	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3523	–	ac_ext=f90
3524	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3525	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3526	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3527	–
3528	–	cat >conftest.$ac_ext <<_ACEOF
3529	–
3530	–	program main
3531	–
3532	–
3533	–	end program main
3534	–
3535	–	_ACEOF
3536	–
3537	–	# Compile and link our simple test program by passing a flag (argument
3538	–	# 1 to this macro) to the Fortran 90 compiler in order to get
3539	–	# "verbose" output that we can then parse for the Fortran 90 linker
3540	–	# flags.
3541	–	ac_save_F90FLAGS=$F90FLAGS
3542	–	F90FLAGS="$F90FLAGS $ac_verb"
3543	–
3544	–	(eval echo $as_me:3544: \"$ac_link\") >&5
3545	–	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3546	–	echo "$ac_f90_v_output" >&5
3547	–	F90FLAGS=$ac_save_F90FLAGS
3548	–
3549	–	rm -f conftest.*
3550	–	ac_ext=f90
3551	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3552	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3553	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3554	–
3555	–	# If we are using xlf then replace all the commas with spaces.
3556	–	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3557	–	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3269		fi
3559	–
3560	–	# If we are using Cray Fortran then delete quotes.
3561	–	# Use "\"" instead of '"' for font-lock-mode.
3562	–	# FIXME: a more general fix for quoted arguments with spaces?
3563	–	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3564	–	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3270		fi
3271	<	# look for -l* and *.a constructs in the output
3272	<	for ac_arg in $ac_f90_v_output; do
3273	<	case $ac_arg in
3274	<	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3570	<	ac_cv_prog_f90_v=$ac_verb
3571	<	break 2 ;;
3572	<	esac
3573	<	done
3574	<	done
3575	<	if test -z "$ac_cv_prog_f90_v"; then
3576	<	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3577	<	echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3578	<	fi
3271	>	RANLIB=$ac_cv_prog_RANLIB
3272	>	if test -n "$RANLIB"; then
3273	>	echo "$as_me:$LINENO: result: $RANLIB" >&5
3274	>	echo "${ECHO_T}$RANLIB" >&6
3275		else
3276	<	echo "$as_me: failed program was:" >&5
3277	<	sed 's/^/| /' conftest.$ac_ext >&5
3582	<
3583	<	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3584	<	echo "$as_me: WARNING: compilation failed" >&2;}
3276	>	echo "$as_me:$LINENO: result: no" >&5
3277	>	echo "${ECHO_T}no" >&6
3278		fi
3586	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3279
3280		fi
3281	<	echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3282	<	echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3283	<	echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3284	<	echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3285	<	if test "${ac_cv_flibs+set}" = set; then
3281	>	if test -z "$ac_cv_prog_RANLIB"; then
3282	>	ac_ct_RANLIB=$RANLIB
3283	>	# Extract the first word of "ranlib", so it can be a program name with args.
3284	>	set dummy ranlib; ac_word=$2
3285	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3286	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3287	>	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3288		echo $ECHO_N "(cached) $ECHO_C" >&6
3289		else
3290	<	if test "x$F90LIBS" != "x"; then
3291	<	ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3290	>	if test -n "$ac_ct_RANLIB"; then
3291	>	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3292		else
3293	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3294	+	for as_dir in $PATH
3295	+	do
3296	+	IFS=$as_save_IFS
3297	+	test -z "$as_dir" && as_dir=.
3298	+	for ac_exec_ext in '' $ac_executable_extensions; do
3299	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3300	+	ac_cv_prog_ac_ct_RANLIB="ranlib"
3301	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3302	+	break 2
3303	+	fi
3304	+	done
3305	+	done
3306
3307	<	ac_ext=f90
3308	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3309	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3310	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3307	>	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3308	>	fi
3309	>	fi
3310	>	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3311	>	if test -n "$ac_ct_RANLIB"; then
3312	>	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3313	>	echo "${ECHO_T}$ac_ct_RANLIB" >&6
3314	>	else
3315	>	echo "$as_me:$LINENO: result: no" >&5
3316	>	echo "${ECHO_T}no" >&6
3317	>	fi
3318
3319	<	cat >conftest.$ac_ext <<_ACEOF
3319	>	RANLIB=$ac_ct_RANLIB
3320	>	else
3321	>	RANLIB="$ac_cv_prog_RANLIB"
3322	>	fi
3323
3607	–	program main
3324
3325	+	# Extract the first word of "perl", so it can be a program name with args.
3326	+	set dummy perl; ac_word=$2
3327	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3328	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3329	+	if test "${ac_cv_path_PERLINTERP+set}" = set; then
3330	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3331	+	else
3332	+	case $PERLINTERP in
3333	+	[\\/]* | ?:[\\/]*)
3334	+	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3335	+	;;
3336	+	*)
3337	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3338	+	for as_dir in $PATH
3339	+	do
3340	+	IFS=$as_save_IFS
3341	+	test -z "$as_dir" && as_dir=.
3342	+	for ac_exec_ext in '' $ac_executable_extensions; do
3343	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3344	+	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3345	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3346	+	break 2
3347	+	fi
3348	+	done
3349	+	done
3350
3351	<	end program main
3352	<
3353	<	_ACEOF
3613	<
3614	<	# Compile and link our simple test program by passing a flag (argument
3615	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3616	<	# "verbose" output that we can then parse for the Fortran 90 linker
3617	<	# flags.
3618	<	ac_save_F90FLAGS=$F90FLAGS
3619	<	F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3620	<
3621	<	(eval echo $as_me:3621: \"$ac_link\") >&5
3622	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3623	<	echo "$ac_f90_v_output" >&5
3624	<	F90FLAGS=$ac_save_F90FLAGS
3625	<
3626	<	rm -f conftest.*
3627	<	ac_ext=f90
3628	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3629	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3630	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3631	<
3632	<	# If we are using xlf then replace all the commas with spaces.
3633	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3634	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3351	>	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3352	>	;;
3353	>	esac
3354		fi
3355	+	PERLINTERP=$ac_cv_path_PERLINTERP
3356
3357	<	# If we are using Cray Fortran then delete quotes.
3358	<	# Use "\"" instead of '"' for font-lock-mode.
3359	<	# FIXME: a more general fix for quoted arguments with spaces?
3360	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3361	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3357	>	if test -n "$PERLINTERP"; then
3358	>	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3359	>	echo "${ECHO_T}$PERLINTERP" >&6
3360	>	else
3361	>	echo "$as_me:$LINENO: result: no" >&5
3362	>	echo "${ECHO_T}no" >&6
3363		fi
3364
3365	<	ac_cv_f90libs=
3365	>	ac_cv_path_perlinterp="$PERLINTERP"
3366	>	_sHpB='#!'
3367
3646	–	# Save positional arguments (if any)
3647	–	ac_save_positional="$@"
3368
3369	<	set X $ac_f90_v_output
3370	<	while test $# != 1; do
3369	>	# Check whether --with-perl-shebang or --without-perl-shebang was given.
3370	>	if test "${with_perl_shebang+set}" = set; then
3371	>	withval="$with_perl_shebang"
3372	>	opt_perl_shebang="$withval"
3373	>	else
3374	>	opt_perl_shebang="not_set"
3375	>	fi;
3376	>	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3377	>	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3378	>	if test "${ax_cv_opt_perl_shebang+set}" = set; then
3379	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3380	>	else
3381	>	case "$opt_perl_shebang" in
3382	>	not_set  ) ax_cv_opt_perl_shebang=''
3383	>	;;
3384	>	*     )
3385	>	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3386	>	esac
3387	>
3388	>	fi
3389	>	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3390	>	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3391	>	if test "A$ax_cv_opt_perl_shebang" != "A"
3392	>	then
3393	>	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3394	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3395	>	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3396	>	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3397	>
3398	>	# Automatic detection of sharpbang formula starts here
3399	>	else
3400	>	_somian_shbangperl=`$PERLINTERP -V:startperl`
3401	>	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3402	>	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3403	>	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3404	>	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3405	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3406	>	else
3407	>	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3408	>	if test "x$_somian_kspb_perl" == x
3409	>	then _somian_ksbp_warn_empty='durnit'
3410	>	else
3411	>	case "A$_somian_kspb_perl" in
3412	>	A#!*perl* )
3413	>	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3414	>	;;
3415	>	A*    )  _somian_ksbp_warn_defau='trouble'
3416	>	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3417	>	esac
3418	>	fi
3419	>
3420	>	fi
3421	>	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3422	>	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3423	>	# The above prints Checking ... result message to user.
3424	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3425	>
3426	>	if test A${_somian_ksbp_warn_empty+set} == Aset
3427	>	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3428	>	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3429	>	fi
3430	>	# Inform user after printing result value
3431	>	if test A${_somian_ksbp_warn_defau+set} == Aset
3432	>	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3433	>	echo "$as_me: Maybe Not good -" >&6;}
3434	>	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3435	>	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3436	>	else { echo "$as_me:$LINENO: OK Good result - " >&5
3437	>	echo "$as_me: OK Good result - " >&6;}
3438	>	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3439	>	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3440	>	fi
3441	>	fi
3442	>
3443	>	# Find a good install program.  We prefer a C program (faster),
3444	>	# so one script is as good as another.  But avoid the broken or
3445	>	# incompatible versions:
3446	>	# SysV /etc/install, /usr/sbin/install
3447	>	# SunOS /usr/etc/install
3448	>	# IRIX /sbin/install
3449	>	# AIX /bin/install
3450	>	# AmigaOS /C/install, which installs bootblocks on floppy discs
3451	>	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3452	>	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3453	>	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3454	>	# OS/2's system install, which has a completely different semantic
3455	>	# ./install, which can be erroneously created by make from ./install.sh.
3456	>	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3457	>	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3458	>	if test -z "$INSTALL"; then
3459	>	if test "${ac_cv_path_install+set}" = set; then
3460	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3461	>	else
3462	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3463	>	for as_dir in $PATH
3464	>	do
3465	>	IFS=$as_save_IFS
3466	>	test -z "$as_dir" && as_dir=.
3467	>	# Account for people who put trailing slashes in PATH elements.
3468	>	case $as_dir/ in
3469	>	./ | .// | /cC/* | \
3470	>	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3471	>	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3472	>	/usr/ucb/* ) ;;
3473	>	*)
3474	>	# OSF1 and SCO ODT 3.0 have their own names for install.
3475	>	# Don't use installbsd from OSF since it installs stuff as root
3476	>	# by default.
3477	>	for ac_prog in ginstall scoinst install; do
3478	>	for ac_exec_ext in '' $ac_executable_extensions; do
3479	>	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3480	>	if test $ac_prog = install &&
3481	>	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3482	>	# AIX install.  It has an incompatible calling convention.
3483	>	:
3484	>	elif test $ac_prog = install &&
3485	>	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3486	>	# program-specific install script used by HP pwplus--don't use.
3487	>	:
3488	>	else
3489	>	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3490	>	break 3
3491	>	fi
3492	>	fi
3493	>	done
3494	>	done
3495	>	;;
3496	>	esac
3497	>	done
3498	>
3499	>
3500	>	fi
3501	>	if test "${ac_cv_path_install+set}" = set; then
3502	>	INSTALL=$ac_cv_path_install
3503	>	else
3504	>	# As a last resort, use the slow shell script.  We don't cache a
3505	>	# path for INSTALL within a source directory, because that will
3506	>	# break other packages using the cache if that directory is
3507	>	# removed, or if the path is relative.
3508	>	INSTALL=$ac_install_sh
3509	>	fi
3510	>	fi
3511	>	echo "$as_me:$LINENO: result: $INSTALL" >&5
3512	>	echo "${ECHO_T}$INSTALL" >&6
3513	>
3514	>	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3515	>	# It thinks the first close brace ends the variable substitution.
3516	>	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3517	>
3518	>	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3519	>
3520	>	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3521	>
3522	>	case "x$INSTALL" in
3523	>	x/*) ;;
3524	>	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3525	>	esac
3526	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3527	>	# Extract the first word of "ar", so it can be a program name with args.
3528	>	set dummy ar; ac_word=$2
3529	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3530	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3531	>	if test "${ac_cv_prog_AR+set}" = set; then
3532	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3533	>	else
3534	>	if test -n "$AR"; then
3535	>	ac_cv_prog_AR="$AR" # Let the user override the test.
3536	>	else
3537	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3538	>	for as_dir in $PATH
3539	>	do
3540	>	IFS=$as_save_IFS
3541	>	test -z "$as_dir" && as_dir=.
3542	>	for ac_exec_ext in '' $ac_executable_extensions; do
3543	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3544	>	ac_cv_prog_AR="ar"
3545	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3546	>	break 2
3547	>	fi
3548	>	done
3549	>	done
3550	>
3551	>	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3552	>	fi
3553	>	fi
3554	>	AR=$ac_cv_prog_AR
3555	>	if test -n "$AR"; then
3556	>	echo "$as_me:$LINENO: result: $AR" >&5
3557	>	echo "${ECHO_T}$AR" >&6
3558	>	else
3559	>	echo "$as_me:$LINENO: result: no" >&5
3560	>	echo "${ECHO_T}no" >&6
3561	>	fi
3562	>
3563	>	if test "$AR" = "NONE"; then
3564	>	cat >confcache <<\_ACEOF
3565	>	# This file is a shell script that caches the results of configure
3566	>	# tests run on this system so they can be shared between configure
3567	>	# scripts and configure runs, see configure's option --config-cache.
3568	>	# It is not useful on other systems.  If it contains results you don't
3569	>	# want to keep, you may remove or edit it.
3570	>	#
3571	>	# config.status only pays attention to the cache file if you give it
3572	>	# the --recheck option to rerun configure.
3573	>	#
3574	>	# `ac_cv_env_foo' variables (set or unset) will be overridden when
3575	>	# loading this file, other *unset* `ac_cv_foo' will be assigned the
3576	>	# following values.
3577	>
3578	>	_ACEOF
3579	>
3580	>	# The following way of writing the cache mishandles newlines in values,
3581	>	# but we know of no workaround that is simple, portable, and efficient.
3582	>	# So, don't put newlines in cache variables' values.
3583	>	# Ultrix sh set writes to stderr and can't be redirected directly,
3584	>	# and sets the high bit in the cache file unless we assign to the vars.
3585	>	{
3586	>	(set) 2>&1 |
3587	>	case `(ac_space=' '; set | grep ac_space) 2>&1` in
3588	>	*ac_space=\ *)
3589	>	# `set' does not quote correctly, so add quotes (double-quote
3590	>	# substitution turns \\\\ into \\, and sed turns \\ into \).
3591	>	sed -n \
3592	>	"s/'/'\\\\''/g;
3593	>	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3594	>	;;
3595	>	*)
3596	>	# `set' quotes correctly as required by POSIX, so do not add quotes.
3597	>	sed -n \
3598	>	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3599	>	;;
3600	>	esac;
3601	>	} |
3602	>	sed '
3603	>	t clear
3604	>	: clear
3605	>	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3606	>	t end
3607	>	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3608	>	: end' >>confcache
3609	>	if diff $cache_file confcache >/dev/null 2>&1; then :; else
3610	>	if test -w $cache_file; then
3611	>	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3612	>	cat confcache >$cache_file
3613	>	else
3614	>	echo "not updating unwritable cache $cache_file"
3615	>	fi
3616	>	fi
3617	>	rm -f confcache
3618	>	exit 1
3619	>	fi
3620	>	# Extract the first word of "ps", so it can be a program name with args.
3621	>	set dummy ps; ac_word=$2
3622	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3623	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3624	>	if test "${ac_cv_path_PS+set}" = set; then
3625	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3626	>	else
3627	>	case $PS in
3628	>	[\\/]* | ?:[\\/]*)
3629	>	ac_cv_path_PS="$PS" # Let the user override the test with a path.
3630	>	;;
3631	>	*)
3632	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3633	>	for as_dir in $PATH
3634	>	do
3635	>	IFS=$as_save_IFS
3636	>	test -z "$as_dir" && as_dir=.
3637	>	for ac_exec_ext in '' $ac_executable_extensions; do
3638	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3639	>	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3640	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3641	>	break 2
3642	>	fi
3643	>	done
3644	>	done
3645	>
3646	>	;;
3647	>	esac
3648	>	fi
3649	>	PS=$ac_cv_path_PS
3650	>
3651	>	if test -n "$PS"; then
3652	>	echo "$as_me:$LINENO: result: $PS" >&5
3653	>	echo "${ECHO_T}$PS" >&6
3654	>	else
3655	>	echo "$as_me:$LINENO: result: no" >&5
3656	>	echo "${ECHO_T}no" >&6
3657	>	fi
3658	>
3659	>	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3660	>	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3661	>	if test "${ac_cv_prog_ps_syntax+set}" = set; then
3662	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3663	>	else
3664	>
3665	>	if $PS ax -o rss > /dev/null 2>&1; then
3666	>	ac_cv_prog_ps_ax=yes
3667	>	else
3668	>	ac_cv_prog_ps_ax=no
3669	>	fi
3670	>	if $PS -ef -o rss > /dev/null 2>&1; then
3671	>	ac_cv_prog_ps_ef=yes
3672	>	else
3673	>	ac_cv_prog_ps_ef=no
3674	>	fi
3675	>	if test "$ac_cv_prog_ps_ax" = yes; then
3676	>	ac_cv_prog_ps_syntax=BSD
3677	>	else
3678	>	if test "$ac_cv_prog_ps_ef" = yes; then
3679	>	ac_cv_prog_ps_syntax=POSIX
3680	>	else
3681	>	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3682	>	echo "$as_me: error: Could not determine ps syntax" >&2;}
3683	>	{ (exit 1); exit 1; }; }
3684	>	fi
3685	>	fi
3686	>
3687	>	fi
3688	>	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3689	>	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3690	>
3691	>	cat >>confdefs.h <<_ACEOF
3692	>	#define PSCOMMAND $PS
3693	>	_ACEOF
3694	>
3695	>	if test "$ac_cv_prog_ps_syntax" = BSD; then
3696	>
3697	>	cat >>confdefs.h <<\_ACEOF
3698	>	#define PSTYPE_IS_BSD 1
3699	>	_ACEOF
3700	>
3701	>	else
3702	>	if test "$ac_cv_prog_ps_syntax" = POSIX; then
3703	>
3704	>	cat >>confdefs.h <<\_ACEOF
3705	>	#define PSTYPE_IS_POSIX 1
3706	>	_ACEOF
3707	>
3708	>	else
3709	>	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3710	>	echo "$as_me: error: Unknown ps syntax type!" >&2;}
3711	>	{ (exit 1); exit 1; }; }
3712	>	fi
3713	>	fi
3714	>
3715	>	ac_ext=${FC_SRCEXT-f}
3716	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3717	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3718	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3719	>
3720	>
3721	>	echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3722	>	echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3723	>	if test "${ac_cv_fc_srcext_F90+set}" = set; then
3724	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3725	>	else
3726	>	ac_ext=F90
3727	>	ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3728	>	FCFLAGS_SRCEXT=""
3729	>	ac_cv_fc_srcext_F90=unknown
3730	>	for ac_flag in none -qsuffix=f=F90 -Tf; do
3731	>	test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3732	>	cat >conftest.$ac_ext <<_ACEOF
3733	>	program main
3734	>
3735	>	end
3736	>	_ACEOF
3737	>	rm -f conftest.$ac_objext
3738	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3739	>	(eval $ac_compile) 2>conftest.er1
3740	>	ac_status=$?
3741	>	grep -v '^ *+' conftest.er1 >conftest.err
3742	>	rm -f conftest.er1
3743	>	cat conftest.err >&5
3744	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745	>	(exit $ac_status); } &&
3746	>	{ ac_try='test -z "$ac_fc_werror_flag"
3747	>	|| test ! -s conftest.err'
3748	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749	>	(eval $ac_try) 2>&5
3750	>	ac_status=$?
3751	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3752	>	(exit $ac_status); }; } &&
3753	>	{ ac_try='test -s conftest.$ac_objext'
3754	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3755	>	(eval $ac_try) 2>&5
3756	>	ac_status=$?
3757	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758	>	(exit $ac_status); }; }; then
3759	>	ac_cv_fc_srcext_F90=$ac_flag; break
3760	>	else
3761	>	echo "$as_me: failed program was:" >&5
3762	>	sed 's/^/| /' conftest.$ac_ext >&5
3763	>
3764	>	fi
3765	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3766	>	done
3767	>	rm -f conftest.$ac_objext conftest.F90
3768	>	FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3769	>
3770	>	fi
3771	>	echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3772	>	echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3773	>	if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3774	>	{ { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3775	>	echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3776	>	{ (exit 1); exit 1; }; }
3777	>	else
3778	>	FC_SRCEXT=F90
3779	>	if test "x$ac_cv_fc_srcext_F90" = xnone; then
3780	>	FCFLAGS_SRCEXT=""
3781	>	FCFLAGS_F90=""
3782	>	else
3783	>	FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3784	>	FCFLAGS_F90=$ac_cv_fc_srcext_F90
3785	>	fi
3786	>
3787	>
3788	>	fi
3789	>
3790	>
3791	>
3792	>
3793	>
3794	>	# Try to determine native compiler flags that allow us to use F90 suffix
3795	>	# for preprocessed f90 source.
3796	>
3797	>	if test "$ac_test_PREPFLAG" != "set"; then
3798	>	PREPFLAG=""
3799	>	case "${host_cpu}-${host_os}" in
3800	>
3801	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3802	>	PREPFLAG="-fpp1 "
3803	>	fi;;
3804	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3805	>	PREPFLAG="-qsuffix=cpp=F90 "
3806	>	fi;;
3807	>	*darwin*)
3808	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3809	>	PREPFLAG="-qsuffix=cpp=F90 "
3810	>	fi;;
3811	>	esac
3812	>
3813	>	if test -z "$PREPFLAG"; then
3814	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3815	>	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3816	>	PREPFLAG=""
3817	>	fi
3818	>
3819	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3820	>	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3821	>
3822	>
3823	>	ac_ext=${FC_SRCEXT-f}
3824	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3825	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3826	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3827	>
3828	>	ac_save_ext=$ac_ext
3829	>	ac_ext=F90
3830	>	ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3831	>
3832	>	if test "$PREPFLAG"; then
3833	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3834	>	fi
3835	>
3836	>	cat >conftest.$ac_ext <<_ACEOF
3837	>
3838	>
3839	>	program conftest
3840	>	integer :: i
3841	>	i = 1
3842	>	end program conftest
3843	>
3844	>	_ACEOF
3845	>	rm -f conftest.$ac_objext
3846	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3847	>	(eval $ac_compile) 2>conftest.er1
3848	>	ac_status=$?
3849	>	grep -v '^ *+' conftest.er1 >conftest.err
3850	>	rm -f conftest.er1
3851	>	cat conftest.err >&5
3852	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853	>	(exit $ac_status); } &&
3854	>	{ ac_try='test -z "$ac_fc_werror_flag"
3855	>	|| test ! -s conftest.err'
3856	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3857	>	(eval $ac_try) 2>&5
3858	>	ac_status=$?
3859	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3860	>	(exit $ac_status); }; } &&
3861	>	{ ac_try='test -s conftest.$ac_objext'
3862	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3863	>	(eval $ac_try) 2>&5
3864	>	ac_status=$?
3865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3866	>	(exit $ac_status); }; }; then
3867	>	prepflagworks=1
3868	>	else
3869	>	echo "$as_me: failed program was:" >&5
3870	>	sed 's/^/| /' conftest.$ac_ext >&5
3871	>
3872	>	prepflagworks=0
3873	>	fi
3874	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3875	>
3876	>	FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3877	>	ac_ext=$ac_save_ext
3878	>	ac_ext=${FC_SRCEXT-f}
3879	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3880	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3881	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3882	>
3883	>
3884	>	if test "$prepflagworks" = 1; then
3885	>	echo "$as_me:$LINENO: result: yes" >&5
3886	>	echo "${ECHO_T}yes" >&6
3887	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3888	>
3889	>	else
3890	>	echo "$as_me:$LINENO: result: no" >&5
3891	>	echo "${ECHO_T}no" >&6
3892	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3893	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3894	>	{ (exit 1); exit 1; }; }
3895	>	fi
3896	>	fi
3897	>
3898	>
3899	>
3900	>
3901	>
3902	>	# Try to determine native compiler flags that allow us to use F90 suffix
3903	>	# for preprocessed f90 source with -D type defines
3904	>
3905	>	if test "$ac_test_PREPDEFFLAG" != "set"; then
3906	>	PREPDEFFLAG=""
3907	>	case "${host_cpu}-${host_os}" in
3908	>
3909	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3910	>	PREPDEFFLAG=" "
3911	>	fi;;
3912	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3913	>	PREPDEFFLAG="-WF,"
3914	>	fi;;
3915	>	*darwin*)
3916	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3917	>	PREPDEFFLAG="-WF,"
3918	>	fi;;
3919	>	esac
3920	>
3921	>	if test -z "$PREPDEFFLAG"; then
3922	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3923	>	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3924	>	PREPDEFFLAG=" "
3925	>	fi
3926	>
3927	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3928	>	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3929	>
3930	>
3931	>	ac_ext=${FC_SRCEXT-f}
3932	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3933	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3934	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3935	>
3936	>	ac_save_ext=$ac_ext
3937	>	ac_ext=F90
3938	>	ac_save_FCFLAGS=$FCFLAGS
3939	>
3940	>	if test "$PREPDEFFLAG"; then
3941	>	FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3942	>	fi
3943	>
3944	>	cat >conftest.$ac_ext <<_ACEOF
3945	>
3946	>
3947	>	program conftest
3948	>	integer :: i
3949	>	#ifdef TEST
3950	>	i = 1
3951	>	#else
3952	>	choke me
3953	>	#endif
3954	>	end program conftest
3955	>
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	>	prepdefflagworks=1
3980	>	else
3981	>	echo "$as_me: failed program was:" >&5
3982	>	sed 's/^/| /' conftest.$ac_ext >&5
3983	>
3984	>	prepdefflagworks=0
3985	>	fi
3986	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3987	>
3988	>	FCFLAGS=$ac_save_FCFLAGS
3989	>	ac_ext=$ac_save_ext
3990	>	ac_ext=${FC_SRCEXT-f}
3991	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3992	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3993	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3994	>
3995	>
3996	>	if test "$prepdefflagworks" = 1; then
3997	>	echo "$as_me:$LINENO: result: yes" >&5
3998	>	echo "${ECHO_T}yes" >&6
3999	>
4000	>	else
4001	>	echo "$as_me:$LINENO: result: no" >&5
4002	>	echo "${ECHO_T}no" >&6
4003	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4004	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4005	>	{ (exit 1); exit 1; }; }
4006	>	fi
4007	>	fi
4008	>
4009	>	ac_ext=${FC_SRCEXT-f}
4010	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4011	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4012	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4013	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4014	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4015	>	if test "${ac_cv_prog_fc_v+set}" = set; then
4016	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4017	>	else
4018	>	cat >conftest.$ac_ext <<_ACEOF
4019	>	program main
4020	>
4021	>	end
4022	>	_ACEOF
4023	>	rm -f conftest.$ac_objext
4024	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4025	>	(eval $ac_compile) 2>conftest.er1
4026	>	ac_status=$?
4027	>	grep -v '^ *+' conftest.er1 >conftest.err
4028	>	rm -f conftest.er1
4029	>	cat conftest.err >&5
4030	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031	>	(exit $ac_status); } &&
4032	>	{ ac_try='test -z "$ac_fc_werror_flag"
4033	>	|| test ! -s conftest.err'
4034	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035	>	(eval $ac_try) 2>&5
4036	>	ac_status=$?
4037	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038	>	(exit $ac_status); }; } &&
4039	>	{ ac_try='test -s conftest.$ac_objext'
4040	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4041	>	(eval $ac_try) 2>&5
4042	>	ac_status=$?
4043	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044	>	(exit $ac_status); }; }; then
4045	>	ac_cv_prog_fc_v=
4046	>	# Try some options frequently used verbose output
4047	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4048	>	cat >conftest.$ac_ext <<_ACEOF
4049	>	program main
4050	>
4051	>	end
4052	>	_ACEOF
4053	>
4054	>	# Compile and link our simple test program by passing a flag (argument
4055	>	# 1 to this macro) to the Fortran compiler in order to get
4056	>	# "verbose" output that we can then parse for the Fortran linker
4057	>	# flags.
4058	>	ac_save_FFLAGS=$FCFLAGS
4059	>	FCFLAGS="$FCFLAGS $ac_verb"
4060	>	(eval echo $as_me:4060: \"$ac_link\") >&5
4061	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4062	>	echo "$ac_fc_v_output" >&5
4063	>	FCFLAGS=$ac_save_FFLAGS
4064	>
4065	>	rm -f conftest*
4066	>
4067	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4068	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4069	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4070	>	ac_fc_v_output="`echo $ac_fc_v_output |
4071	>	grep 'LPATH is:' |
4072	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4073	>
4074	>	case $ac_fc_v_output in
4075	>	# If we are using xlf then replace all the commas with spaces.
4076	>	*xlfentry*)
4077	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4078	>
4079	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4080	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4081	>	*mGLOB_options_string*)
4082	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4083	>
4084	>	# If we are using Cray Fortran then delete quotes.
4085	>	# Use "\"" instead of '"' for font-lock-mode.
4086	>	# FIXME: a more general fix for quoted arguments with spaces?
4087	>	*cft90*)
4088	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4089	>	esac
4090	>
4091	>
4092	>	# look for -l* and *.a constructs in the output
4093	>	for ac_arg in $ac_fc_v_output; do
4094	>	case $ac_arg in
4095	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4096	>	ac_cv_prog_fc_v=$ac_verb
4097	>	break 2 ;;
4098	>	esac
4099	>	done
4100	>	done
4101	>	if test -z "$ac_cv_prog_fc_v"; then
4102	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4103	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4104	>	fi
4105	>	else
4106	>	echo "$as_me: failed program was:" >&5
4107	>	sed 's/^/| /' conftest.$ac_ext >&5
4108	>
4109	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4110	>	echo "$as_me: WARNING: compilation failed" >&2;}
4111	>	fi
4112	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4113	>
4114	>	fi
4115	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4116	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4117	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4118	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4119	>	if test "${ac_cv_fc_libs+set}" = set; then
4120	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4121	>	else
4122	>	if test "x$FCLIBS" != "x"; then
4123	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4124	>	else
4125	>
4126	>	cat >conftest.$ac_ext <<_ACEOF
4127	>	program main
4128	>
4129	>	end
4130	>	_ACEOF
4131	>
4132	>	# Compile and link our simple test program by passing a flag (argument
4133	>	# 1 to this macro) to the Fortran compiler in order to get
4134	>	# "verbose" output that we can then parse for the Fortran linker
4135	>	# flags.
4136	>	ac_save_FFLAGS=$FCFLAGS
4137	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4138	>	(eval echo $as_me:4138: \"$ac_link\") >&5
4139	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4140	>	echo "$ac_fc_v_output" >&5
4141	>	FCFLAGS=$ac_save_FFLAGS
4142	>
4143	>	rm -f conftest*
4144	>
4145	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4146	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4147	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4148	>	ac_fc_v_output="`echo $ac_fc_v_output |
4149	>	grep 'LPATH is:' |
4150	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4151	>
4152	>	case $ac_fc_v_output in
4153	>	# If we are using xlf then replace all the commas with spaces.
4154	>	*xlfentry*)
4155	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4156	>
4157	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4158	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4159	>	*mGLOB_options_string*)
4160	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4161	>
4162	>	# If we are using Cray Fortran then delete quotes.
4163	>	# Use "\"" instead of '"' for font-lock-mode.
4164	>	# FIXME: a more general fix for quoted arguments with spaces?
4165	>	*cft90*)
4166	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4167	>	esac
4168	>
4169	>
4170	>
4171	>	ac_cv_fc_libs=
4172	>
4173	>	# Save positional arguments (if any)
4174	>	ac_save_positional="$@"
4175	>
4176	>	set X $ac_fc_v_output
4177	>	while test $# != 1; do
4178		shift
4179		ac_arg=$1
4180		case $ac_arg in
4181		[\\/]*.a | ?:[\\/]*.a)
4182		ac_exists=false
4183	<	for ac_i in $ac_cv_f90libs; do
4183	>	for ac_i in $ac_cv_fc_libs; do
4184		if test x"$ac_arg" = x"$ac_i"; then
4185		ac_exists=true
4186		break
#	Line 3663 | Line 4190 | else
4190		if test x"$ac_exists" = xtrue; then
4191		:
4192		else
4193	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4193	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4194		fi
4195
4196		;;
4197		-bI:*)
4198		ac_exists=false
4199	<	for ac_i in $ac_cv_f90libs; do
4199	>	for ac_i in $ac_cv_fc_libs; do
4200		if test x"$ac_arg" = x"$ac_i"; then
4201		ac_exists=true
4202		break
#	Line 3681 | Line 4208 | else
4208		else
4209		if test "$ac_compiler_gnu" = yes; then
4210		for ac_link_opt in $ac_arg; do
4211	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4211	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4212		done
4213		else
4214	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4214	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4215		fi
4216		fi
4217
4218		;;
4219		# Ignore these flags.
4220	<	-lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4220	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4221		;;
4222		-lkernel32)
4223	<	test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4223	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4224		;;
4225		-[LRuY])
4226		# These flags, when seen by themselves, take an argument.
4227		# We remove the space between option and argument and re-iterate
4228		# unless we find an empty arg or a new option (starting with -)
4229		case $2 in
4230	<	"" | -*);;
4231	<	*)
4230	>	"" | -*);;
4231	>	*)
4232		ac_arg="$ac_arg$2"
3706	–
4233		shift; shift
4234		set X $ac_arg "$@"
4235		;;
#	Line 3712 | Line 4238 | fi
4238		-YP,*)
4239		for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4240		ac_exists=false
4241	<	for ac_i in $ac_cv_f90libs; do
4241	>	for ac_i in $ac_cv_fc_libs; do
4242		if test x"$ac_j" = x"$ac_i"; then
4243		ac_exists=true
4244		break
#	Line 3723 | Line 4249 | else
4249		:
4250		else
4251		ac_arg="$ac_arg $ac_j"
4252	<	ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4252	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4253		fi
4254
4255		done
4256		;;
4257		-[lLR]*)
4258		ac_exists=false
4259	<	for ac_i in $ac_cv_f90libs; do
4259	>	for ac_i in $ac_cv_fc_libs; do
4260		if test x"$ac_arg" = x"$ac_i"; then
4261		ac_exists=true
4262		break
#	Line 3740 | Line 4266 | else
4266		if test x"$ac_exists" = xtrue; then
4267		:
4268		else
4269	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4269	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4270		fi
4271
4272		;;
#	Line 3755 | Line 4281 | case `(uname -sr) 2>/dev/null` in
4281		# must begin with a "/").
4282		case `(uname -sr) 2>/dev/null` in
4283		"SunOS 5"*)
4284	<	ac_ld_run_path=`echo $ac_f90_v_output |
4284	>	ac_ld_run_path=`echo $ac_fc_v_output |
4285		sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4286		test "x$ac_ld_run_path" != x &&
3761	–
4287		if test "$ac_compiler_gnu" = yes; then
4288		for ac_link_opt in $ac_ld_run_path; do
4289	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4289	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4290		done
4291		else
4292	<	ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4292	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4293		fi
4294		;;
4295		esac
4296	<	fi # test "x$F90LIBS" = "x"
4296	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4297
4298		fi
4299	<	echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4300	<	echo "${ECHO_T}$ac_cv_flibs" >&6
4301	<	F90LIBS="$ac_cv_f90libs"
4299	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4300	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
4301	>	FCLIBS="$ac_cv_fc_libs"
4302
3778	–	ac_ext=f90
3779	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3780	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3781	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4303
4304	+	ac_ext=${FC_SRCEXT-f}
4305	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4306	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4307	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4308
4309	<	echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4310	<	echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4311	<	if test "${ac_cv_f90_mangling+set}" = set; then
4309	>
4310	>	ac_ext=${FC_SRCEXT-f}
4311	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4312	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4313	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4314	>
4315	>	echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4316	>	echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4317	>	if test "${ac_cv_fc_dummy_main+set}" = set; then
4318		echo $ECHO_N "(cached) $ECHO_C" >&6
4319		else
4320	<	ac_ext=f90
4321	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4322	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4323	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3793	<	cat >conftest.$ac_ext <<_ACEOF
3794	<	subroutine foobar()
3795	<	return
3796	<	end
3797	<	subroutine foo_bar()
3798	<	return
3799	<	end
3800	<	_ACEOF
3801	<	rm -f conftest.$ac_objext
3802	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3803	<	(eval $ac_compile) 2>conftest.er1
3804	<	ac_status=$?
3805	<	grep -v '^ *+' conftest.er1 >conftest.err
3806	<	rm -f conftest.er1
3807	<	cat conftest.err >&5
3808	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3809	<	(exit $ac_status); } &&
3810	<	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3811	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812	<	(eval $ac_try) 2>&5
3813	<	ac_status=$?
3814	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815	<	(exit $ac_status); }; } &&
3816	<	{ ac_try='test -s conftest.$ac_objext'
3817	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818	<	(eval $ac_try) 2>&5
3819	<	ac_status=$?
3820	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821	<	(exit $ac_status); }; }; then
3822	<	mv conftest.$ac_objext cf90_test.$ac_objext
3823	<
3824	<	ac_ext=c
4320	>	ac_fc_dm_save_LIBS=$LIBS
4321	>	LIBS="$LIBS $FCLIBS"
4322	>	ac_fortran_dm_var=FC_DUMMY_MAIN
4323	>	ac_ext=c
4324		ac_cpp='$CPP $CPPFLAGS'
4325		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4326		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4327		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4328
4329	<	ac_save_LIBS=$LIBS
4330	<	LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3832	<
3833	<	ac_success=no
3834	<	for ac_foobar in foobar FOOBAR; do
3835	<	for ac_underscore in "" "_"; do
3836	<	ac_func="$ac_foobar$ac_underscore"
3837	<	cat >conftest.$ac_ext <<_ACEOF
4329	>	# First, try linking without a dummy main:
4330	>	cat >conftest.$ac_ext <<_ACEOF
4331		/* confdefs.h.  */
4332		_ACEOF
4333		cat confdefs.h >>conftest.$ac_ext
4334		cat >>conftest.$ac_ext <<_ACEOF
4335		/* end confdefs.h.  */
4336
4337	<	/* Override any gcc2 internal prototype to avoid an error.  */
4338	<	#ifdef __cplusplus
4339	<	extern "C"
4337	>	#ifdef FC_DUMMY_MAIN
4338	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4339	>	#  ifdef __cplusplus
4340	>	extern "C"
4341	>	#  endif
4342	>	int FC_DUMMY_MAIN() { return 1; }
4343		#endif
4344	<	/* We use char because int might match the return type of a gcc2
3849	<	builtin and then its argument prototype would still apply.  */
3850	<	char $ac_func ();
4344	>	#endif
4345		int
4346		main ()
4347		{
4348	<	$ac_func ();
4348	>
4349		;
4350		return 0;
4351		}
#	Line 3865 | Line 4359 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4359		cat conftest.err >&5
4360		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361		(exit $ac_status); } &&
4362	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4362	>	{ ac_try='test -z "$ac_c_werror_flag"
4363	>	|| test ! -s conftest.err'
4364		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4365		(eval $ac_try) 2>&5
4366		ac_status=$?
#	Line 3877 | Line 4372 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4372		ac_status=$?
4373		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4374		(exit $ac_status); }; }; then
4375	<	ac_success=yes; break 2
4375	>	ac_cv_fortran_dummy_main=none
4376		else
4377		echo "$as_me: failed program was:" >&5
4378		sed 's/^/| /' conftest.$ac_ext >&5
4379
4380	+	ac_cv_fortran_dummy_main=unknown
4381		fi
4382		rm -f conftest.err conftest.$ac_objext \
4383		conftest$ac_exeext conftest.$ac_ext
3888	–	done
3889	–	done
4384
4385	<	if test "$ac_success" = "yes"; then
4386	<	case $ac_foobar in
4387	<	foobar)
3894	<	ac_case=lower
3895	<	ac_foo_bar=foo_bar
3896	<	;;
3897	<	FOOBAR)
3898	<	ac_case=upper
3899	<	ac_foo_bar=FOO_BAR
3900	<	;;
3901	<	esac
3902	<
3903	<	ac_success_extra=no
3904	<	for ac_extra in "" "_"; do
3905	<	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3906	<
3907	<	cat >conftest.$ac_ext <<_ACEOF
4385	>	if test $ac_cv_fortran_dummy_main = unknown; then
4386	>	for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4387	>	cat >conftest.$ac_ext <<_ACEOF
4388		/* confdefs.h.  */
4389		_ACEOF
4390		cat confdefs.h >>conftest.$ac_ext
4391		cat >>conftest.$ac_ext <<_ACEOF
4392		/* end confdefs.h.  */
4393	<
4394	<	/* Override any gcc2 internal prototype to avoid an error.  */
4395	<	#ifdef __cplusplus
4396	<	extern "C"
4393	>	#define $ac_fortran_dm_var $ac_func
4394	>	#ifdef FC_DUMMY_MAIN
4395	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4396	>	#  ifdef __cplusplus
4397	>	extern "C"
4398	>	#  endif
4399	>	int FC_DUMMY_MAIN() { return 1; }
4400		#endif
4401	<	/* We use char because int might match the return type of a gcc2
3919	<	builtin and then its argument prototype would still apply.  */
3920	<	char $ac_func ();
4401	>	#endif
4402		int
4403		main ()
4404		{
4405	<	$ac_func ();
4405	>
4406		;
4407		return 0;
4408		}
#	Line 3935 | Line 4416 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4416		cat conftest.err >&5
4417		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418		(exit $ac_status); } &&
4419	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4419	>	{ ac_try='test -z "$ac_c_werror_flag"
4420	>	|| test ! -s conftest.err'
4421		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4422		(eval $ac_try) 2>&5
4423		ac_status=$?
#	Line 3947 | Line 4429 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4429		ac_status=$?
4430		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4431		(exit $ac_status); }; }; then
4432	<	ac_success_extra=yes; break
4432	>	ac_cv_fortran_dummy_main=$ac_func; break
4433		else
4434		echo "$as_me: failed program was:" >&5
4435		sed 's/^/| /' conftest.$ac_ext >&5
#	Line 3955 | Line 4437 | rm -f conftest.err conftest.$ac_objext \
4437		fi
4438		rm -f conftest.err conftest.$ac_objext \
4439		conftest$ac_exeext conftest.$ac_ext
4440	<	done
4440	>	done
4441	>	fi
4442	>	ac_ext=${FC_SRCEXT-f}
4443	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4444	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4445	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4446	>	ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4447	>	rm -f conftest*
4448	>	LIBS=$ac_fc_dm_save_LIBS
4449
4450	<	if test "$ac_success_extra" = "yes"; then
4451	<	ac_cv_f90_mangling="$ac_case case"
4452	<	if test -z "$ac_underscore"; then
4453	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4454	<	else
4455	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4450	>	fi
4451	>	echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4452	>	echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4453	>	FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4454	>	if test "$FC_DUMMY_MAIN" != unknown; then
4455	>	if test $FC_DUMMY_MAIN != none; then
4456
4457	<	fi
4458	<	if test -z "$ac_extra"; then
4459	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3970	<	else
3971	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3972	<	fi
3973	<	else
3974	<	ac_cv_f90_mangling="unknown"
3975	<	fi
3976	<	else
3977	<	ac_cv_f90_mangling="unknown"
4457	>	cat >>confdefs.h <<_ACEOF
4458	>	#define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4459	>	_ACEOF
4460
4461	<	fi
4461	>	if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4462
4463	<	LIBS=$ac_save_LIBS
4464	<	ac_ext=f90
4465	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4466	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4467	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4468	<	rm -f cf90_test* conftest*
4463	>	cat >>confdefs.h <<\_ACEOF
4464	>	#define FC_DUMMY_MAIN_EQ_F77 1
4465	>	_ACEOF
4466	>
4467	>	fi
4468	>	fi
4469		else
4470	+	{ { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4471	+	See \`config.log' for more details." >&5
4472	+	echo "$as_me: error: linking to Fortran libraries from C fails
4473	+	See \`config.log' for more details." >&2;}
4474	+	{ (exit 1); exit 1; }; }
4475	+	fi
4476	+
4477	+
4478	+	ac_ext=${FC_SRCEXT-f}
4479	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4480	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4481	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4482	+
4483	+	ac_ext=${FC_SRCEXT-f}
4484	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4485	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4486	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4487	+	echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4488	+	echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4489	+	if test "${ac_cv_fc_mangling+set}" = set; then
4490	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4491	+	else
4492	+	cat >conftest.$ac_ext <<_ACEOF
4493	+	subroutine foobar()
4494	+	return
4495	+	end
4496	+	subroutine foo_bar()
4497	+	return
4498	+	end
4499	+	_ACEOF
4500	+	rm -f conftest.$ac_objext
4501	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4502	+	(eval $ac_compile) 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_fc_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_objext'
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	+	mv conftest.$ac_objext cfortran_test.$ac_objext
4523	+
4524	+	ac_save_LIBS=$LIBS
4525	+	LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4526	+
4527	+	ac_ext=c
4528	+	ac_cpp='$CPP $CPPFLAGS'
4529	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4530	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4531	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4532	+	ac_success=no
4533	+	for ac_foobar in foobar FOOBAR; do
4534	+	for ac_underscore in "" "_"; do
4535	+	ac_func="$ac_foobar$ac_underscore"
4536	+	cat >conftest.$ac_ext <<_ACEOF
4537	+	/* confdefs.h.  */
4538	+	_ACEOF
4539	+	cat confdefs.h >>conftest.$ac_ext
4540	+	cat >>conftest.$ac_ext <<_ACEOF
4541	+	/* end confdefs.h.  */
4542	+
4543	+	/* Override any gcc2 internal prototype to avoid an error.  */
4544	+	#ifdef __cplusplus
4545	+	extern "C"
4546	+	#endif
4547	+	/* We use char because int might match the return type of a gcc2
4548	+	builtin and then its argument prototype would still apply.  */
4549	+	char $ac_func ();
4550	+	#ifdef FC_DUMMY_MAIN
4551	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4552	+	#  ifdef __cplusplus
4553	+	extern "C"
4554	+	#  endif
4555	+	int FC_DUMMY_MAIN() { return 1; }
4556	+	#endif
4557	+	#endif
4558	+	int
4559	+	main ()
4560	+	{
4561	+	$ac_func ();
4562	+	;
4563	+	return 0;
4564	+	}
4565	+	_ACEOF
4566	+	rm -f conftest.$ac_objext conftest$ac_exeext
4567	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4568	+	(eval $ac_link) 2>conftest.er1
4569	+	ac_status=$?
4570	+	grep -v '^ *+' conftest.er1 >conftest.err
4571	+	rm -f conftest.er1
4572	+	cat conftest.err >&5
4573	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574	+	(exit $ac_status); } &&
4575	+	{ ac_try='test -z "$ac_c_werror_flag"
4576	+	|| test ! -s conftest.err'
4577	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4578	+	(eval $ac_try) 2>&5
4579	+	ac_status=$?
4580	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4581	+	(exit $ac_status); }; } &&
4582	+	{ ac_try='test -s conftest$ac_exeext'
4583	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4584	+	(eval $ac_try) 2>&5
4585	+	ac_status=$?
4586	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4587	+	(exit $ac_status); }; }; then
4588	+	ac_success=yes; break 2
4589	+	else
4590		echo "$as_me: failed program was:" >&5
4591		sed 's/^/| /' conftest.$ac_ext >&5
4592
4593		fi
4594	+	rm -f conftest.err conftest.$ac_objext \
4595	+	conftest$ac_exeext conftest.$ac_ext
4596	+	done
4597	+	done
4598	+	ac_ext=${FC_SRCEXT-f}
4599	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4600	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4601	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4602	+
4603	+	if test "$ac_success" = "yes"; then
4604	+	case $ac_foobar in
4605	+	foobar)
4606	+	ac_case=lower
4607	+	ac_foo_bar=foo_bar
4608	+	;;
4609	+	FOOBAR)
4610	+	ac_case=upper
4611	+	ac_foo_bar=FOO_BAR
4612	+	;;
4613	+	esac
4614	+
4615	+	ac_ext=c
4616	+	ac_cpp='$CPP $CPPFLAGS'
4617	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4618	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4619	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4620	+	ac_success_extra=no
4621	+	for ac_extra in "" "_"; do
4622	+	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4623	+	cat >conftest.$ac_ext <<_ACEOF
4624	+	/* confdefs.h.  */
4625	+	_ACEOF
4626	+	cat confdefs.h >>conftest.$ac_ext
4627	+	cat >>conftest.$ac_ext <<_ACEOF
4628	+	/* end confdefs.h.  */
4629	+
4630	+	/* Override any gcc2 internal prototype to avoid an error.  */
4631	+	#ifdef __cplusplus
4632	+	extern "C"
4633	+	#endif
4634	+	/* We use char because int might match the return type of a gcc2
4635	+	builtin and then its argument prototype would still apply.  */
4636	+	char $ac_func ();
4637	+	#ifdef FC_DUMMY_MAIN
4638	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4639	+	#  ifdef __cplusplus
4640	+	extern "C"
4641	+	#  endif
4642	+	int FC_DUMMY_MAIN() { return 1; }
4643	+	#endif
4644	+	#endif
4645	+	int
4646	+	main ()
4647	+	{
4648	+	$ac_func ();
4649	+	;
4650	+	return 0;
4651	+	}
4652	+	_ACEOF
4653	+	rm -f conftest.$ac_objext conftest$ac_exeext
4654	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4655	+	(eval $ac_link) 2>conftest.er1
4656	+	ac_status=$?
4657	+	grep -v '^ *+' conftest.er1 >conftest.err
4658	+	rm -f conftest.er1
4659	+	cat conftest.err >&5
4660	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4661	+	(exit $ac_status); } &&
4662	+	{ ac_try='test -z "$ac_c_werror_flag"
4663	+	|| test ! -s conftest.err'
4664	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4665	+	(eval $ac_try) 2>&5
4666	+	ac_status=$?
4667	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4668	+	(exit $ac_status); }; } &&
4669	+	{ ac_try='test -s conftest$ac_exeext'
4670	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4671	+	(eval $ac_try) 2>&5
4672	+	ac_status=$?
4673	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4674	+	(exit $ac_status); }; }; then
4675	+	ac_success_extra=yes; break
4676	+	else
4677	+	echo "$as_me: failed program was:" >&5
4678	+	sed 's/^/| /' conftest.$ac_ext >&5
4679	+
4680	+	fi
4681	+	rm -f conftest.err conftest.$ac_objext \
4682	+	conftest$ac_exeext conftest.$ac_ext
4683	+	done
4684	+	ac_ext=${FC_SRCEXT-f}
4685	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4686	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4687	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4688	+
4689	+	if test "$ac_success_extra" = "yes"; then
4690	+	ac_cv_fc_mangling="$ac_case case"
4691	+	if test -z "$ac_underscore"; then
4692	+	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4693	+	else
4694	+	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4695	+	fi
4696	+	if test -z "$ac_extra"; then
4697	+	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4698	+	else
4699	+	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4700	+	fi
4701	+	else
4702	+	ac_cv_fc_mangling="unknown"
4703	+	fi
4704	+	else
4705	+	ac_cv_fc_mangling="unknown"
4706	+	fi
4707	+
4708	+	LIBS=$ac_save_LIBS
4709	+	rm -f cfortran_test* conftest*
4710	+	else
4711	+	echo "$as_me: failed program was:" >&5
4712	+	sed 's/^/| /' conftest.$ac_ext >&5
4713	+
4714	+	{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4715	+	See \`config.log' for more details." >&5
4716	+	echo "$as_me: error: cannot compile a simple Fortran program
4717	+	See \`config.log' for more details." >&2;}
4718	+	{ (exit 1); exit 1; }; }
4719	+	fi
4720		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3993	–	ac_ext=f90
3994	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3995	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3996	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4721
4722		fi
4723	<	echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4724	<	echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4723	>	echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4724	>	echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4725
4726	+	ac_ext=${FC_SRCEXT-f}
4727	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4728	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4729	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4730
4731	+	ac_ext=${FC_SRCEXT-f}
4732	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4733	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4734	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4735
4736	<	case $ac_cv_f90_mangling in
4736	>
4737	>	case $ac_cv_fc_mangling in
4738		"lower case, no underscore, no extra underscore")
4739		cat >>confdefs.h <<\_ACEOF
4740	<	#define F90_FUNC(name,NAME) name
4740	>	#define FC_FUNC(name,NAME) name
4741		_ACEOF
4742
4743		cat >>confdefs.h <<\_ACEOF
4744	<	#define F90_FUNC_(name,NAME) name
4744	>	#define FC_FUNC_(name,NAME) name
4745		_ACEOF
4746		;;
4747		"lower case, no underscore, extra underscore")
4748		cat >>confdefs.h <<\_ACEOF
4749	<	#define F90_FUNC(name,NAME) name
4749	>	#define FC_FUNC(name,NAME) name
4750		_ACEOF
4751
4752		cat >>confdefs.h <<\_ACEOF
4753	<	#define F90_FUNC_(name,NAME) name ## _
4753	>	#define FC_FUNC_(name,NAME) name ## _
4754		_ACEOF
4755		;;
4756		"lower case, underscore, no extra underscore")
4757		cat >>confdefs.h <<\_ACEOF
4758	<	#define F90_FUNC(name,NAME) name ## _
4758	>	#define FC_FUNC(name,NAME) name ## _
4759		_ACEOF
4760
4761		cat >>confdefs.h <<\_ACEOF
4762	<	#define F90_FUNC_(name,NAME) name ## _
4762	>	#define FC_FUNC_(name,NAME) name ## _
4763		_ACEOF
4764		;;
4765		"lower case, underscore, extra underscore")
4766		cat >>confdefs.h <<\_ACEOF
4767	<	#define F90_FUNC(name,NAME) name ## _
4767	>	#define FC_FUNC(name,NAME) name ## _
4768		_ACEOF
4769
4770		cat >>confdefs.h <<\_ACEOF
4771	<	#define F90_FUNC_(name,NAME) name ## __
4771	>	#define FC_FUNC_(name,NAME) name ## __
4772		_ACEOF
4773		;;
4774		"upper case, no underscore, no extra underscore")
4775		cat >>confdefs.h <<\_ACEOF
4776	<	#define F90_FUNC(name,NAME) NAME
4776	>	#define FC_FUNC(name,NAME) NAME
4777		_ACEOF
4778
4779		cat >>confdefs.h <<\_ACEOF
4780	<	#define F90_FUNC_(name,NAME) NAME
4780	>	#define FC_FUNC_(name,NAME) NAME
4781		_ACEOF
4782		;;
4783		"upper case, no underscore, extra underscore")
4784		cat >>confdefs.h <<\_ACEOF
4785	<	#define F90_FUNC(name,NAME) NAME
4785	>	#define FC_FUNC(name,NAME) NAME
4786		_ACEOF
4787
4788		cat >>confdefs.h <<\_ACEOF
4789	<	#define F90_FUNC_(name,NAME) NAME ## _
4789	>	#define FC_FUNC_(name,NAME) NAME ## _
4790		_ACEOF
4791		;;
4792		"upper case, underscore, no extra underscore")
4793		cat >>confdefs.h <<\_ACEOF
4794	<	#define F90_FUNC(name,NAME) NAME ## _
4794	>	#define FC_FUNC(name,NAME) NAME ## _
4795		_ACEOF
4796
4797		cat >>confdefs.h <<\_ACEOF
4798	<	#define F90_FUNC_(name,NAME) NAME ## _
4798	>	#define FC_FUNC_(name,NAME) NAME ## _
4799		_ACEOF
4800		;;
4801		"upper case, underscore, extra underscore")
4802		cat >>confdefs.h <<\_ACEOF
4803	<	#define F90_FUNC(name,NAME) NAME ## _
4803	>	#define FC_FUNC(name,NAME) NAME ## _
4804		_ACEOF
4805
4806		cat >>confdefs.h <<\_ACEOF
4807	<	#define F90_FUNC_(name,NAME) NAME ## __
4807	>	#define FC_FUNC_(name,NAME) NAME ## __
4808		_ACEOF
4809		;;
4810		*)
4811	<	{ echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4812	<	echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4811	>	{ echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4812	>	echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4813		;;
4814		esac
4815
4816	+	ac_ext=${FC_SRCEXT-f}
4817	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4818	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4819	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4820
4821
4822
4823	+	ac_ext=${FC_SRCEXT-f}
4824	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4825	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4826	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4827	+	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4828	+	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4829	+	if test "${ac_cv_prog_fc_v+set}" = set; then
4830	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4831	+	else
4832	+	cat >conftest.$ac_ext <<_ACEOF
4833	+	program main
4834
4835	+	end
4836	+	_ACEOF
4837	+	rm -f conftest.$ac_objext
4838	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4839	+	(eval $ac_compile) 2>conftest.er1
4840	+	ac_status=$?
4841	+	grep -v '^ *+' conftest.er1 >conftest.err
4842	+	rm -f conftest.er1
4843	+	cat conftest.err >&5
4844	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4845	+	(exit $ac_status); } &&
4846	+	{ ac_try='test -z "$ac_fc_werror_flag"
4847	+	|| test ! -s conftest.err'
4848	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4849	+	(eval $ac_try) 2>&5
4850	+	ac_status=$?
4851	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4852	+	(exit $ac_status); }; } &&
4853	+	{ ac_try='test -s conftest.$ac_objext'
4854	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4855	+	(eval $ac_try) 2>&5
4856	+	ac_status=$?
4857	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4858	+	(exit $ac_status); }; }; then
4859	+	ac_cv_prog_fc_v=
4860	+	# Try some options frequently used verbose output
4861	+	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4862	+	cat >conftest.$ac_ext <<_ACEOF
4863	+	program main
4864	+
4865	+	end
4866	+	_ACEOF
4867	+
4868	+	# Compile and link our simple test program by passing a flag (argument
4869	+	# 1 to this macro) to the Fortran compiler in order to get
4870	+	# "verbose" output that we can then parse for the Fortran linker
4871	+	# flags.
4872	+	ac_save_FFLAGS=$FCFLAGS
4873	+	FCFLAGS="$FCFLAGS $ac_verb"
4874	+	(eval echo $as_me:4874: \"$ac_link\") >&5
4875	+	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4876	+	echo "$ac_fc_v_output" >&5
4877	+	FCFLAGS=$ac_save_FFLAGS
4878	+
4879	+	rm -f conftest*
4880	+
4881	+	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4882	+	# /foo, /bar, and /baz are search directories for the Fortran linker.
4883	+	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4884	+	ac_fc_v_output="`echo $ac_fc_v_output |
4885	+	grep 'LPATH is:' |
4886	+	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4887	+
4888	+	case $ac_fc_v_output in
4889	+	# If we are using xlf then replace all the commas with spaces.
4890	+	*xlfentry*)
4891	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4892	+
4893	+	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4894	+	# $LIBS confuse us, and the libraries appear later in the output anyway).
4895	+	*mGLOB_options_string*)
4896	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4897	+
4898	+	# If we are using Cray Fortran then delete quotes.
4899	+	# Use "\"" instead of '"' for font-lock-mode.
4900	+	# FIXME: a more general fix for quoted arguments with spaces?
4901	+	*cft90*)
4902	+	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4903	+	esac
4904	+
4905	+
4906	+	# look for -l* and *.a constructs in the output
4907	+	for ac_arg in $ac_fc_v_output; do
4908	+	case $ac_arg in
4909	+	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4910	+	ac_cv_prog_fc_v=$ac_verb
4911	+	break 2 ;;
4912	+	esac
4913	+	done
4914	+	done
4915	+	if test -z "$ac_cv_prog_fc_v"; then
4916	+	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4917	+	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4918	+	fi
4919	+	else
4920	+	echo "$as_me: failed program was:" >&5
4921	+	sed 's/^/| /' conftest.$ac_ext >&5
4922	+
4923	+	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4924	+	echo "$as_me: WARNING: compilation failed" >&2;}
4925	+	fi
4926	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4927	+
4928	+	fi
4929	+	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4930	+	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4931	+	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4932	+	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4933	+	if test "${ac_cv_fc_libs+set}" = set; then
4934	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4935	+	else
4936	+	if test "x$FCLIBS" != "x"; then
4937	+	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4938	+	else
4939	+
4940	+	cat >conftest.$ac_ext <<_ACEOF
4941	+	program main
4942	+
4943	+	end
4944	+	_ACEOF
4945	+
4946	+	# Compile and link our simple test program by passing a flag (argument
4947	+	# 1 to this macro) to the Fortran compiler in order to get
4948	+	# "verbose" output that we can then parse for the Fortran linker
4949	+	# flags.
4950	+	ac_save_FFLAGS=$FCFLAGS
4951	+	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4952	+	(eval echo $as_me:4952: \"$ac_link\") >&5
4953	+	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4954	+	echo "$ac_fc_v_output" >&5
4955	+	FCFLAGS=$ac_save_FFLAGS
4956	+
4957	+	rm -f conftest*
4958	+
4959	+	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4960	+	# /foo, /bar, and /baz are search directories for the Fortran linker.
4961	+	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4962	+	ac_fc_v_output="`echo $ac_fc_v_output |
4963	+	grep 'LPATH is:' |
4964	+	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4965	+
4966	+	case $ac_fc_v_output in
4967	+	# If we are using xlf then replace all the commas with spaces.
4968	+	*xlfentry*)
4969	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4970	+
4971	+	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4972	+	# $LIBS confuse us, and the libraries appear later in the output anyway).
4973	+	*mGLOB_options_string*)
4974	+	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4975	+
4976	+	# If we are using Cray Fortran then delete quotes.
4977	+	# Use "\"" instead of '"' for font-lock-mode.
4978	+	# FIXME: a more general fix for quoted arguments with spaces?
4979	+	*cft90*)
4980	+	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4981	+	esac
4982	+
4983	+
4984	+
4985	+	ac_cv_fc_libs=
4986	+
4987	+	# Save positional arguments (if any)
4988	+	ac_save_positional="$@"
4989	+
4990	+	set X $ac_fc_v_output
4991	+	while test $# != 1; do
4992	+	shift
4993	+	ac_arg=$1
4994	+	case $ac_arg in
4995	+	[\\/]*.a | ?:[\\/]*.a)
4996	+	ac_exists=false
4997	+	for ac_i in $ac_cv_fc_libs; do
4998	+	if test x"$ac_arg" = x"$ac_i"; then
4999	+	ac_exists=true
5000	+	break
5001	+	fi
5002	+	done
5003	+
5004	+	if test x"$ac_exists" = xtrue; then
5005	+	:
5006	+	else
5007	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5008	+	fi
5009	+
5010	+	;;
5011	+	-bI:*)
5012	+	ac_exists=false
5013	+	for ac_i in $ac_cv_fc_libs; do
5014	+	if test x"$ac_arg" = x"$ac_i"; then
5015	+	ac_exists=true
5016	+	break
5017	+	fi
5018	+	done
5019	+
5020	+	if test x"$ac_exists" = xtrue; then
5021	+	:
5022	+	else
5023	+	if test "$ac_compiler_gnu" = yes; then
5024	+	for ac_link_opt in $ac_arg; do
5025	+	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5026	+	done
5027	+	else
5028	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5029	+	fi
5030	+	fi
5031	+
5032	+	;;
5033	+	# Ignore these flags.
5034	+	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5035	+	;;
5036	+	-lkernel32)
5037	+	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5038	+	;;
5039	+	-[LRuY])
5040	+	# These flags, when seen by themselves, take an argument.
5041	+	# We remove the space between option and argument and re-iterate
5042	+	# unless we find an empty arg or a new option (starting with -)
5043	+	case $2 in
5044	+	"" | -*);;
5045	+	*)
5046	+	ac_arg="$ac_arg$2"
5047	+	shift; shift
5048	+	set X $ac_arg "$@"
5049	+	;;
5050	+	esac
5051	+	;;
5052	+	-YP,*)
5053	+	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5054	+	ac_exists=false
5055	+	for ac_i in $ac_cv_fc_libs; do
5056	+	if test x"$ac_j" = x"$ac_i"; then
5057	+	ac_exists=true
5058	+	break
5059	+	fi
5060	+	done
5061	+
5062	+	if test x"$ac_exists" = xtrue; then
5063	+	:
5064	+	else
5065	+	ac_arg="$ac_arg $ac_j"
5066	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5067	+	fi
5068	+
5069	+	done
5070	+	;;
5071	+	-[lLR]*)
5072	+	ac_exists=false
5073	+	for ac_i in $ac_cv_fc_libs; do
5074	+	if test x"$ac_arg" = x"$ac_i"; then
5075	+	ac_exists=true
5076	+	break
5077	+	fi
5078	+	done
5079	+
5080	+	if test x"$ac_exists" = xtrue; then
5081	+	:
5082	+	else
5083	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5084	+	fi
5085	+
5086	+	;;
5087	+	# Ignore everything else.
5088	+	esac
5089	+	done
5090	+	# restore positional arguments
5091	+	set X $ac_save_positional; shift
5092	+
5093	+	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5094	+	# then we insist that the "run path" must be an absolute path (i.e. it
5095	+	# must begin with a "/").
5096	+	case `(uname -sr) 2>/dev/null` in
5097	+	"SunOS 5"*)
5098	+	ac_ld_run_path=`echo $ac_fc_v_output |
5099	+	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5100	+	test "x$ac_ld_run_path" != x &&
5101	+	if test "$ac_compiler_gnu" = yes; then
5102	+	for ac_link_opt in $ac_ld_run_path; do
5103	+	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5104	+	done
5105	+	else
5106	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5107	+	fi
5108	+	;;
5109	+	esac
5110	+	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5111	+
5112	+	fi
5113	+	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5114	+	echo "${ECHO_T}$ac_cv_fc_libs" >&6
5115	+	FCLIBS="$ac_cv_fc_libs"
5116	+
5117	+
5118	+	ac_ext=${FC_SRCEXT-f}
5119	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5120	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5121	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5122	+
5123	+
5124	+
5125		echo "$as_me:$LINENO: checking for module suffix" >&5
5126		echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5127		rm -f conftest*
5128		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5129		rm -f work*
5130	<	cat >conftest.f90 <<EOF
5130	>	cat >conftest.$ac_ext <<EOF
5131		module conftest
5132		integer n
5133		parameter (n=1)
#	Line 4098 | Line 5136 | modcase="lower"
5136		# SGI and absoft compilers generates module name in upper case!
5137		testname="conftest"
5138		modcase="lower"
5139	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5140	<	MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5139	>	if (eval $ac_compile) 2>/dev/null ; then
5140	>	MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5141		MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5142		if test -z "$MOD" ; then
5143		MOD=`ls CONFTEST* 2>/dev/null \
5144	<	| grep -v CONFTEST.f | grep -v CONFTEST.o`
5144	>	| grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5145		MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5146		if test -n "$MOD" ; then
5147		testname="CONFTEST"
#	Line 4143 | Line 5181 | rm -f work*
5181		rm -f conftest*
5182		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5183		rm -f work*
5184	<	cat >conftest.f90 <<EOF
5184	>	cat >conftest.$ac_ext <<EOF
5185		module conftest
5186		integer n
5187		parameter (n=1)
#	Line 4151 | Line 5189 | testname="conftest"
5189		EOF
5190		# SGI and absoft compilers generates module name in upper case!
5191		testname="conftest"
5192	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5193	<	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5192	>	if (eval $ac_compile) 2>/dev/null ; then
5193	>	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5194		mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5195		if test -n "$mod" ; then
5196		testname="CONFTEST"
#	Line 4161 | Line 5199 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5199		if test ! -d conf ; then mkdir conf ; madedir=1; fi
5200		cp $testname.$MOD conf
5201		rm -f conftest* CONFTEST*
5202	<	cat >conftest1.f90 <<EOF
5202	>	cat >conftest1.$ac_ext <<EOF
5203		program main
5204		use conftest
5205		print *, n
#	Line 4169 | Line 5207 | EOF
5207		EOF
5208		F90_WORK_FILES_ARG=""
5209		F90MODINCSPEC=""
5210	<	if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5210	>	if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5211		MODDIRFLAG="-I"
5212		F90MODINCSPEC="-I<dir>"
5213		echo "$as_me:$LINENO: result: -I" >&5
5214		echo "${ECHO_T}-I" >&6
5215	<	elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5215	>	elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5216		MODDIRFLAG="-M"
5217		F90MODINCSPEC="-M<dir>"
5218		echo "$as_me:$LINENO: result: -M" >&5
5219		echo "${ECHO_T}-M" >&6
5220	<	elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5220	>	elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5221		MODDIRFLAG="-p"
5222		F90MODINCSPEC="-p<dir>"
5223		echo "$as_me:$LINENO: result: -p" >&5
#	Line 4188 | Line 5226 | echo "${ECHO_T}-p" >&6
5226		cp work.pc conf/mpimod.pc
5227		echo "mpimod.pc" > conf/mpimod.pcl
5228		echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5229	<	if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5229	>	if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5230		MODDIRFLAG='-cl,mpimod.pcl'
5231		echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5232		echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
#	Line 4218 | Line 5256 | else
5256		if test "${ac_cv_f90_module_names+set}" = set; then
5257		echo $ECHO_N "(cached) $ECHO_C" >&6
5258		else
5259	<	ac_ext=f90
5260	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5261	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5262	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5259	>	ac_ext=${FC_SRCEXT-f}
5260	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5261	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5262	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5263
5264		# carry out the test in a new directory, so that we don't miss anything
5265		mkdir conftest
#	Line 4239 | Line 5277 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5277		cat conftest.err >&5
5278		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5279		(exit $ac_status); } &&
5280	<	{ ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
5280	>	{ ac_try='test -z "$ac_fc_werror_flag"
5281	>	|| test ! -s conftest.err'
5282		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5283		(eval $ac_try) 2>&5
5284		ac_status=$?
#	Line 4354 | Line 5393 | rm -rf conftest
5393		cd ..
5394		# cleanup
5395		rm -rf conftest
5396	<	ac_ext=f90
5397	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5398	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5399	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5396	>	ac_ext=${FC_SRCEXT-f}
5397	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5398	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5399	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5400
5401		fi
5402		echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
#	Line 4446 | Line 5485 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5485		ac_compiler_gnu=$ac_cv_c_compiler_gnu
5486
5487
5488	<	ac_ext=cc
5489	<	ac_cpp='$CXXCPP $CPPFLAGS'
5490	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5491	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5492	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5488	>	ac_ext=c
5489	>	ac_cpp='$CPP $CPPFLAGS'
5490	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5491	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5492	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5493
5494
5495
#	Line 4475 | Line 5514 | char asin ();
5514		/* We use char because int might match the return type of a gcc2
5515		builtin and then its argument prototype would still apply.  */
5516		char asin ();
5517	+	#ifdef FC_DUMMY_MAIN
5518	+	#ifndef FC_DUMMY_MAIN_EQ_F77
5519	+	#  ifdef __cplusplus
5520	+	extern "C"
5521	+	#  endif
5522	+	int FC_DUMMY_MAIN() { return 1; }
5523	+	#endif
5524	+	#endif
5525		int
5526		main ()
5527		{
#	Line 4492 | Line 5539 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5539		cat conftest.err >&5
5540		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5541		(exit $ac_status); } &&
5542	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
5542	>	{ ac_try='test -z "$ac_c_werror_flag"
5543	>	|| test ! -s conftest.err'
5544		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5545		(eval $ac_try) 2>&5
5546		ac_status=$?
#	Line 4529 | Line 5577 | fi
5577		fi
5578
5579
5580	<	ac_ext=c
5581	<	ac_cpp='$CPP $CPPFLAGS'
5582	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4535	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4536	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4537	<
4538	<	ac_ext=c
4539	<	ac_cpp='$CPP $CPPFLAGS'
4540	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4541	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4542	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4543	<	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4544	<	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4545	<	# On Suns, sometimes $CPP names a directory.
4546	<	if test -n "$CPP" && test -d "$CPP"; then
4547	<	CPP=
4548	<	fi
4549	<	if test -z "$CPP"; then
4550	<	if test "${ac_cv_prog_CPP+set}" = set; then
5580	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5581	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5582	>	if test "${ac_cv_header_stdc+set}" = set; then
5583		echo $ECHO_N "(cached) $ECHO_C" >&6
5584		else
4553	–	# Double quotes because CPP needs to be expanded
4554	–	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4555	–	do
4556	–	ac_preproc_ok=false
4557	–	for ac_c_preproc_warn_flag in '' yes
4558	–	do
4559	–	# Use a header file that comes with gcc, so configuring glibc
4560	–	# with a fresh cross-compiler works.
4561	–	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4562	–	# <limits.h> exists even on freestanding compilers.
4563	–	# On the NeXT, cc -E runs the code through the compiler's parser,
4564	–	# not just through cpp. "Syntax error" is here to catch this case.
5585		cat >conftest.$ac_ext <<_ACEOF
5586		/* confdefs.h.  */
5587		_ACEOF
5588		cat confdefs.h >>conftest.$ac_ext
5589		cat >>conftest.$ac_ext <<_ACEOF
5590		/* end confdefs.h.  */
5591	<	#ifdef __STDC__
5592	<	# include <limits.h>
5593	<	#else
5594	<	# include <assert.h>
5591	>	#include <stdlib.h>
5592	>	#include <stdarg.h>
5593	>	#include <string.h>
5594	>	#include <float.h>
5595	>
5596	>	#ifdef FC_DUMMY_MAIN
5597	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5598	>	#  ifdef __cplusplus
5599	>	extern "C"
5600	>	#  endif
5601	>	int FC_DUMMY_MAIN() { return 1; }
5602		#endif
5603	<	Syntax error
5603	>	#endif
5604	>	int
5605	>	main ()
5606	>	{
5607	>
5608	>	;
5609	>	return 0;
5610	>	}
5611		_ACEOF
5612	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5613	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5612	>	rm -f conftest.$ac_objext
5613	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5614	>	(eval $ac_compile) 2>conftest.er1
5615		ac_status=$?
5616		grep -v '^ *+' conftest.er1 >conftest.err
5617		rm -f conftest.er1
5618		cat conftest.err >&5
5619		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5620	<	(exit $ac_status); } >/dev/null; then
5621	<	if test -s conftest.err; then
5622	<	ac_cpp_err=$ac_c_preproc_warn_flag
5623	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5624	<	else
5625	<	ac_cpp_err=
5626	<	fi
5620	>	(exit $ac_status); } &&
5621	>	{ ac_try='test -z "$ac_c_werror_flag"
5622	>	|| test ! -s conftest.err'
5623	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5624	>	(eval $ac_try) 2>&5
5625	>	ac_status=$?
5626	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5627	>	(exit $ac_status); }; } &&
5628	>	{ ac_try='test -s conftest.$ac_objext'
5629	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5630	>	(eval $ac_try) 2>&5
5631	>	ac_status=$?
5632	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5633	>	(exit $ac_status); }; }; then
5634	>	ac_cv_header_stdc=yes
5635		else
4593	–	ac_cpp_err=yes
4594	–	fi
4595	–	if test -z "$ac_cpp_err"; then
4596	–	:
4597	–	else
5636		echo "$as_me: failed program was:" >&5
5637		sed 's/^/| /' conftest.$ac_ext >&5
5638
5639	<	# Broken: fails on valid input.
4602	<	continue
5639	>	ac_cv_header_stdc=no
5640		fi
5641	<	rm -f conftest.err conftest.$ac_ext
5641	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5642
5643	<	# OK, works on sane cases.  Now check whether non-existent headers
5644	<	# can be detected and how.
5643	>	if test $ac_cv_header_stdc = yes; then
5644	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5645		cat >conftest.$ac_ext <<_ACEOF
5646		/* confdefs.h.  */
5647		_ACEOF
5648		cat confdefs.h >>conftest.$ac_ext
5649		cat >>conftest.$ac_ext <<_ACEOF
5650		/* end confdefs.h.  */
5651	<	#include <ac_nonexistent.h>
5651	>	#include <string.h>
5652	>
5653		_ACEOF
5654	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5655	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5656	<	ac_status=$?
4619	<	grep -v '^ *+' conftest.er1 >conftest.err
4620	<	rm -f conftest.er1
4621	<	cat conftest.err >&5
4622	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4623	<	(exit $ac_status); } >/dev/null; then
4624	<	if test -s conftest.err; then
4625	<	ac_cpp_err=$ac_c_preproc_warn_flag
4626	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4627	<	else
4628	<	ac_cpp_err=
4629	<	fi
5654	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5655	>	$EGREP "memchr" >/dev/null 2>&1; then
5656	>	:
5657		else
5658	<	ac_cpp_err=yes
5658	>	ac_cv_header_stdc=no
5659		fi
5660	<	if test -z "$ac_cpp_err"; then
4634	<	# Broken: success on invalid input.
4635	<	continue
4636	<	else
4637	<	echo "$as_me: failed program was:" >&5
4638	<	sed 's/^/| /' conftest.$ac_ext >&5
5660	>	rm -f conftest*
5661
4640	–	# Passes both tests.
4641	–	ac_preproc_ok=:
4642	–	break
5662		fi
4644	–	rm -f conftest.err conftest.$ac_ext
5663
5664	<	done
5665	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5666	<	rm -f conftest.err conftest.$ac_ext
5667	<	if $ac_preproc_ok; then
5668	<	break
5664	>	if test $ac_cv_header_stdc = yes; then
5665	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5666	>	cat >conftest.$ac_ext <<_ACEOF
5667	>	/* confdefs.h.  */
5668	>	_ACEOF
5669	>	cat confdefs.h >>conftest.$ac_ext
5670	>	cat >>conftest.$ac_ext <<_ACEOF
5671	>	/* end confdefs.h.  */
5672	>	#include <stdlib.h>
5673	>
5674	>	_ACEOF
5675	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5676	>	$EGREP "free" >/dev/null 2>&1; then
5677	>	:
5678	>	else
5679	>	ac_cv_header_stdc=no
5680		fi
5681	+	rm -f conftest*
5682
4653	–	done
4654	–	ac_cv_prog_CPP=$CPP
4655	–
5683		fi
5684	<	CPP=$ac_cv_prog_CPP
5684	>
5685	>	if test $ac_cv_header_stdc = yes; then
5686	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5687	>	if test "$cross_compiling" = yes; then
5688	>	:
5689		else
4659	–	ac_cv_prog_CPP=$CPP
4660	–	fi
4661	–	echo "$as_me:$LINENO: result: $CPP" >&5
4662	–	echo "${ECHO_T}$CPP" >&6
4663	–	ac_preproc_ok=false
4664	–	for ac_c_preproc_warn_flag in '' yes
4665	–	do
4666	–	# Use a header file that comes with gcc, so configuring glibc
4667	–	# with a fresh cross-compiler works.
4668	–	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4669	–	# <limits.h> exists even on freestanding compilers.
4670	–	# On the NeXT, cc -E runs the code through the compiler's parser,
4671	–	# not just through cpp. "Syntax error" is here to catch this case.
5690		cat >conftest.$ac_ext <<_ACEOF
5691		/* confdefs.h.  */
5692		_ACEOF
5693		cat confdefs.h >>conftest.$ac_ext
5694		cat >>conftest.$ac_ext <<_ACEOF
5695		/* end confdefs.h.  */
5696	<	#ifdef __STDC__
5697	<	# include <limits.h>
5696	>	#include <ctype.h>
5697	>	#if ((' ' & 0x0FF) == 0x020)
5698	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5699	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5700		#else
5701	<	# include <assert.h>
5701	>	# define ISLOWER(c) \
5702	>	(('a' <= (c) && (c) <= 'i') \
5703	>	|| ('j' <= (c) && (c) <= 'r') \
5704	>	|| ('s' <= (c) && (c) <= 'z'))
5705	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5706		#endif
5707	<	Syntax error
5707	>
5708	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5709	>	int
5710	>	main ()
5711	>	{
5712	>	int i;
5713	>	for (i = 0; i < 256; i++)
5714	>	if (XOR (islower (i), ISLOWER (i))
5715	>	|| toupper (i) != TOUPPER (i))
5716	>	exit(2);
5717	>	exit (0);
5718	>	}
5719		_ACEOF
5720	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5721	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5720	>	rm -f conftest$ac_exeext
5721	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5722	>	(eval $ac_link) 2>&5
5723		ac_status=$?
4688	–	grep -v '^ *+' conftest.er1 >conftest.err
4689	–	rm -f conftest.er1
4690	–	cat conftest.err >&5
5724		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725	<	(exit $ac_status); } >/dev/null; then
5726	<	if test -s conftest.err; then
5727	<	ac_cpp_err=$ac_c_preproc_warn_flag
5728	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5729	<	else
5730	<	ac_cpp_err=
4698	<	fi
4699	<	else
4700	<	ac_cpp_err=yes
4701	<	fi
4702	<	if test -z "$ac_cpp_err"; then
5725	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5726	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5727	>	(eval $ac_try) 2>&5
5728	>	ac_status=$?
5729	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5730	>	(exit $ac_status); }; }; then
5731		:
5732		else
5733	<	echo "$as_me: failed program was:" >&5
5733	>	echo "$as_me: program exited with status $ac_status" >&5
5734	>	echo "$as_me: failed program was:" >&5
5735		sed 's/^/| /' conftest.$ac_ext >&5
5736
5737	<	# Broken: fails on valid input.
5738	<	continue
5737	>	( exit $ac_status )
5738	>	ac_cv_header_stdc=no
5739		fi
5740	<	rm -f conftest.err conftest.$ac_ext
5740	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5741	>	fi
5742	>	fi
5743	>	fi
5744	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5745	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
5746	>	if test $ac_cv_header_stdc = yes; then
5747
5748	<	# OK, works on sane cases.  Now check whether non-existent headers
5749	<	# can be detected and how.
5748	>	cat >>confdefs.h <<\_ACEOF
5749	>	#define STDC_HEADERS 1
5750	>	_ACEOF
5751	>
5752	>	fi
5753	>
5754	>	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
5755	>
5756	>
5757	>
5758	>
5759	>
5760	>
5761	>
5762	>
5763	>
5764	>	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5765	>	inttypes.h stdint.h unistd.h
5766	>	do
5767	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5768	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
5769	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5770	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5771	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5772	>	else
5773		cat >conftest.$ac_ext <<_ACEOF
5774		/* confdefs.h.  */
5775		_ACEOF
5776		cat confdefs.h >>conftest.$ac_ext
5777		cat >>conftest.$ac_ext <<_ACEOF
5778		/* end confdefs.h.  */
5779	<	#include <ac_nonexistent.h>
5779	>	$ac_includes_default
5780	>
5781	>	#include <$ac_header>
5782		_ACEOF
5783	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5784	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5783	>	rm -f conftest.$ac_objext
5784	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5785	>	(eval $ac_compile) 2>conftest.er1
5786		ac_status=$?
5787		grep -v '^ *+' conftest.er1 >conftest.err
5788		rm -f conftest.er1
5789		cat conftest.err >&5
5790		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5791	<	(exit $ac_status); } >/dev/null; then
5792	<	if test -s conftest.err; then
5793	<	ac_cpp_err=$ac_c_preproc_warn_flag
5794	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5795	<	else
5796	<	ac_cpp_err=
5797	<	fi
5791	>	(exit $ac_status); } &&
5792	>	{ ac_try='test -z "$ac_c_werror_flag"
5793	>	|| test ! -s conftest.err'
5794	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5795	>	(eval $ac_try) 2>&5
5796	>	ac_status=$?
5797	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5798	>	(exit $ac_status); }; } &&
5799	>	{ ac_try='test -s conftest.$ac_objext'
5800	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5801	>	(eval $ac_try) 2>&5
5802	>	ac_status=$?
5803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5804	>	(exit $ac_status); }; }; then
5805	>	eval "$as_ac_Header=yes"
5806		else
4738	–	ac_cpp_err=yes
4739	–	fi
4740	–	if test -z "$ac_cpp_err"; then
4741	–	# Broken: success on invalid input.
4742	–	continue
4743	–	else
5807		echo "$as_me: failed program was:" >&5
5808		sed 's/^/| /' conftest.$ac_ext >&5
5809
5810	<	# Passes both tests.
4748	<	ac_preproc_ok=:
4749	<	break
5810	>	eval "$as_ac_Header=no"
5811		fi
5812	<	rm -f conftest.err conftest.$ac_ext
5812	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5813	>	fi
5814	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5815	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5816	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5817	>	cat >>confdefs.h <<_ACEOF
5818	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5819	>	_ACEOF
5820
4753	–	done
4754	–	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4755	–	rm -f conftest.err conftest.$ac_ext
4756	–	if $ac_preproc_ok; then
4757	–	:
4758	–	else
4759	–	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4760	–	See \`config.log' for more details." >&5
4761	–	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4762	–	See \`config.log' for more details." >&2;}
4763	–	{ (exit 1); exit 1; }; }
5821		fi
5822
5823	<	ac_ext=c
4767	<	ac_cpp='$CPP $CPPFLAGS'
4768	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4769	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4770	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5823	>	done
5824
5825
5826	<	echo "$as_me:$LINENO: checking for egrep" >&5
5827	<	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5828	<	if test "${ac_cv_prog_egrep+set}" = set; then
5829	<	echo $ECHO_N "(cached) $ECHO_C" >&6
5830	<	else
5831	<	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5832	<	then ac_cv_prog_egrep='grep -E'
5833	<	else ac_cv_prog_egrep='egrep'
5834	<	fi
5835	<	fi
5836	<	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5837	<	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5838	<	EGREP=$ac_cv_prog_egrep
5826	>	#
5827	>	# Handle user hints
5828	>	#
5829	>
5830	>	# Check whether --with-zlib or --without-zlib was given.
5831	>	if test "${with_zlib+set}" = set; then
5832	>	withval="$with_zlib"
5833	>	zlib_dir="$withval"
5834	>	else
5835	>	zlib_dir="not_set"
5836	>	fi;
5837	>	if test "$zlib_dir" != "no"; then
5838	>
5839	>	if test "$zlib_dir" != "not_set" ; then
5840	>	if test -d "$zlib_dir"
5841	>	then
5842	>	ZLIB_HOME="$zlib_dir"
5843	>	else
5844	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5845	>	echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5846	>	fi
5847	>	fi
5848	>
5849	>	ZLIB_HOME=/usr/local
5850	>	if test ! -f "${ZLIB_HOME}/include/zlib.h"
5851	>	then
5852	>	ZLIB_HOME=/usr
5853	>	fi
5854	>
5855	>	#
5856	>	# Locate zlib, if wanted
5857	>	#
5858	>	if test -n "${ZLIB_HOME}"
5859	>	then
5860	>	ZLIB_OLD_LDFLAGS=$LDFLAGS
5861	>	ZLIB_OLD_CPPFLAGS=$LDFLAGS
5862	>	LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5863	>	CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5864	>
5865	>
5866	>	ac_ext=c
5867	>	ac_cpp='$CPP $CPPFLAGS'
5868	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5869	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5870	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5871	>
5872	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5873	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5874	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5875	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5876	>	else
5877	>	ac_check_lib_save_LIBS=$LIBS
5878	>	LIBS="-lz  $LIBS"
5879	>	cat >conftest.$ac_ext <<_ACEOF
5880	>	/* confdefs.h.  */
5881	>	_ACEOF
5882	>	cat confdefs.h >>conftest.$ac_ext
5883	>	cat >>conftest.$ac_ext <<_ACEOF
5884	>	/* end confdefs.h.  */
5885	>
5886	>	/* Override any gcc2 internal prototype to avoid an error.  */
5887	>	#ifdef __cplusplus
5888	>	extern "C"
5889	>	#endif
5890	>	/* We use char because int might match the return type of a gcc2
5891	>	builtin and then its argument prototype would still apply.  */
5892	>	char inflateEnd ();
5893	>	#ifdef FC_DUMMY_MAIN
5894	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5895	>	#  ifdef __cplusplus
5896	>	extern "C"
5897	>	#  endif
5898	>	int FC_DUMMY_MAIN() { return 1; }
5899	>	#endif
5900	>	#endif
5901	>	int
5902	>	main ()
5903	>	{
5904	>	inflateEnd ();
5905	>	;
5906	>	return 0;
5907	>	}
5908	>	_ACEOF
5909	>	rm -f conftest.$ac_objext conftest$ac_exeext
5910	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5911	>	(eval $ac_link) 2>conftest.er1
5912	>	ac_status=$?
5913	>	grep -v '^ *+' conftest.er1 >conftest.err
5914	>	rm -f conftest.er1
5915	>	cat conftest.err >&5
5916	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5917	>	(exit $ac_status); } &&
5918	>	{ ac_try='test -z "$ac_c_werror_flag"
5919	>	|| test ! -s conftest.err'
5920	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5921	>	(eval $ac_try) 2>&5
5922	>	ac_status=$?
5923	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5924	>	(exit $ac_status); }; } &&
5925	>	{ ac_try='test -s conftest$ac_exeext'
5926	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5927	>	(eval $ac_try) 2>&5
5928	>	ac_status=$?
5929	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5930	>	(exit $ac_status); }; }; then
5931	>	ac_cv_lib_z_inflateEnd=yes
5932	>	else
5933	>	echo "$as_me: failed program was:" >&5
5934	>	sed 's/^/| /' conftest.$ac_ext >&5
5935	>
5936	>	ac_cv_lib_z_inflateEnd=no
5937	>	fi
5938	>	rm -f conftest.err conftest.$ac_objext \
5939	>	conftest$ac_exeext conftest.$ac_ext
5940	>	LIBS=$ac_check_lib_save_LIBS
5941	>	fi
5942	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5943	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5944	>	if test $ac_cv_lib_z_inflateEnd = yes; then
5945	>	zlib_cv_libz=yes
5946	>	else
5947	>	zlib_cv_libz=no
5948	>	fi
5949	>
5950	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5951	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
5952	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5953	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5954	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5955	>	fi
5956	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5957	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5958	>	else
5959	>	# Is the header compilable?
5960	>	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5961	>	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5962	>	cat >conftest.$ac_ext <<_ACEOF
5963	>	/* confdefs.h.  */
5964	>	_ACEOF
5965	>	cat confdefs.h >>conftest.$ac_ext
5966	>	cat >>conftest.$ac_ext <<_ACEOF
5967	>	/* end confdefs.h.  */
5968	>	$ac_includes_default
5969	>	#include <zlib.h>
5970	>	_ACEOF
5971	>	rm -f conftest.$ac_objext
5972	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5973	>	(eval $ac_compile) 2>conftest.er1
5974	>	ac_status=$?
5975	>	grep -v '^ *+' conftest.er1 >conftest.err
5976	>	rm -f conftest.er1
5977	>	cat conftest.err >&5
5978	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5979	>	(exit $ac_status); } &&
5980	>	{ ac_try='test -z "$ac_c_werror_flag"
5981	>	|| test ! -s conftest.err'
5982	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5983	>	(eval $ac_try) 2>&5
5984	>	ac_status=$?
5985	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5986	>	(exit $ac_status); }; } &&
5987	>	{ ac_try='test -s conftest.$ac_objext'
5988	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5989	>	(eval $ac_try) 2>&5
5990	>	ac_status=$?
5991	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5992	>	(exit $ac_status); }; }; then
5993	>	ac_header_compiler=yes
5994	>	else
5995	>	echo "$as_me: failed program was:" >&5
5996	>	sed 's/^/| /' conftest.$ac_ext >&5
5997	>
5998	>	ac_header_compiler=no
5999	>	fi
6000	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6001	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6002	>	echo "${ECHO_T}$ac_header_compiler" >&6
6003	>
6004	>	# Is the header present?
6005	>	echo "$as_me:$LINENO: checking zlib.h presence" >&5
6006	>	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6007	>	cat >conftest.$ac_ext <<_ACEOF
6008	>	/* confdefs.h.  */
6009	>	_ACEOF
6010	>	cat confdefs.h >>conftest.$ac_ext
6011	>	cat >>conftest.$ac_ext <<_ACEOF
6012	>	/* end confdefs.h.  */
6013	>	#include <zlib.h>
6014	>	_ACEOF
6015	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6016	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6017	>	ac_status=$?
6018	>	grep -v '^ *+' conftest.er1 >conftest.err
6019	>	rm -f conftest.er1
6020	>	cat conftest.err >&5
6021	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6022	>	(exit $ac_status); } >/dev/null; then
6023	>	if test -s conftest.err; then
6024	>	ac_cpp_err=$ac_c_preproc_warn_flag
6025	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6026	>	else
6027	>	ac_cpp_err=
6028	>	fi
6029	>	else
6030	>	ac_cpp_err=yes
6031	>	fi
6032	>	if test -z "$ac_cpp_err"; then
6033	>	ac_header_preproc=yes
6034	>	else
6035	>	echo "$as_me: failed program was:" >&5
6036	>	sed 's/^/| /' conftest.$ac_ext >&5
6037	>
6038	>	ac_header_preproc=no
6039	>	fi
6040	>	rm -f conftest.err conftest.$ac_ext
6041	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6042	>	echo "${ECHO_T}$ac_header_preproc" >&6
6043	>
6044	>	# So?  What about this header?
6045	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6046	>	yes:no: )
6047	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6048	>	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6049	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6050	>	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6051	>	ac_header_preproc=yes
6052	>	;;
6053	>	no:yes:* )
6054	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6055	>	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6056	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6057	>	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6058	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6059	>	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6060	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6061	>	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6062	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6063	>	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6064	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6065	>	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6066	>	(
6067	>	cat <<\_ASBOX
6068	>	## ------------------------------ ##
6069	>	## Report this to gezelter@nd.edu ##
6070	>	## ------------------------------ ##
6071	>	_ASBOX
6072	>	) |
6073	>	sed "s/^/$as_me: WARNING:     /" >&2
6074	>	;;
6075	>	esac
6076	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6077	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6078	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6079	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6080	>	else
6081	>	ac_cv_header_zlib_h=$ac_header_preproc
6082	>	fi
6083	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6084	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6085	>
6086	>	fi
6087	>	if test $ac_cv_header_zlib_h = yes; then
6088	>	zlib_cv_zlib_h=yes
6089	>	else
6090	>	zlib_cv_zlib_h=no
6091	>	fi
6092	>
6093	>
6094	>	ac_ext=c
6095	>	ac_cpp='$CPP $CPPFLAGS'
6096	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6097	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6098	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6099	>
6100	>
6101	>	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6102	>
6103	>	cat >>confdefs.h <<\_ACEOF
6104	>	#define HAVE_ZLIB_H 1
6105	>	_ACEOF
6106	>
6107	>
6108	>	cat >>confdefs.h <<\_ACEOF
6109	>	#define HAVE_LIBZ 1
6110	>	_ACEOF
6111	>
6112	>	ZLIB_INC_DIR="${ZLIB_HOME}/include"
6113	>	ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6114	>	ZLIB="-lz"
6115	>	else
6116	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6117	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6118	>	ZLIB_INC_DIR=
6119	>	ZLIB_LIB_DIR=
6120	>	ZLIB=
6121	>	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6122	>	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6123	>	echo "$as_me:$LINENO: result: failed" >&5
6124	>	echo "${ECHO_T}failed" >&6
6125	>	echo ""
6126	>	echo "*********************************************************"
6127	>	echo "* WARNING: Could not find a working zlib installation   *"
6128	>	echo "* If you need OOPSE to be able to deal with compressed  *"
6129	>	echo "* trajectory dump files be sure to specify a valid zlib *"
6130	>	echo "* installation with --with-zlib=DIR                     *"
6131	>	echo "*                                                       *"
6132	>	echo "* OOPSE will still work without zlib installed.         *"
6133	>	echo "*********************************************************"
6134	>	echo ""
6135	>	fi
6136	>
6137	>
6138	>
6139	>	fi
6140	>	fi
6141	>
6142	>	#
6143	>	# Handle user hints
6144	>	#
6145	>
6146	>	# Check whether --with-fftw or --without-fftw was given.
6147	>	if test "${with_fftw+set}" = set; then
6148	>	withval="$with_fftw"
6149	>	fftw_dir="$withval"
6150	>	else
6151	>	fftw_dir="not_set"
6152	>	fi;
6153	>	if test "$fftw_dir" != "no"; then
6154	>	if test "$fftw_dir" != "not_set" ; then
6155	>	if test -d "$fftw_dir"; then
6156	>	FFTW_HOME="$fftw_dir"
6157	>	else
6158	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6159	>	echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6160	>	FFTW_HOME=/usr/local
6161	>	if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6162	>	FFTW_HOME=/usr
6163	>	fi
6164	>	fi
6165	>	#
6166	>	# Locate fftw, if wanted
6167	>	#
6168	>	if test -n "${FFTW_HOME}"; then
6169	>	FFTW_OLD_LDFLAGS=$LDFLAGS
6170	>	FFTW_OLD_CPPFLAGS=$LDFLAGS
6171	>	LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6172	>	CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6173	>
6174	>
6175	>	ac_ext=c
6176	>	ac_cpp='$CPP $CPPFLAGS'
6177	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6178	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6179	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6180	>
6181	>	echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6182	>	echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6183	>	if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6184	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6185	>	else
6186	>	ac_check_lib_save_LIBS=$LIBS
6187	>	LIBS="-lfftw3  $LIBS"
6188	>	cat >conftest.$ac_ext <<_ACEOF
6189	>	/* confdefs.h.  */
6190	>	_ACEOF
6191	>	cat confdefs.h >>conftest.$ac_ext
6192	>	cat >>conftest.$ac_ext <<_ACEOF
6193	>	/* end confdefs.h.  */
6194	>
6195	>	/* Override any gcc2 internal prototype to avoid an error.  */
6196	>	#ifdef __cplusplus
6197	>	extern "C"
6198	>	#endif
6199	>	/* We use char because int might match the return type of a gcc2
6200	>	builtin and then its argument prototype would still apply.  */
6201	>	char fftw_execute ();
6202	>	#ifdef FC_DUMMY_MAIN
6203	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6204	>	#  ifdef __cplusplus
6205	>	extern "C"
6206	>	#  endif
6207	>	int FC_DUMMY_MAIN() { return 1; }
6208	>	#endif
6209	>	#endif
6210	>	int
6211	>	main ()
6212	>	{
6213	>	fftw_execute ();
6214	>	;
6215	>	return 0;
6216	>	}
6217	>	_ACEOF
6218	>	rm -f conftest.$ac_objext conftest$ac_exeext
6219	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6220	>	(eval $ac_link) 2>conftest.er1
6221	>	ac_status=$?
6222	>	grep -v '^ *+' conftest.er1 >conftest.err
6223	>	rm -f conftest.er1
6224	>	cat conftest.err >&5
6225	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6226	>	(exit $ac_status); } &&
6227	>	{ ac_try='test -z "$ac_c_werror_flag"
6228	>	|| test ! -s conftest.err'
6229	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6230	>	(eval $ac_try) 2>&5
6231	>	ac_status=$?
6232	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6233	>	(exit $ac_status); }; } &&
6234	>	{ ac_try='test -s conftest$ac_exeext'
6235	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6236	>	(eval $ac_try) 2>&5
6237	>	ac_status=$?
6238	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6239	>	(exit $ac_status); }; }; then
6240	>	ac_cv_lib_fftw3_fftw_execute=yes
6241	>	else
6242	>	echo "$as_me: failed program was:" >&5
6243	>	sed 's/^/| /' conftest.$ac_ext >&5
6244	>
6245	>	ac_cv_lib_fftw3_fftw_execute=no
6246	>	fi
6247	>	rm -f conftest.err conftest.$ac_objext \
6248	>	conftest$ac_exeext conftest.$ac_ext
6249	>	LIBS=$ac_check_lib_save_LIBS
6250	>	fi
6251	>	echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6252	>	echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6253	>	if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6254	>	fftw_cv_libfftw3=yes
6255	>	else
6256	>	fftw_cv_libfftw3=no
6257	>	fi
6258	>
6259	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6260	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6261	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6262	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6263	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6264	>	fi
6265	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6266	>	echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6267	>	else
6268	>	# Is the header compilable?
6269	>	echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6270	>	echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6271	>	cat >conftest.$ac_ext <<_ACEOF
6272	>	/* confdefs.h.  */
6273	>	_ACEOF
6274	>	cat confdefs.h >>conftest.$ac_ext
6275	>	cat >>conftest.$ac_ext <<_ACEOF
6276	>	/* end confdefs.h.  */
6277	>	$ac_includes_default
6278	>	#include <fftw3.h>
6279	>	_ACEOF
6280	>	rm -f conftest.$ac_objext
6281	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6282	>	(eval $ac_compile) 2>conftest.er1
6283	>	ac_status=$?
6284	>	grep -v '^ *+' conftest.er1 >conftest.err
6285	>	rm -f conftest.er1
6286	>	cat conftest.err >&5
6287	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6288	>	(exit $ac_status); } &&
6289	>	{ ac_try='test -z "$ac_c_werror_flag"
6290	>	|| test ! -s conftest.err'
6291	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6292	>	(eval $ac_try) 2>&5
6293	>	ac_status=$?
6294	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6295	>	(exit $ac_status); }; } &&
6296	>	{ ac_try='test -s conftest.$ac_objext'
6297	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6298	>	(eval $ac_try) 2>&5
6299	>	ac_status=$?
6300	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6301	>	(exit $ac_status); }; }; then
6302	>	ac_header_compiler=yes
6303	>	else
6304	>	echo "$as_me: failed program was:" >&5
6305	>	sed 's/^/| /' conftest.$ac_ext >&5
6306	>
6307	>	ac_header_compiler=no
6308	>	fi
6309	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6310	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6311	>	echo "${ECHO_T}$ac_header_compiler" >&6
6312	>
6313	>	# Is the header present?
6314	>	echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6315	>	echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6316	>	cat >conftest.$ac_ext <<_ACEOF
6317	>	/* confdefs.h.  */
6318	>	_ACEOF
6319	>	cat confdefs.h >>conftest.$ac_ext
6320	>	cat >>conftest.$ac_ext <<_ACEOF
6321	>	/* end confdefs.h.  */
6322	>	#include <fftw3.h>
6323	>	_ACEOF
6324	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6325	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6326	>	ac_status=$?
6327	>	grep -v '^ *+' conftest.er1 >conftest.err
6328	>	rm -f conftest.er1
6329	>	cat conftest.err >&5
6330	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6331	>	(exit $ac_status); } >/dev/null; then
6332	>	if test -s conftest.err; then
6333	>	ac_cpp_err=$ac_c_preproc_warn_flag
6334	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6335	>	else
6336	>	ac_cpp_err=
6337	>	fi
6338	>	else
6339	>	ac_cpp_err=yes
6340	>	fi
6341	>	if test -z "$ac_cpp_err"; then
6342	>	ac_header_preproc=yes
6343	>	else
6344	>	echo "$as_me: failed program was:" >&5
6345	>	sed 's/^/| /' conftest.$ac_ext >&5
6346	>
6347	>	ac_header_preproc=no
6348	>	fi
6349	>	rm -f conftest.err conftest.$ac_ext
6350	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6351	>	echo "${ECHO_T}$ac_header_preproc" >&6
6352	>
6353	>	# So?  What about this header?
6354	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6355	>	yes:no: )
6356	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6357	>	echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6358	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6359	>	echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6360	>	ac_header_preproc=yes
6361	>	;;
6362	>	no:yes:* )
6363	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6364	>	echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6365	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6366	>	echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6367	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6368	>	echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6369	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6370	>	echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6371	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6372	>	echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6373	>	{ echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6374	>	echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6375	>	(
6376	>	cat <<\_ASBOX
6377	>	## ------------------------------ ##
6378	>	## Report this to gezelter@nd.edu ##
6379	>	## ------------------------------ ##
6380	>	_ASBOX
6381	>	) |
6382	>	sed "s/^/$as_me: WARNING:     /" >&2
6383	>	;;
6384	>	esac
6385	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6386	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6387	>	if test "${ac_cv_header_fftw3_h+set}" = set; then
6388	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6389	>	else
6390	>	ac_cv_header_fftw3_h=$ac_header_preproc
6391	>	fi
6392	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6393	>	echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6394	>
6395	>	fi
6396	>	if test $ac_cv_header_fftw3_h = yes; then
6397	>	fftw_cv_fftw3_h=yes
6398	>	else
6399	>	fftw_cv_fftw3_h=no
6400	>	fi
6401	>
6402	>
6403	>	if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6404	>	echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6405	>	echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6406	>	if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6407	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6408	>	else
6409	>	ac_check_lib_save_LIBS=$LIBS
6410	>	LIBS="-lfftw  $LIBS"
6411	>	cat >conftest.$ac_ext <<_ACEOF
6412	>	/* confdefs.h.  */
6413	>	_ACEOF
6414	>	cat confdefs.h >>conftest.$ac_ext
6415	>	cat >>conftest.$ac_ext <<_ACEOF
6416	>	/* end confdefs.h.  */
6417	>
6418	>	/* Override any gcc2 internal prototype to avoid an error.  */
6419	>	#ifdef __cplusplus
6420	>	extern "C"
6421	>	#endif
6422	>	/* We use char because int might match the return type of a gcc2
6423	>	builtin and then its argument prototype would still apply.  */
6424	>	char fftwnd_one ();
6425	>	#ifdef FC_DUMMY_MAIN
6426	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6427	>	#  ifdef __cplusplus
6428	>	extern "C"
6429	>	#  endif
6430	>	int FC_DUMMY_MAIN() { return 1; }
6431	>	#endif
6432	>	#endif
6433	>	int
6434	>	main ()
6435	>	{
6436	>	fftwnd_one ();
6437	>	;
6438	>	return 0;
6439	>	}
6440	>	_ACEOF
6441	>	rm -f conftest.$ac_objext conftest$ac_exeext
6442	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6443	>	(eval $ac_link) 2>conftest.er1
6444	>	ac_status=$?
6445	>	grep -v '^ *+' conftest.er1 >conftest.err
6446	>	rm -f conftest.er1
6447	>	cat conftest.err >&5
6448	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6449	>	(exit $ac_status); } &&
6450	>	{ ac_try='test -z "$ac_c_werror_flag"
6451	>	|| test ! -s conftest.err'
6452	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6453	>	(eval $ac_try) 2>&5
6454	>	ac_status=$?
6455	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6456	>	(exit $ac_status); }; } &&
6457	>	{ ac_try='test -s conftest$ac_exeext'
6458	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6459	>	(eval $ac_try) 2>&5
6460	>	ac_status=$?
6461	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6462	>	(exit $ac_status); }; }; then
6463	>	ac_cv_lib_fftw_fftwnd_one=yes
6464	>	else
6465	>	echo "$as_me: failed program was:" >&5
6466	>	sed 's/^/| /' conftest.$ac_ext >&5
6467	>
6468	>	ac_cv_lib_fftw_fftwnd_one=no
6469	>	fi
6470	>	rm -f conftest.err conftest.$ac_objext \
6471	>	conftest$ac_exeext conftest.$ac_ext
6472	>	LIBS=$ac_check_lib_save_LIBS
6473	>	fi
6474	>	echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6475	>	echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6476	>	if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6477	>	fftw_cv_libfftw=yes
6478	>	else
6479	>	fftw_cv_libfftw=no
6480	>	fi
6481	>
6482	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6483	>	echo "$as_me:$LINENO: checking for fftw.h" >&5
6484	>	echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6485	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6486	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6487	>	fi
6488	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6489	>	echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6490	>	else
6491	>	# Is the header compilable?
6492	>	echo "$as_me:$LINENO: checking fftw.h usability" >&5
6493	>	echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6494	>	cat >conftest.$ac_ext <<_ACEOF
6495	>	/* confdefs.h.  */
6496	>	_ACEOF
6497	>	cat confdefs.h >>conftest.$ac_ext
6498	>	cat >>conftest.$ac_ext <<_ACEOF
6499	>	/* end confdefs.h.  */
6500	>	$ac_includes_default
6501	>	#include <fftw.h>
6502	>	_ACEOF
6503	>	rm -f conftest.$ac_objext
6504	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6505	>	(eval $ac_compile) 2>conftest.er1
6506	>	ac_status=$?
6507	>	grep -v '^ *+' conftest.er1 >conftest.err
6508	>	rm -f conftest.er1
6509	>	cat conftest.err >&5
6510	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6511	>	(exit $ac_status); } &&
6512	>	{ ac_try='test -z "$ac_c_werror_flag"
6513	>	|| test ! -s conftest.err'
6514	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6515	>	(eval $ac_try) 2>&5
6516	>	ac_status=$?
6517	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6518	>	(exit $ac_status); }; } &&
6519	>	{ ac_try='test -s conftest.$ac_objext'
6520	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6521	>	(eval $ac_try) 2>&5
6522	>	ac_status=$?
6523	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6524	>	(exit $ac_status); }; }; then
6525	>	ac_header_compiler=yes
6526	>	else
6527	>	echo "$as_me: failed program was:" >&5
6528	>	sed 's/^/| /' conftest.$ac_ext >&5
6529	>
6530	>	ac_header_compiler=no
6531	>	fi
6532	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6533	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6534	>	echo "${ECHO_T}$ac_header_compiler" >&6
6535	>
6536	>	# Is the header present?
6537	>	echo "$as_me:$LINENO: checking fftw.h presence" >&5
6538	>	echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6539	>	cat >conftest.$ac_ext <<_ACEOF
6540	>	/* confdefs.h.  */
6541	>	_ACEOF
6542	>	cat confdefs.h >>conftest.$ac_ext
6543	>	cat >>conftest.$ac_ext <<_ACEOF
6544	>	/* end confdefs.h.  */
6545	>	#include <fftw.h>
6546	>	_ACEOF
6547	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6548	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6549	>	ac_status=$?
6550	>	grep -v '^ *+' conftest.er1 >conftest.err
6551	>	rm -f conftest.er1
6552	>	cat conftest.err >&5
6553	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6554	>	(exit $ac_status); } >/dev/null; then
6555	>	if test -s conftest.err; then
6556	>	ac_cpp_err=$ac_c_preproc_warn_flag
6557	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6558	>	else
6559	>	ac_cpp_err=
6560	>	fi
6561	>	else
6562	>	ac_cpp_err=yes
6563	>	fi
6564	>	if test -z "$ac_cpp_err"; then
6565	>	ac_header_preproc=yes
6566	>	else
6567	>	echo "$as_me: failed program was:" >&5
6568	>	sed 's/^/| /' conftest.$ac_ext >&5
6569	>
6570	>	ac_header_preproc=no
6571	>	fi
6572	>	rm -f conftest.err conftest.$ac_ext
6573	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6574	>	echo "${ECHO_T}$ac_header_preproc" >&6
6575	>
6576	>	# So?  What about this header?
6577	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6578	>	yes:no: )
6579	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6580	>	echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6581	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6582	>	echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6583	>	ac_header_preproc=yes
6584	>	;;
6585	>	no:yes:* )
6586	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6587	>	echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6588	>	{ echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6589	>	echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6590	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6591	>	echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6592	>	{ echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6593	>	echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6594	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6595	>	echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6596	>	{ echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6597	>	echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6598	>	(
6599	>	cat <<\_ASBOX
6600	>	## ------------------------------ ##
6601	>	## Report this to gezelter@nd.edu ##
6602	>	## ------------------------------ ##
6603	>	_ASBOX
6604	>	) |
6605	>	sed "s/^/$as_me: WARNING:     /" >&2
6606	>	;;
6607	>	esac
6608	>	echo "$as_me:$LINENO: checking for fftw.h" >&5
6609	>	echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6610	>	if test "${ac_cv_header_fftw_h+set}" = set; then
6611	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6612	>	else
6613	>	ac_cv_header_fftw_h=$ac_header_preproc
6614	>	fi
6615	>	echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6616	>	echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6617	>
6618	>	fi
6619	>	if test $ac_cv_header_fftw_h = yes; then
6620	>	fftw_cv_fftw_h=yes
6621	>	else
6622	>	fftw_cv_fftw_h=no
6623	>	fi
6624	>
6625	>
6626	>	if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6627	>	echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6628	>	echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6629	>	if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6630	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6631	>	else
6632	>	ac_check_lib_save_LIBS=$LIBS
6633	>	LIBS="-ldfftw  $LIBS"
6634	>	cat >conftest.$ac_ext <<_ACEOF
6635	>	/* confdefs.h.  */
6636	>	_ACEOF
6637	>	cat confdefs.h >>conftest.$ac_ext
6638	>	cat >>conftest.$ac_ext <<_ACEOF
6639	>	/* end confdefs.h.  */
6640	>
6641	>	/* Override any gcc2 internal prototype to avoid an error.  */
6642	>	#ifdef __cplusplus
6643	>	extern "C"
6644	>	#endif
6645	>	/* We use char because int might match the return type of a gcc2
6646	>	builtin and then its argument prototype would still apply.  */
6647	>	char fftwnd_one ();
6648	>	#ifdef FC_DUMMY_MAIN
6649	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6650	>	#  ifdef __cplusplus
6651	>	extern "C"
6652	>	#  endif
6653	>	int FC_DUMMY_MAIN() { return 1; }
6654	>	#endif
6655	>	#endif
6656	>	int
6657	>	main ()
6658	>	{
6659	>	fftwnd_one ();
6660	>	;
6661	>	return 0;
6662	>	}
6663	>	_ACEOF
6664	>	rm -f conftest.$ac_objext conftest$ac_exeext
6665	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6666	>	(eval $ac_link) 2>conftest.er1
6667	>	ac_status=$?
6668	>	grep -v '^ *+' conftest.er1 >conftest.err
6669	>	rm -f conftest.er1
6670	>	cat conftest.err >&5
6671	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6672	>	(exit $ac_status); } &&
6673	>	{ ac_try='test -z "$ac_c_werror_flag"
6674	>	|| test ! -s conftest.err'
6675	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6676	>	(eval $ac_try) 2>&5
6677	>	ac_status=$?
6678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6679	>	(exit $ac_status); }; } &&
6680	>	{ ac_try='test -s conftest$ac_exeext'
6681	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6682	>	(eval $ac_try) 2>&5
6683	>	ac_status=$?
6684	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6685	>	(exit $ac_status); }; }; then
6686	>	ac_cv_lib_dfftw_fftwnd_one=yes
6687	>	else
6688	>	echo "$as_me: failed program was:" >&5
6689	>	sed 's/^/| /' conftest.$ac_ext >&5
6690	>
6691	>	ac_cv_lib_dfftw_fftwnd_one=no
6692	>	fi
6693	>	rm -f conftest.err conftest.$ac_objext \
6694	>	conftest$ac_exeext conftest.$ac_ext
6695	>	LIBS=$ac_check_lib_save_LIBS
6696	>	fi
6697	>	echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6698	>	echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6699	>	if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6700	>	fftw_cv_libdfftw=yes
6701	>	else
6702	>	fftw_cv_libdfftw=no
6703	>	fi
6704	>
6705	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6706	>	echo "$as_me:$LINENO: checking for dfftw.h" >&5
6707	>	echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6708	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6709	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6710	>	fi
6711	>	echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6712	>	echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6713	>	else
6714	>	# Is the header compilable?
6715	>	echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6716	>	echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6717	>	cat >conftest.$ac_ext <<_ACEOF
6718	>	/* confdefs.h.  */
6719	>	_ACEOF
6720	>	cat confdefs.h >>conftest.$ac_ext
6721	>	cat >>conftest.$ac_ext <<_ACEOF
6722	>	/* end confdefs.h.  */
6723	>	$ac_includes_default
6724	>	#include <dfftw.h>
6725	>	_ACEOF
6726	>	rm -f conftest.$ac_objext
6727	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6728	>	(eval $ac_compile) 2>conftest.er1
6729	>	ac_status=$?
6730	>	grep -v '^ *+' conftest.er1 >conftest.err
6731	>	rm -f conftest.er1
6732	>	cat conftest.err >&5
6733	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6734	>	(exit $ac_status); } &&
6735	>	{ ac_try='test -z "$ac_c_werror_flag"
6736	>	|| test ! -s conftest.err'
6737	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6738	>	(eval $ac_try) 2>&5
6739	>	ac_status=$?
6740	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6741	>	(exit $ac_status); }; } &&
6742	>	{ ac_try='test -s conftest.$ac_objext'
6743	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6744	>	(eval $ac_try) 2>&5
6745	>	ac_status=$?
6746	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6747	>	(exit $ac_status); }; }; then
6748	>	ac_header_compiler=yes
6749	>	else
6750	>	echo "$as_me: failed program was:" >&5
6751	>	sed 's/^/| /' conftest.$ac_ext >&5
6752	>
6753	>	ac_header_compiler=no
6754	>	fi
6755	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6756	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6757	>	echo "${ECHO_T}$ac_header_compiler" >&6
6758	>
6759	>	# Is the header present?
6760	>	echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6761	>	echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6762	>	cat >conftest.$ac_ext <<_ACEOF
6763	>	/* confdefs.h.  */
6764	>	_ACEOF
6765	>	cat confdefs.h >>conftest.$ac_ext
6766	>	cat >>conftest.$ac_ext <<_ACEOF
6767	>	/* end confdefs.h.  */
6768	>	#include <dfftw.h>
6769	>	_ACEOF
6770	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6771	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6772	>	ac_status=$?
6773	>	grep -v '^ *+' conftest.er1 >conftest.err
6774	>	rm -f conftest.er1
6775	>	cat conftest.err >&5
6776	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6777	>	(exit $ac_status); } >/dev/null; then
6778	>	if test -s conftest.err; then
6779	>	ac_cpp_err=$ac_c_preproc_warn_flag
6780	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6781	>	else
6782	>	ac_cpp_err=
6783	>	fi
6784	>	else
6785	>	ac_cpp_err=yes
6786	>	fi
6787	>	if test -z "$ac_cpp_err"; then
6788	>	ac_header_preproc=yes
6789	>	else
6790	>	echo "$as_me: failed program was:" >&5
6791	>	sed 's/^/| /' conftest.$ac_ext >&5
6792	>
6793	>	ac_header_preproc=no
6794	>	fi
6795	>	rm -f conftest.err conftest.$ac_ext
6796	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6797	>	echo "${ECHO_T}$ac_header_preproc" >&6
6798	>
6799	>	# So?  What about this header?
6800	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6801	>	yes:no: )
6802	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6803	>	echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6804	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6805	>	echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6806	>	ac_header_preproc=yes
6807	>	;;
6808	>	no:yes:* )
6809	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6810	>	echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6811	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6812	>	echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6813	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6814	>	echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6815	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6816	>	echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6817	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6818	>	echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6819	>	{ echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6820	>	echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6821	>	(
6822	>	cat <<\_ASBOX
6823	>	## ------------------------------ ##
6824	>	## Report this to gezelter@nd.edu ##
6825	>	## ------------------------------ ##
6826	>	_ASBOX
6827	>	) |
6828	>	sed "s/^/$as_me: WARNING:     /" >&2
6829	>	;;
6830	>	esac
6831	>	echo "$as_me:$LINENO: checking for dfftw.h" >&5
6832	>	echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6833	>	if test "${ac_cv_header_dfftw_h+set}" = set; then
6834	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6835	>	else
6836	>	ac_cv_header_dfftw_h=$ac_header_preproc
6837	>	fi
6838	>	echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6839	>	echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6840	>
6841	>	fi
6842	>	if test $ac_cv_header_dfftw_h = yes; then
6843	>	fftw_cv_dfftw_h=yes
6844	>	else
6845	>	fftw_cv_dfftw_h=no
6846	>	fi
6847	>
6848	>
6849	>	fi
6850	>	fi
6851	>	ac_ext=c
6852	>	ac_cpp='$CPP $CPPFLAGS'
6853	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6854	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6855	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6856	>
6857	>	if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6858	>
6859	>	cat >>confdefs.h <<\_ACEOF
6860	>	#define HAVE_FFTW3_H 1
6861	>	_ACEOF
6862	>
6863	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6864	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6865	>	FFTW_LIBS="-lfftw3"
6866	>	else
6867	>	if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6868	>
6869	>	cat >>confdefs.h <<\_ACEOF
6870	>	#define HAVE_FFTW_H 1
6871	>	_ACEOF
6872	>
6873	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6874	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6875	>	FFTW_LIBS="-lfftw"
6876	>	else
6877	>	if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6878	>
6879	>	cat >>confdefs.h <<\_ACEOF
6880	>	#define HAVE_DFFTW_H 1
6881	>	_ACEOF
6882	>
6883	>	FFTW_INC_DIR="${FFTW_HOME}/include"
6884	>	FFTW_LIB_DIR="${FFTW_HOME}/lib"
6885	>	FFTW_LIBS="-ldfftw"
6886	>	else
6887	>	echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6888	>	echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6889	>	FFTW_INC_DIR=
6890	>	FFTW_LIB_DIR=
6891	>	FFTW_LIBS=
6892	>	LDFLAGS="$FFTW_OLD_LDFLAGS"
6893	>	CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6894	>	echo "$as_me:$LINENO: result: failed" >&5
6895	>	echo "${ECHO_T}failed" >&6
6896	>	echo ""
6897	>	echo "*********************************************************"
6898	>	echo "* WARNING: Could not find a working FFTW installation   *"
6899	>	echo "* If you need the staticProps program to be able to     *"
6900	>	echo "* compute undulation spectra, be sure to specify a      *"
6901	>	echo "* valid fftw installation with --with-fftw=DIR          *"
6902	>	echo "*                                                       *"
6903	>	echo "* OOPSE will still work without fftw installed.         *"
6904	>	echo "*********************************************************"
6905	>	echo ""
6906	>	fi
6907	>	fi
6908	>	fi
6909	>
6910	>
6911	>
6912	>	fi
6913	>	fi
6914	>	fi
6915	>
6916	>
6917	>
6918	>	# Checks for header files.
6919	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6920	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6921	>	if test "${ac_cv_header_stdc+set}" = set; then
6922	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6923	>	else
6924	>	cat >conftest.$ac_ext <<_ACEOF
6925	>	/* confdefs.h.  */
6926	>	_ACEOF
6927	>	cat confdefs.h >>conftest.$ac_ext
6928	>	cat >>conftest.$ac_ext <<_ACEOF
6929	>	/* end confdefs.h.  */
6930	>	#include <stdlib.h>
6931	>	#include <stdarg.h>
6932	>	#include <string.h>
6933	>	#include <float.h>
6934	>
6935	>	#ifdef FC_DUMMY_MAIN
6936	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6937	>	#  ifdef __cplusplus
6938	>	extern "C"
6939	>	#  endif
6940	>	int FC_DUMMY_MAIN() { return 1; }
6941	>	#endif
6942	>	#endif
6943	>	int
6944	>	main ()
6945	>	{
6946	>
6947	>	;
6948	>	return 0;
6949	>	}
6950	>	_ACEOF
6951	>	rm -f conftest.$ac_objext
6952	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6953	>	(eval $ac_compile) 2>conftest.er1
6954	>	ac_status=$?
6955	>	grep -v '^ *+' conftest.er1 >conftest.err
6956	>	rm -f conftest.er1
6957	>	cat conftest.err >&5
6958	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6959	>	(exit $ac_status); } &&
6960	>	{ ac_try='test -z "$ac_c_werror_flag"
6961	>	|| test ! -s conftest.err'
6962	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6963	>	(eval $ac_try) 2>&5
6964	>	ac_status=$?
6965	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6966	>	(exit $ac_status); }; } &&
6967	>	{ ac_try='test -s conftest.$ac_objext'
6968	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6969	>	(eval $ac_try) 2>&5
6970	>	ac_status=$?
6971	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6972	>	(exit $ac_status); }; }; then
6973	>	ac_cv_header_stdc=yes
6974	>	else
6975	>	echo "$as_me: failed program was:" >&5
6976	>	sed 's/^/| /' conftest.$ac_ext >&5
6977	>
6978	>	ac_cv_header_stdc=no
6979	>	fi
6980	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6981	>
6982	>	if test $ac_cv_header_stdc = yes; then
6983	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6984	>	cat >conftest.$ac_ext <<_ACEOF
6985	>	/* confdefs.h.  */
6986	>	_ACEOF
6987	>	cat confdefs.h >>conftest.$ac_ext
6988	>	cat >>conftest.$ac_ext <<_ACEOF
6989	>	/* end confdefs.h.  */
6990	>	#include <string.h>
6991	>
6992	>	_ACEOF
6993	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6994	>	$EGREP "memchr" >/dev/null 2>&1; then
6995	>	:
6996	>	else
6997	>	ac_cv_header_stdc=no
6998	>	fi
6999	>	rm -f conftest*
7000	>
7001	>	fi
7002	>
7003	>	if test $ac_cv_header_stdc = yes; then
7004	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7005	>	cat >conftest.$ac_ext <<_ACEOF
7006	>	/* confdefs.h.  */
7007	>	_ACEOF
7008	>	cat confdefs.h >>conftest.$ac_ext
7009	>	cat >>conftest.$ac_ext <<_ACEOF
7010	>	/* end confdefs.h.  */
7011	>	#include <stdlib.h>
7012	>
7013	>	_ACEOF
7014	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7015	>	$EGREP "free" >/dev/null 2>&1; then
7016	>	:
7017	>	else
7018	>	ac_cv_header_stdc=no
7019	>	fi
7020	>	rm -f conftest*
7021	>
7022	>	fi
7023	>
7024	>	if test $ac_cv_header_stdc = yes; then
7025	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7026	>	if test "$cross_compiling" = yes; then
7027	>	:
7028	>	else
7029	>	cat >conftest.$ac_ext <<_ACEOF
7030	>	/* confdefs.h.  */
7031	>	_ACEOF
7032	>	cat confdefs.h >>conftest.$ac_ext
7033	>	cat >>conftest.$ac_ext <<_ACEOF
7034	>	/* end confdefs.h.  */
7035	>	#include <ctype.h>
7036	>	#if ((' ' & 0x0FF) == 0x020)
7037	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7038	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7039	>	#else
7040	>	# define ISLOWER(c) \
7041	>	(('a' <= (c) && (c) <= 'i') \
7042	>	|| ('j' <= (c) && (c) <= 'r') \
7043	>	|| ('s' <= (c) && (c) <= 'z'))
7044	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7045	>	#endif
7046	>
7047	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7048	>	int
7049	>	main ()
7050	>	{
7051	>	int i;
7052	>	for (i = 0; i < 256; i++)
7053	>	if (XOR (islower (i), ISLOWER (i))
7054	>	|| toupper (i) != TOUPPER (i))
7055	>	exit(2);
7056	>	exit (0);
7057	>	}
7058	>	_ACEOF
7059	>	rm -f conftest$ac_exeext
7060	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7061	>	(eval $ac_link) 2>&5
7062	>	ac_status=$?
7063	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7064	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7065	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7066	>	(eval $ac_try) 2>&5
7067	>	ac_status=$?
7068	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7069	>	(exit $ac_status); }; }; then
7070	>	:
7071	>	else
7072	>	echo "$as_me: program exited with status $ac_status" >&5
7073	>	echo "$as_me: failed program was:" >&5
7074	>	sed 's/^/| /' conftest.$ac_ext >&5
7075	>
7076	>	( exit $ac_status )
7077	>	ac_cv_header_stdc=no
7078	>	fi
7079	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7080	>	fi
7081	>	fi
7082	>	fi
7083	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7084	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
7085	>	if test $ac_cv_header_stdc = yes; then
7086	>
7087	>	cat >>confdefs.h <<\_ACEOF
7088	>	#define STDC_HEADERS 1
7089	>	_ACEOF
7090	>
7091	>	fi
7092	>
7093	>
7094	>
7095	>
7096	>
7097	>
7098	>
7099	>
7100	>
7101	>
7102	>
7103	>
7104	>
7105	>
7106	>
7107	>
7108	>
7109	>
7110	>
7111	>
7112	>
7113	>
7114	>
7115	>
7116	>
7117	>
7118	>	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
7119	>	do
7120	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7121	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7122	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7123	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7124	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7125	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7126	>	fi
7127	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7128	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7129	>	else
7130	>	# Is the header compilable?
7131	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
7132	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7133	>	cat >conftest.$ac_ext <<_ACEOF
7134	>	/* confdefs.h.  */
7135	>	_ACEOF
7136	>	cat confdefs.h >>conftest.$ac_ext
7137	>	cat >>conftest.$ac_ext <<_ACEOF
7138	>	/* end confdefs.h.  */
7139	>	$ac_includes_default
7140	>	#include <$ac_header>
7141	>	_ACEOF
7142	>	rm -f conftest.$ac_objext
7143	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7144	>	(eval $ac_compile) 2>conftest.er1
7145	>	ac_status=$?
7146	>	grep -v '^ *+' conftest.er1 >conftest.err
7147	>	rm -f conftest.er1
7148	>	cat conftest.err >&5
7149	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7150	>	(exit $ac_status); } &&
7151	>	{ ac_try='test -z "$ac_c_werror_flag"
7152	>	|| test ! -s conftest.err'
7153	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7154	>	(eval $ac_try) 2>&5
7155	>	ac_status=$?
7156	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7157	>	(exit $ac_status); }; } &&
7158	>	{ ac_try='test -s conftest.$ac_objext'
7159	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7160	>	(eval $ac_try) 2>&5
7161	>	ac_status=$?
7162	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7163	>	(exit $ac_status); }; }; then
7164	>	ac_header_compiler=yes
7165	>	else
7166	>	echo "$as_me: failed program was:" >&5
7167	>	sed 's/^/| /' conftest.$ac_ext >&5
7168	>
7169	>	ac_header_compiler=no
7170	>	fi
7171	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7172	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7173	>	echo "${ECHO_T}$ac_header_compiler" >&6
7174	>
7175	>	# Is the header present?
7176	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
7177	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7178	>	cat >conftest.$ac_ext <<_ACEOF
7179	>	/* confdefs.h.  */
7180	>	_ACEOF
7181	>	cat confdefs.h >>conftest.$ac_ext
7182	>	cat >>conftest.$ac_ext <<_ACEOF
7183	>	/* end confdefs.h.  */
7184	>	#include <$ac_header>
7185	>	_ACEOF
7186	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7187	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7188	>	ac_status=$?
7189	>	grep -v '^ *+' conftest.er1 >conftest.err
7190	>	rm -f conftest.er1
7191	>	cat conftest.err >&5
7192	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7193	>	(exit $ac_status); } >/dev/null; then
7194	>	if test -s conftest.err; then
7195	>	ac_cpp_err=$ac_c_preproc_warn_flag
7196	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7197	>	else
7198	>	ac_cpp_err=
7199	>	fi
7200	>	else
7201	>	ac_cpp_err=yes
7202	>	fi
7203	>	if test -z "$ac_cpp_err"; then
7204	>	ac_header_preproc=yes
7205	>	else
7206	>	echo "$as_me: failed program was:" >&5
7207	>	sed 's/^/| /' conftest.$ac_ext >&5
7208	>
7209	>	ac_header_preproc=no
7210	>	fi
7211	>	rm -f conftest.err conftest.$ac_ext
7212	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7213	>	echo "${ECHO_T}$ac_header_preproc" >&6
7214	>
7215	>	# So?  What about this header?
7216	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7217	>	yes:no: )
7218	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7219	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7220	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7221	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7222	>	ac_header_preproc=yes
7223	>	;;
7224	>	no:yes:* )
7225	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7226	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7227	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7228	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7229	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7230	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7231	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7232	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7233	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7234	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7235	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7236	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7237	>	(
7238	>	cat <<\_ASBOX
7239	>	## ------------------------------ ##
7240	>	## Report this to gezelter@nd.edu ##
7241	>	## ------------------------------ ##
7242	>	_ASBOX
7243	>	) |
7244	>	sed "s/^/$as_me: WARNING:     /" >&2
7245	>	;;
7246	>	esac
7247	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7248	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7249	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7250	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7251	>	else
7252	>	eval "$as_ac_Header=\$ac_header_preproc"
7253	>	fi
7254	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7255	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7256	>
7257	>	fi
7258	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
7259	>	cat >>confdefs.h <<_ACEOF
7260	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7261	>	_ACEOF
7262	>
7263	>	fi
7264	>
7265	>	done
7266	>
7267	>
7268	>	# Checks for typedefs, structures, and compiler characteristics.
7269	>	echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7270	>	echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7271	>	if test "${ac_cv_header_stdbool_h+set}" = set; then
7272	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7273	>	else
7274	>	cat >conftest.$ac_ext <<_ACEOF
7275	>	/* confdefs.h.  */
7276	>	_ACEOF
7277	>	cat confdefs.h >>conftest.$ac_ext
7278	>	cat >>conftest.$ac_ext <<_ACEOF
7279	>	/* end confdefs.h.  */
7280	>
7281	>	#include <stdbool.h>
7282	>	#ifndef bool
7283	>	# error bool is not defined
7284	>	#endif
7285	>	#ifndef false
7286	>	# error false is not defined
7287	>	#endif
7288	>	#if false
7289	>	# error false is not 0
7290	>	#endif
7291	>	#ifndef true
7292	>	# error true is not defined
7293	>	#endif
7294	>	#if true != 1
7295	>	# error true is not 1
7296	>	#endif
7297	>	#ifndef __bool_true_false_are_defined
7298	>	# error __bool_true_false_are_defined is not defined
7299	>	#endif
7300	>
7301	>	struct s { _Bool s: 1; _Bool t; } s;
7302	>
7303	>	char a[true == 1 ? 1 : -1];
7304	>	char b[false == 0 ? 1 : -1];
7305	>	char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7306	>	char d[(bool) -0.5 == true ? 1 : -1];
7307	>	bool e = &s;
7308	>	char f[(_Bool) -0.0 == false ? 1 : -1];
7309	>	char g[true];
7310	>	char h[sizeof (_Bool)];
7311	>	char i[sizeof s.t];
7312	>
7313	>	#ifdef FC_DUMMY_MAIN
7314	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7315	>	#  ifdef __cplusplus
7316	>	extern "C"
7317	>	#  endif
7318	>	int FC_DUMMY_MAIN() { return 1; }
7319	>	#endif
7320	>	#endif
7321	>	int
7322	>	main ()
7323	>	{
7324	>	return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7325	>	;
7326	>	return 0;
7327	>	}
7328	>	_ACEOF
7329	>	rm -f conftest.$ac_objext
7330	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7331	>	(eval $ac_compile) 2>conftest.er1
7332	>	ac_status=$?
7333	>	grep -v '^ *+' conftest.er1 >conftest.err
7334	>	rm -f conftest.er1
7335	>	cat conftest.err >&5
7336	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7337	>	(exit $ac_status); } &&
7338	>	{ ac_try='test -z "$ac_c_werror_flag"
7339	>	|| test ! -s conftest.err'
7340	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7341	>	(eval $ac_try) 2>&5
7342	>	ac_status=$?
7343	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7344	>	(exit $ac_status); }; } &&
7345	>	{ ac_try='test -s conftest.$ac_objext'
7346	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7347	>	(eval $ac_try) 2>&5
7348	>	ac_status=$?
7349	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7350	>	(exit $ac_status); }; }; then
7351	>	ac_cv_header_stdbool_h=yes
7352	>	else
7353	>	echo "$as_me: failed program was:" >&5
7354	>	sed 's/^/| /' conftest.$ac_ext >&5
7355	>
7356	>	ac_cv_header_stdbool_h=no
7357	>	fi
7358	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7359	>	fi
7360	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7361	>	echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7362	>	echo "$as_me:$LINENO: checking for _Bool" >&5
7363	>	echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7364	>	if test "${ac_cv_type__Bool+set}" = set; then
7365	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7366	>	else
7367	>	cat >conftest.$ac_ext <<_ACEOF
7368	>	/* confdefs.h.  */
7369	>	_ACEOF
7370	>	cat confdefs.h >>conftest.$ac_ext
7371	>	cat >>conftest.$ac_ext <<_ACEOF
7372	>	/* end confdefs.h.  */
7373	>	$ac_includes_default
7374	>	#ifdef FC_DUMMY_MAIN
7375	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7376	>	#  ifdef __cplusplus
7377	>	extern "C"
7378	>	#  endif
7379	>	int FC_DUMMY_MAIN() { return 1; }
7380	>	#endif
7381	>	#endif
7382	>	int
7383	>	main ()
7384	>	{
7385	>	if ((_Bool *) 0)
7386	>	return 0;
7387	>	if (sizeof (_Bool))
7388	>	return 0;
7389	>	;
7390	>	return 0;
7391	>	}
7392	>	_ACEOF
7393	>	rm -f conftest.$ac_objext
7394	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7395	>	(eval $ac_compile) 2>conftest.er1
7396	>	ac_status=$?
7397	>	grep -v '^ *+' conftest.er1 >conftest.err
7398	>	rm -f conftest.er1
7399	>	cat conftest.err >&5
7400	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7401	>	(exit $ac_status); } &&
7402	>	{ ac_try='test -z "$ac_c_werror_flag"
7403	>	|| test ! -s conftest.err'
7404	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7405	>	(eval $ac_try) 2>&5
7406	>	ac_status=$?
7407	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7408	>	(exit $ac_status); }; } &&
7409	>	{ ac_try='test -s conftest.$ac_objext'
7410	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7411	>	(eval $ac_try) 2>&5
7412	>	ac_status=$?
7413	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7414	>	(exit $ac_status); }; }; then
7415	>	ac_cv_type__Bool=yes
7416	>	else
7417	>	echo "$as_me: failed program was:" >&5
7418	>	sed 's/^/| /' conftest.$ac_ext >&5
7419	>
7420	>	ac_cv_type__Bool=no
7421	>	fi
7422	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7423	>	fi
7424	>	echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7425	>	echo "${ECHO_T}$ac_cv_type__Bool" >&6
7426	>	if test $ac_cv_type__Bool = yes; then
7427	>
7428	>	cat >>confdefs.h <<_ACEOF
7429	>	#define HAVE__BOOL 1
7430	>	_ACEOF
7431	>
7432	>
7433	>	fi
7434	>
7435	>	if test $ac_cv_header_stdbool_h = yes; then
7436	>
7437	>	cat >>confdefs.h <<\_ACEOF
7438	>	#define HAVE_STDBOOL_H 1
7439	>	_ACEOF
7440	>
7441	>	fi
7442	>
7443	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7444	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7445	>	if test "${ac_cv_c_const+set}" = set; then
7446	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7447	>	else
7448	>	cat >conftest.$ac_ext <<_ACEOF
7449	>	/* confdefs.h.  */
7450	>	_ACEOF
7451	>	cat confdefs.h >>conftest.$ac_ext
7452	>	cat >>conftest.$ac_ext <<_ACEOF
7453	>	/* end confdefs.h.  */
7454	>
7455	>	#ifdef FC_DUMMY_MAIN
7456	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7457	>	#  ifdef __cplusplus
7458	>	extern "C"
7459	>	#  endif
7460	>	int FC_DUMMY_MAIN() { return 1; }
7461	>	#endif
7462	>	#endif
7463	>	int
7464	>	main ()
7465	>	{
7466	>	/* FIXME: Include the comments suggested by Paul. */
7467	>	#ifndef __cplusplus
7468	>	/* Ultrix mips cc rejects this.  */
7469	>	typedef int charset[2];
7470	>	const charset x;
7471	>	/* SunOS 4.1.1 cc rejects this.  */
7472	>	char const *const *ccp;
7473	>	char **p;
7474	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7475	>	struct point {int x, y;};
7476	>	static struct point const zero = {0,0};
7477	>	/* AIX XL C 1.02.0.0 rejects this.
7478	>	It does not let you subtract one const X* pointer from another in
7479	>	an arm of an if-expression whose if-part is not a constant
7480	>	expression */
7481	>	const char *g = "string";
7482	>	ccp = &g + (g ? g-g : 0);
7483	>	/* HPUX 7.0 cc rejects these. */
7484	>	++ccp;
7485	>	p = (char**) ccp;
7486	>	ccp = (char const *const *) p;
7487	>	{ /* SCO 3.2v4 cc rejects this.  */
7488	>	char *t;
7489	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7490	>
7491	>	*t++ = 0;
7492	>	}
7493	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7494	>	int x[] = {25, 17};
7495	>	const int *foo = &x[0];
7496	>	++foo;
7497	>	}
7498	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7499	>	typedef const int *iptr;
7500	>	iptr p = 0;
7501	>	++p;
7502	>	}
7503	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7504	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7505	>	struct s { int j; const int *ap[3]; };
7506	>	struct s *b; b->j = 5;
7507	>	}
7508	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7509	>	const int foo = 10;
7510	>	}
7511	>	#endif
7512	>
7513	>	;
7514	>	return 0;
7515	>	}
7516	>	_ACEOF
7517	>	rm -f conftest.$ac_objext
7518	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7519	>	(eval $ac_compile) 2>conftest.er1
7520	>	ac_status=$?
7521	>	grep -v '^ *+' conftest.er1 >conftest.err
7522	>	rm -f conftest.er1
7523	>	cat conftest.err >&5
7524	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7525	>	(exit $ac_status); } &&
7526	>	{ ac_try='test -z "$ac_c_werror_flag"
7527	>	|| test ! -s conftest.err'
7528	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7529	>	(eval $ac_try) 2>&5
7530	>	ac_status=$?
7531	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7532	>	(exit $ac_status); }; } &&
7533	>	{ ac_try='test -s conftest.$ac_objext'
7534	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7535	>	(eval $ac_try) 2>&5
7536	>	ac_status=$?
7537	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7538	>	(exit $ac_status); }; }; then
7539	>	ac_cv_c_const=yes
7540	>	else
7541	>	echo "$as_me: failed program was:" >&5
7542	>	sed 's/^/| /' conftest.$ac_ext >&5
7543	>
7544	>	ac_cv_c_const=no
7545	>	fi
7546	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7547	>	fi
7548	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7549	>	echo "${ECHO_T}$ac_cv_c_const" >&6
7550	>	if test $ac_cv_c_const = no; then
7551	>
7552	>	cat >>confdefs.h <<\_ACEOF
7553	>	#define const
7554	>	_ACEOF
7555	>
7556	>	fi
7557	>
7558	>	echo "$as_me:$LINENO: checking for inline" >&5
7559	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
7560	>	if test "${ac_cv_c_inline+set}" = set; then
7561	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7562	>	else
7563	>	ac_cv_c_inline=no
7564	>	for ac_kw in inline __inline__ __inline; do
7565	>	cat >conftest.$ac_ext <<_ACEOF
7566	>	/* confdefs.h.  */
7567	>	_ACEOF
7568	>	cat confdefs.h >>conftest.$ac_ext
7569	>	cat >>conftest.$ac_ext <<_ACEOF
7570	>	/* end confdefs.h.  */
7571	>	#ifndef __cplusplus
7572	>	typedef int foo_t;
7573	>	static $ac_kw foo_t static_foo () {return 0; }
7574	>	$ac_kw foo_t foo () {return 0; }
7575	>	#endif
7576	>
7577	>	_ACEOF
7578	>	rm -f conftest.$ac_objext
7579	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7580	>	(eval $ac_compile) 2>conftest.er1
7581	>	ac_status=$?
7582	>	grep -v '^ *+' conftest.er1 >conftest.err
7583	>	rm -f conftest.er1
7584	>	cat conftest.err >&5
7585	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7586	>	(exit $ac_status); } &&
7587	>	{ ac_try='test -z "$ac_c_werror_flag"
7588	>	|| test ! -s conftest.err'
7589	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7590	>	(eval $ac_try) 2>&5
7591	>	ac_status=$?
7592	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7593	>	(exit $ac_status); }; } &&
7594	>	{ ac_try='test -s conftest.$ac_objext'
7595	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7596	>	(eval $ac_try) 2>&5
7597	>	ac_status=$?
7598	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7599	>	(exit $ac_status); }; }; then
7600	>	ac_cv_c_inline=$ac_kw; break
7601	>	else
7602	>	echo "$as_me: failed program was:" >&5
7603	>	sed 's/^/| /' conftest.$ac_ext >&5
7604	>
7605	>	fi
7606	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7607	>	done
7608	>
7609	>	fi
7610	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7611	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
7612	>
7613	>
7614	>	case $ac_cv_c_inline in
7615	>	inline | yes) ;;
7616	>	*)
7617	>	case $ac_cv_c_inline in
7618	>	no) ac_val=;;
7619	>	*) ac_val=$ac_cv_c_inline;;
7620	>	esac
7621	>	cat >>confdefs.h <<_ACEOF
7622	>	#ifndef __cplusplus
7623	>	#define inline $ac_val
7624	>	#endif
7625	>	_ACEOF
7626	>	;;
7627	>	esac
7628	>
7629	>	echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7630	>	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7631	>	if test "${ac_cv_c_restrict+set}" = set; then
7632	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7633	>	else
7634	>	ac_cv_c_restrict=no
7635	>	# Try the official restrict keyword, then gcc's __restrict, and
7636	>	# the less common variants.
7637	>	for ac_kw in restrict __restrict __restrict__ _Restrict; do
7638	>	cat >conftest.$ac_ext <<_ACEOF
7639	>	/* confdefs.h.  */
7640	>	_ACEOF
7641	>	cat confdefs.h >>conftest.$ac_ext
7642	>	cat >>conftest.$ac_ext <<_ACEOF
7643	>	/* end confdefs.h.  */
7644	>	float * $ac_kw x;
7645	>	_ACEOF
7646	>	rm -f conftest.$ac_objext
7647	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7648	>	(eval $ac_compile) 2>conftest.er1
7649	>	ac_status=$?
7650	>	grep -v '^ *+' conftest.er1 >conftest.err
7651	>	rm -f conftest.er1
7652	>	cat conftest.err >&5
7653	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7654	>	(exit $ac_status); } &&
7655	>	{ ac_try='test -z "$ac_c_werror_flag"
7656	>	|| test ! -s conftest.err'
7657	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7658	>	(eval $ac_try) 2>&5
7659	>	ac_status=$?
7660	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7661	>	(exit $ac_status); }; } &&
7662	>	{ ac_try='test -s conftest.$ac_objext'
7663	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7664	>	(eval $ac_try) 2>&5
7665	>	ac_status=$?
7666	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7667	>	(exit $ac_status); }; }; then
7668	>	ac_cv_c_restrict=$ac_kw; break
7669	>	else
7670	>	echo "$as_me: failed program was:" >&5
7671	>	sed 's/^/| /' conftest.$ac_ext >&5
7672	>
7673	>	fi
7674	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7675	>	done
7676	>
7677	>	fi
7678	>	echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7679	>	echo "${ECHO_T}$ac_cv_c_restrict" >&6
7680	>	case $ac_cv_c_restrict in
7681	>	restrict) ;;
7682	>	no)
7683	>	cat >>confdefs.h <<\_ACEOF
7684	>	#define restrict
7685	>	_ACEOF
7686	>	;;
7687	>	*)  cat >>confdefs.h <<_ACEOF
7688	>	#define restrict $ac_cv_c_restrict
7689	>	_ACEOF
7690	>	;;
7691	>	esac
7692	>
7693	>	echo "$as_me:$LINENO: checking for size_t" >&5
7694	>	echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7695	>	if test "${ac_cv_type_size_t+set}" = set; then
7696	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7697	>	else
7698	>	cat >conftest.$ac_ext <<_ACEOF
7699	>	/* confdefs.h.  */
7700	>	_ACEOF
7701	>	cat confdefs.h >>conftest.$ac_ext
7702	>	cat >>conftest.$ac_ext <<_ACEOF
7703	>	/* end confdefs.h.  */
7704	>	$ac_includes_default
7705	>	#ifdef FC_DUMMY_MAIN
7706	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7707	>	#  ifdef __cplusplus
7708	>	extern "C"
7709	>	#  endif
7710	>	int FC_DUMMY_MAIN() { return 1; }
7711	>	#endif
7712	>	#endif
7713	>	int
7714	>	main ()
7715	>	{
7716	>	if ((size_t *) 0)
7717	>	return 0;
7718	>	if (sizeof (size_t))
7719	>	return 0;
7720	>	;
7721	>	return 0;
7722	>	}
7723	>	_ACEOF
7724	>	rm -f conftest.$ac_objext
7725	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7726	>	(eval $ac_compile) 2>conftest.er1
7727	>	ac_status=$?
7728	>	grep -v '^ *+' conftest.er1 >conftest.err
7729	>	rm -f conftest.er1
7730	>	cat conftest.err >&5
7731	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7732	>	(exit $ac_status); } &&
7733	>	{ ac_try='test -z "$ac_c_werror_flag"
7734	>	|| test ! -s conftest.err'
7735	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7736	>	(eval $ac_try) 2>&5
7737	>	ac_status=$?
7738	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7739	>	(exit $ac_status); }; } &&
7740	>	{ ac_try='test -s conftest.$ac_objext'
7741	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7742	>	(eval $ac_try) 2>&5
7743	>	ac_status=$?
7744	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7745	>	(exit $ac_status); }; }; then
7746	>	ac_cv_type_size_t=yes
7747	>	else
7748	>	echo "$as_me: failed program was:" >&5
7749	>	sed 's/^/| /' conftest.$ac_ext >&5
7750	>
7751	>	ac_cv_type_size_t=no
7752	>	fi
7753	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7754	>	fi
7755	>	echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7756	>	echo "${ECHO_T}$ac_cv_type_size_t" >&6
7757	>	if test $ac_cv_type_size_t = yes; then
7758	>	:
7759	>	else
7760	>
7761	>	cat >>confdefs.h <<_ACEOF
7762	>	#define size_t unsigned
7763	>	_ACEOF
7764	>
7765	>	fi
7766	>
7767	>	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7768	>	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7769	>	if test "${ac_cv_header_time+set}" = set; then
7770	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7771	>	else
7772	>	cat >conftest.$ac_ext <<_ACEOF
7773	>	/* confdefs.h.  */
7774	>	_ACEOF
7775	>	cat confdefs.h >>conftest.$ac_ext
7776	>	cat >>conftest.$ac_ext <<_ACEOF
7777	>	/* end confdefs.h.  */
7778	>	#include <sys/types.h>
7779	>	#include <sys/time.h>
7780	>	#include <time.h>
7781	>
7782	>	#ifdef FC_DUMMY_MAIN
7783	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7784	>	#  ifdef __cplusplus
7785	>	extern "C"
7786	>	#  endif
7787	>	int FC_DUMMY_MAIN() { return 1; }
7788	>	#endif
7789	>	#endif
7790	>	int
7791	>	main ()
7792	>	{
7793	>	if ((struct tm *) 0)
7794	>	return 0;
7795	>	;
7796	>	return 0;
7797	>	}
7798	>	_ACEOF
7799	>	rm -f conftest.$ac_objext
7800	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7801	>	(eval $ac_compile) 2>conftest.er1
7802	>	ac_status=$?
7803	>	grep -v '^ *+' conftest.er1 >conftest.err
7804	>	rm -f conftest.er1
7805	>	cat conftest.err >&5
7806	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7807	>	(exit $ac_status); } &&
7808	>	{ ac_try='test -z "$ac_c_werror_flag"
7809	>	|| test ! -s conftest.err'
7810	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7811	>	(eval $ac_try) 2>&5
7812	>	ac_status=$?
7813	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7814	>	(exit $ac_status); }; } &&
7815	>	{ ac_try='test -s conftest.$ac_objext'
7816	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7817	>	(eval $ac_try) 2>&5
7818	>	ac_status=$?
7819	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7820	>	(exit $ac_status); }; }; then
7821	>	ac_cv_header_time=yes
7822	>	else
7823	>	echo "$as_me: failed program was:" >&5
7824	>	sed 's/^/| /' conftest.$ac_ext >&5
7825	>
7826	>	ac_cv_header_time=no
7827	>	fi
7828	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7829	>	fi
7830	>	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7831	>	echo "${ECHO_T}$ac_cv_header_time" >&6
7832	>	if test $ac_cv_header_time = yes; then
7833	>
7834	>	cat >>confdefs.h <<\_ACEOF
7835	>	#define TIME_WITH_SYS_TIME 1
7836	>	_ACEOF
7837	>
7838	>	fi
7839	>
7840	>	echo "$as_me:$LINENO: checking for clock_t" >&5
7841	>	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7842	>	if test "${ac_cv_type_clock_t+set}" = set; then
7843	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7844	>	else
7845	>	cat >conftest.$ac_ext <<_ACEOF
7846	>	/* confdefs.h.  */
7847	>	_ACEOF
7848	>	cat confdefs.h >>conftest.$ac_ext
7849	>	cat >>conftest.$ac_ext <<_ACEOF
7850	>	/* end confdefs.h.  */
7851	>	$ac_includes_default
7852	>	#ifdef FC_DUMMY_MAIN
7853	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7854	>	#  ifdef __cplusplus
7855	>	extern "C"
7856	>	#  endif
7857	>	int FC_DUMMY_MAIN() { return 1; }
7858	>	#endif
7859	>	#endif
7860	>	int
7861	>	main ()
7862	>	{
7863	>	if ((clock_t *) 0)
7864	>	return 0;
7865	>	if (sizeof (clock_t))
7866	>	return 0;
7867	>	;
7868	>	return 0;
7869	>	}
7870	>	_ACEOF
7871	>	rm -f conftest.$ac_objext
7872	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7873	>	(eval $ac_compile) 2>conftest.er1
7874	>	ac_status=$?
7875	>	grep -v '^ *+' conftest.er1 >conftest.err
7876	>	rm -f conftest.er1
7877	>	cat conftest.err >&5
7878	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879	>	(exit $ac_status); } &&
7880	>	{ ac_try='test -z "$ac_c_werror_flag"
7881	>	|| test ! -s conftest.err'
7882	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7883	>	(eval $ac_try) 2>&5
7884	>	ac_status=$?
7885	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7886	>	(exit $ac_status); }; } &&
7887	>	{ ac_try='test -s conftest.$ac_objext'
7888	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7889	>	(eval $ac_try) 2>&5
7890	>	ac_status=$?
7891	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7892	>	(exit $ac_status); }; }; then
7893	>	ac_cv_type_clock_t=yes
7894	>	else
7895	>	echo "$as_me: failed program was:" >&5
7896	>	sed 's/^/| /' conftest.$ac_ext >&5
7897	>
7898	>	ac_cv_type_clock_t=no
7899	>	fi
7900	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7901	>	fi
7902	>	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7903	>	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7904	>	if test $ac_cv_type_clock_t = yes; then
7905	>
7906	>	cat >>confdefs.h <<_ACEOF
7907	>	#define HAVE_CLOCK_T 1
7908	>	_ACEOF
7909	>
7910	>
7911	>	fi
7912	>
7913	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7914	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7915	>	if test "${ac_cv_c_const+set}" = set; then
7916	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7917	>	else
7918	>	cat >conftest.$ac_ext <<_ACEOF
7919	>	/* confdefs.h.  */
7920	>	_ACEOF
7921	>	cat confdefs.h >>conftest.$ac_ext
7922	>	cat >>conftest.$ac_ext <<_ACEOF
7923	>	/* end confdefs.h.  */
7924	>
7925	>	#ifdef FC_DUMMY_MAIN
7926	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7927	>	#  ifdef __cplusplus
7928	>	extern "C"
7929	>	#  endif
7930	>	int FC_DUMMY_MAIN() { return 1; }
7931	>	#endif
7932	>	#endif
7933	>	int
7934	>	main ()
7935	>	{
7936	>	/* FIXME: Include the comments suggested by Paul. */
7937	>	#ifndef __cplusplus
7938	>	/* Ultrix mips cc rejects this.  */
7939	>	typedef int charset[2];
7940	>	const charset x;
7941	>	/* SunOS 4.1.1 cc rejects this.  */
7942	>	char const *const *ccp;
7943	>	char **p;
7944	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7945	>	struct point {int x, y;};
7946	>	static struct point const zero = {0,0};
7947	>	/* AIX XL C 1.02.0.0 rejects this.
7948	>	It does not let you subtract one const X* pointer from another in
7949	>	an arm of an if-expression whose if-part is not a constant
7950	>	expression */
7951	>	const char *g = "string";
7952	>	ccp = &g + (g ? g-g : 0);
7953	>	/* HPUX 7.0 cc rejects these. */
7954	>	++ccp;
7955	>	p = (char**) ccp;
7956	>	ccp = (char const *const *) p;
7957	>	{ /* SCO 3.2v4 cc rejects this.  */
7958	>	char *t;
7959	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7960	>
7961	>	*t++ = 0;
7962	>	}
7963	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7964	>	int x[] = {25, 17};
7965	>	const int *foo = &x[0];
7966	>	++foo;
7967	>	}
7968	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7969	>	typedef const int *iptr;
7970	>	iptr p = 0;
7971	>	++p;
7972	>	}
7973	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7974	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7975	>	struct s { int j; const int *ap[3]; };
7976	>	struct s *b; b->j = 5;
7977	>	}
7978	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7979	>	const int foo = 10;
7980	>	}
7981	>	#endif
7982	>
7983	>	;
7984	>	return 0;
7985	>	}
7986	>	_ACEOF
7987	>	rm -f conftest.$ac_objext
7988	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7989	>	(eval $ac_compile) 2>conftest.er1
7990	>	ac_status=$?
7991	>	grep -v '^ *+' conftest.er1 >conftest.err
7992	>	rm -f conftest.er1
7993	>	cat conftest.err >&5
7994	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7995	>	(exit $ac_status); } &&
7996	>	{ ac_try='test -z "$ac_c_werror_flag"
7997	>	|| test ! -s conftest.err'
7998	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7999	>	(eval $ac_try) 2>&5
8000	>	ac_status=$?
8001	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8002	>	(exit $ac_status); }; } &&
8003	>	{ ac_try='test -s conftest.$ac_objext'
8004	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8005	>	(eval $ac_try) 2>&5
8006	>	ac_status=$?
8007	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8008	>	(exit $ac_status); }; }; then
8009	>	ac_cv_c_const=yes
8010	>	else
8011	>	echo "$as_me: failed program was:" >&5
8012	>	sed 's/^/| /' conftest.$ac_ext >&5
8013	>
8014	>	ac_cv_c_const=no
8015	>	fi
8016	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8017	>	fi
8018	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8019	>	echo "${ECHO_T}$ac_cv_c_const" >&6
8020	>	if test $ac_cv_c_const = no; then
8021	>
8022	>	cat >>confdefs.h <<\_ACEOF
8023	>	#define const
8024	>	_ACEOF
8025	>
8026	>	fi
8027	>
8028	>	echo "$as_me:$LINENO: checking for inline" >&5
8029	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
8030	>	if test "${ac_cv_c_inline+set}" = set; then
8031	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8032	>	else
8033	>	ac_cv_c_inline=no
8034	>	for ac_kw in inline __inline__ __inline; do
8035	>	cat >conftest.$ac_ext <<_ACEOF
8036	>	/* confdefs.h.  */
8037	>	_ACEOF
8038	>	cat confdefs.h >>conftest.$ac_ext
8039	>	cat >>conftest.$ac_ext <<_ACEOF
8040	>	/* end confdefs.h.  */
8041	>	#ifndef __cplusplus
8042	>	typedef int foo_t;
8043	>	static $ac_kw foo_t static_foo () {return 0; }
8044	>	$ac_kw foo_t foo () {return 0; }
8045	>	#endif
8046	>
8047	>	_ACEOF
8048	>	rm -f conftest.$ac_objext
8049	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8050	>	(eval $ac_compile) 2>conftest.er1
8051	>	ac_status=$?
8052	>	grep -v '^ *+' conftest.er1 >conftest.err
8053	>	rm -f conftest.er1
8054	>	cat conftest.err >&5
8055	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8056	>	(exit $ac_status); } &&
8057	>	{ ac_try='test -z "$ac_c_werror_flag"
8058	>	|| test ! -s conftest.err'
8059	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8060	>	(eval $ac_try) 2>&5
8061	>	ac_status=$?
8062	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8063	>	(exit $ac_status); }; } &&
8064	>	{ ac_try='test -s conftest.$ac_objext'
8065	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8066	>	(eval $ac_try) 2>&5
8067	>	ac_status=$?
8068	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8069	>	(exit $ac_status); }; }; then
8070	>	ac_cv_c_inline=$ac_kw; break
8071	>	else
8072	>	echo "$as_me: failed program was:" >&5
8073	>	sed 's/^/| /' conftest.$ac_ext >&5
8074	>
8075	>	fi
8076	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8077	>	done
8078	>
8079	>	fi
8080	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8081	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
8082	>
8083	>
8084	>	case $ac_cv_c_inline in
8085	>	inline | yes) ;;
8086	>	*)
8087	>	case $ac_cv_c_inline in
8088	>	no) ac_val=;;
8089	>	*) ac_val=$ac_cv_c_inline;;
8090	>	esac
8091	>	cat >>confdefs.h <<_ACEOF
8092	>	#ifndef __cplusplus
8093	>	#define inline $ac_val
8094	>	#endif
8095	>	_ACEOF
8096	>	;;
8097	>	esac
8098	>
8099	>
8100	>	# Checks for library functions.
8101	>
8102	>	for ac_header in stdlib.h
8103	>	do
8104	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8105	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8106	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8107	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8108	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8109	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8110	>	fi
8111	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8112	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8113	>	else
8114	>	# Is the header compilable?
8115	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8116	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8117	>	cat >conftest.$ac_ext <<_ACEOF
8118	>	/* confdefs.h.  */
8119	>	_ACEOF
8120	>	cat confdefs.h >>conftest.$ac_ext
8121	>	cat >>conftest.$ac_ext <<_ACEOF
8122	>	/* end confdefs.h.  */
8123	>	$ac_includes_default
8124	>	#include <$ac_header>
8125	>	_ACEOF
8126	>	rm -f conftest.$ac_objext
8127	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8128	>	(eval $ac_compile) 2>conftest.er1
8129	>	ac_status=$?
8130	>	grep -v '^ *+' conftest.er1 >conftest.err
8131	>	rm -f conftest.er1
8132	>	cat conftest.err >&5
8133	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8134	>	(exit $ac_status); } &&
8135	>	{ ac_try='test -z "$ac_c_werror_flag"
8136	>	|| test ! -s conftest.err'
8137	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8138	>	(eval $ac_try) 2>&5
8139	>	ac_status=$?
8140	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8141	>	(exit $ac_status); }; } &&
8142	>	{ ac_try='test -s conftest.$ac_objext'
8143	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8144	>	(eval $ac_try) 2>&5
8145	>	ac_status=$?
8146	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8147	>	(exit $ac_status); }; }; then
8148	>	ac_header_compiler=yes
8149	>	else
8150	>	echo "$as_me: failed program was:" >&5
8151	>	sed 's/^/| /' conftest.$ac_ext >&5
8152	>
8153	>	ac_header_compiler=no
8154	>	fi
8155	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8156	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8157	>	echo "${ECHO_T}$ac_header_compiler" >&6
8158	>
8159	>	# Is the header present?
8160	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8161	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8162	>	cat >conftest.$ac_ext <<_ACEOF
8163	>	/* confdefs.h.  */
8164	>	_ACEOF
8165	>	cat confdefs.h >>conftest.$ac_ext
8166	>	cat >>conftest.$ac_ext <<_ACEOF
8167	>	/* end confdefs.h.  */
8168	>	#include <$ac_header>
8169	>	_ACEOF
8170	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8171	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8172	>	ac_status=$?
8173	>	grep -v '^ *+' conftest.er1 >conftest.err
8174	>	rm -f conftest.er1
8175	>	cat conftest.err >&5
8176	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8177	>	(exit $ac_status); } >/dev/null; then
8178	>	if test -s conftest.err; then
8179	>	ac_cpp_err=$ac_c_preproc_warn_flag
8180	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8181	>	else
8182	>	ac_cpp_err=
8183	>	fi
8184	>	else
8185	>	ac_cpp_err=yes
8186	>	fi
8187	>	if test -z "$ac_cpp_err"; then
8188	>	ac_header_preproc=yes
8189	>	else
8190	>	echo "$as_me: failed program was:" >&5
8191	>	sed 's/^/| /' conftest.$ac_ext >&5
8192	>
8193	>	ac_header_preproc=no
8194	>	fi
8195	>	rm -f conftest.err conftest.$ac_ext
8196	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8197	>	echo "${ECHO_T}$ac_header_preproc" >&6
8198	>
8199	>	# So?  What about this header?
8200	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8201	>	yes:no: )
8202	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8203	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8204	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8205	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8206	>	ac_header_preproc=yes
8207	>	;;
8208	>	no:yes:* )
8209	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8210	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8211	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8212	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8213	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8214	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8215	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8216	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8217	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8218	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8219	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8220	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8221	>	(
8222	>	cat <<\_ASBOX
8223	>	## ------------------------------ ##
8224	>	## Report this to gezelter@nd.edu ##
8225	>	## ------------------------------ ##
8226	>	_ASBOX
8227	>	) |
8228	>	sed "s/^/$as_me: WARNING:     /" >&2
8229	>	;;
8230	>	esac
8231	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8232	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8233	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8234	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8235	>	else
8236	>	eval "$as_ac_Header=\$ac_header_preproc"
8237	>	fi
8238	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8239	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8240	>
8241	>	fi
8242	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8243	>	cat >>confdefs.h <<_ACEOF
8244	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8245	>	_ACEOF
8246	>
8247	>	fi
8248	>
8249	>	done
8250	>
8251	>	echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8252	>	echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8253	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8254	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8255	>	else
8256	>	if test "$cross_compiling" = yes; then
8257	>	ac_cv_func_malloc_0_nonnull=no
8258	>	else
8259	>	cat >conftest.$ac_ext <<_ACEOF
8260	>	/* confdefs.h.  */
8261	>	_ACEOF
8262	>	cat confdefs.h >>conftest.$ac_ext
8263	>	cat >>conftest.$ac_ext <<_ACEOF
8264	>	/* end confdefs.h.  */
8265	>	#if STDC_HEADERS || HAVE_STDLIB_H
8266	>	# include <stdlib.h>
8267	>	#else
8268	>	char *malloc ();
8269	>	#endif
8270	>
8271	>	#ifdef FC_DUMMY_MAIN
8272	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8273	>	#  ifdef __cplusplus
8274	>	extern "C"
8275	>	#  endif
8276	>	int FC_DUMMY_MAIN() { return 1; }
8277	>	#endif
8278	>	#endif
8279	>	int
8280	>	main ()
8281	>	{
8282	>	exit (malloc (0) ? 0 : 1);
8283	>	;
8284	>	return 0;
8285	>	}
8286	>	_ACEOF
8287	>	rm -f conftest$ac_exeext
8288	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8289	>	(eval $ac_link) 2>&5
8290	>	ac_status=$?
8291	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8292	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8293	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8294	>	(eval $ac_try) 2>&5
8295	>	ac_status=$?
8296	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8297	>	(exit $ac_status); }; }; then
8298	>	ac_cv_func_malloc_0_nonnull=yes
8299	>	else
8300	>	echo "$as_me: program exited with status $ac_status" >&5
8301	>	echo "$as_me: failed program was:" >&5
8302	>	sed 's/^/| /' conftest.$ac_ext >&5
8303	>
8304	>	( exit $ac_status )
8305	>	ac_cv_func_malloc_0_nonnull=no
8306	>	fi
8307	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8308	>	fi
8309	>	fi
8310	>	echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8311	>	echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8312	>	if test $ac_cv_func_malloc_0_nonnull = yes; then
8313	>
8314	>	cat >>confdefs.h <<\_ACEOF
8315	>	#define HAVE_MALLOC 1
8316	>	_ACEOF
8317	>
8318	>	else
8319	>	cat >>confdefs.h <<\_ACEOF
8320	>	#define HAVE_MALLOC 0
8321	>	_ACEOF
8322	>
8323	>	case $LIBOBJS in
8324	>	"malloc.$ac_objext"   | \
8325	>	*" malloc.$ac_objext"   | \
8326	>	"malloc.$ac_objext "* | \
8327	>	*" malloc.$ac_objext "* ) ;;
8328	>	*) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8329	>	esac
8330	>
8331	>
8332	>	cat >>confdefs.h <<\_ACEOF
8333	>	#define malloc rpl_malloc
8334	>	_ACEOF
8335	>
8336	>	fi
8337	>
8338	>
8339	>
8340	>	echo "$as_me:$LINENO: checking for working memcmp" >&5
8341	>	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8342	>	if test "${ac_cv_func_memcmp_working+set}" = set; then
8343	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8344	>	else
8345	>	if test "$cross_compiling" = yes; then
8346	>	ac_cv_func_memcmp_working=no
8347	>	else
8348	>	cat >conftest.$ac_ext <<_ACEOF
8349	>	/* confdefs.h.  */
8350	>	_ACEOF
8351	>	cat confdefs.h >>conftest.$ac_ext
8352	>	cat >>conftest.$ac_ext <<_ACEOF
8353	>	/* end confdefs.h.  */
8354	>	$ac_includes_default
8355	>	#ifdef FC_DUMMY_MAIN
8356	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8357	>	#  ifdef __cplusplus
8358	>	extern "C"
8359	>	#  endif
8360	>	int FC_DUMMY_MAIN() { return 1; }
8361	>	#endif
8362	>	#endif
8363	>	int
8364	>	main ()
8365	>	{
8366	>
8367	>	/* Some versions of memcmp are not 8-bit clean.  */
8368	>	char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8369	>	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8370	>	exit (1);
8371	>
8372	>	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8373	>	or more and with at least one buffer not starting on a 4-byte boundary.
8374	>	William Lewis provided this test program.   */
8375	>	{
8376	>	char foo[21];
8377	>	char bar[21];
8378	>	int i;
8379	>	for (i = 0; i < 4; i++)
8380	>	{
8381	>	char *a = foo + i;
8382	>	char *b = bar + i;
8383	>	strcpy (a, "--------01111111");
8384	>	strcpy (b, "--------10000000");
8385	>	if (memcmp (a, b, 16) >= 0)
8386	>	exit (1);
8387	>	}
8388	>	exit (0);
8389	>	}
8390	>
8391	>	;
8392	>	return 0;
8393	>	}
8394	>	_ACEOF
8395	>	rm -f conftest$ac_exeext
8396	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8397	>	(eval $ac_link) 2>&5
8398	>	ac_status=$?
8399	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8400	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8401	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8402	>	(eval $ac_try) 2>&5
8403	>	ac_status=$?
8404	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8405	>	(exit $ac_status); }; }; then
8406	>	ac_cv_func_memcmp_working=yes
8407	>	else
8408	>	echo "$as_me: program exited with status $ac_status" >&5
8409	>	echo "$as_me: failed program was:" >&5
8410	>	sed 's/^/| /' conftest.$ac_ext >&5
8411	>
8412	>	( exit $ac_status )
8413	>	ac_cv_func_memcmp_working=no
8414	>	fi
8415	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8416	>	fi
8417	>	fi
8418	>	echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8419	>	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8420	>	test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8421	>	"memcmp.$ac_objext"   | \
8422	>	*" memcmp.$ac_objext"   | \
8423	>	"memcmp.$ac_objext "* | \
8424	>	*" memcmp.$ac_objext "* ) ;;
8425	>	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8426	>	esac
8427	>
8428	>
8429	>
8430	>	for ac_header in stdlib.h
8431	>	do
8432	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8433	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8434	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8435	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8436	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8437	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8438	>	fi
8439	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8440	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8441	>	else
8442	>	# Is the header compilable?
8443	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8444	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8445	>	cat >conftest.$ac_ext <<_ACEOF
8446	>	/* confdefs.h.  */
8447	>	_ACEOF
8448	>	cat confdefs.h >>conftest.$ac_ext
8449	>	cat >>conftest.$ac_ext <<_ACEOF
8450	>	/* end confdefs.h.  */
8451	>	$ac_includes_default
8452	>	#include <$ac_header>
8453	>	_ACEOF
8454	>	rm -f conftest.$ac_objext
8455	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8456	>	(eval $ac_compile) 2>conftest.er1
8457	>	ac_status=$?
8458	>	grep -v '^ *+' conftest.er1 >conftest.err
8459	>	rm -f conftest.er1
8460	>	cat conftest.err >&5
8461	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8462	>	(exit $ac_status); } &&
8463	>	{ ac_try='test -z "$ac_c_werror_flag"
8464	>	|| test ! -s conftest.err'
8465	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8466	>	(eval $ac_try) 2>&5
8467	>	ac_status=$?
8468	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8469	>	(exit $ac_status); }; } &&
8470	>	{ ac_try='test -s conftest.$ac_objext'
8471	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8472	>	(eval $ac_try) 2>&5
8473	>	ac_status=$?
8474	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8475	>	(exit $ac_status); }; }; then
8476	>	ac_header_compiler=yes
8477	>	else
8478	>	echo "$as_me: failed program was:" >&5
8479	>	sed 's/^/| /' conftest.$ac_ext >&5
8480	>
8481	>	ac_header_compiler=no
8482	>	fi
8483	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8484	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8485	>	echo "${ECHO_T}$ac_header_compiler" >&6
8486	>
8487	>	# Is the header present?
8488	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8489	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8490	>	cat >conftest.$ac_ext <<_ACEOF
8491	>	/* confdefs.h.  */
8492	>	_ACEOF
8493	>	cat confdefs.h >>conftest.$ac_ext
8494	>	cat >>conftest.$ac_ext <<_ACEOF
8495	>	/* end confdefs.h.  */
8496	>	#include <$ac_header>
8497	>	_ACEOF
8498	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8499	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8500	>	ac_status=$?
8501	>	grep -v '^ *+' conftest.er1 >conftest.err
8502	>	rm -f conftest.er1
8503	>	cat conftest.err >&5
8504	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8505	>	(exit $ac_status); } >/dev/null; then
8506	>	if test -s conftest.err; then
8507	>	ac_cpp_err=$ac_c_preproc_warn_flag
8508	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8509	>	else
8510	>	ac_cpp_err=
8511	>	fi
8512	>	else
8513	>	ac_cpp_err=yes
8514	>	fi
8515	>	if test -z "$ac_cpp_err"; then
8516	>	ac_header_preproc=yes
8517	>	else
8518	>	echo "$as_me: failed program was:" >&5
8519	>	sed 's/^/| /' conftest.$ac_ext >&5
8520	>
8521	>	ac_header_preproc=no
8522	>	fi
8523	>	rm -f conftest.err conftest.$ac_ext
8524	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8525	>	echo "${ECHO_T}$ac_header_preproc" >&6
8526	>
8527	>	# So?  What about this header?
8528	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8529	>	yes:no: )
8530	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8531	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8532	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8533	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8534	>	ac_header_preproc=yes
8535	>	;;
8536	>	no:yes:* )
8537	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8538	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8539	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8540	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8541	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8542	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8543	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8544	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8545	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8546	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8547	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8548	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8549	>	(
8550	>	cat <<\_ASBOX
8551	>	## ------------------------------ ##
8552	>	## Report this to gezelter@nd.edu ##
8553	>	## ------------------------------ ##
8554	>	_ASBOX
8555	>	) |
8556	>	sed "s/^/$as_me: WARNING:     /" >&2
8557	>	;;
8558	>	esac
8559	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8560	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8561	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8562	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8563	>	else
8564	>	eval "$as_ac_Header=\$ac_header_preproc"
8565	>	fi
8566	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8567	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8568	>
8569	>	fi
8570	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8571	>	cat >>confdefs.h <<_ACEOF
8572	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8573	>	_ACEOF
8574	>
8575	>	fi
8576	>
8577	>	done
8578	>
8579	>	echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8580	>	echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8581	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8582	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8583	>	else
8584	>	if test "$cross_compiling" = yes; then
8585	>	ac_cv_func_realloc_0_nonnull=no
8586	>	else
8587	>	cat >conftest.$ac_ext <<_ACEOF
8588	>	/* confdefs.h.  */
8589	>	_ACEOF
8590	>	cat confdefs.h >>conftest.$ac_ext
8591	>	cat >>conftest.$ac_ext <<_ACEOF
8592	>	/* end confdefs.h.  */
8593	>	#if STDC_HEADERS || HAVE_STDLIB_H
8594	>	# include <stdlib.h>
8595	>	#else
8596	>	char *realloc ();
8597	>	#endif
8598	>
8599	>	#ifdef FC_DUMMY_MAIN
8600	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8601	>	#  ifdef __cplusplus
8602	>	extern "C"
8603	>	#  endif
8604	>	int FC_DUMMY_MAIN() { return 1; }
8605	>	#endif
8606	>	#endif
8607	>	int
8608	>	main ()
8609	>	{
8610	>	exit (realloc (0, 0) ? 0 : 1);
8611	>	;
8612	>	return 0;
8613	>	}
8614	>	_ACEOF
8615	>	rm -f conftest$ac_exeext
8616	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8617	>	(eval $ac_link) 2>&5
8618	>	ac_status=$?
8619	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8620	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8621	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8622	>	(eval $ac_try) 2>&5
8623	>	ac_status=$?
8624	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8625	>	(exit $ac_status); }; }; then
8626	>	ac_cv_func_realloc_0_nonnull=yes
8627	>	else
8628	>	echo "$as_me: program exited with status $ac_status" >&5
8629	>	echo "$as_me: failed program was:" >&5
8630	>	sed 's/^/| /' conftest.$ac_ext >&5
8631	>
8632	>	( exit $ac_status )
8633	>	ac_cv_func_realloc_0_nonnull=no
8634	>	fi
8635	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8636	>	fi
8637	>	fi
8638	>	echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8639	>	echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8640	>	if test $ac_cv_func_realloc_0_nonnull = yes; then
8641	>
8642	>	cat >>confdefs.h <<\_ACEOF
8643	>	#define HAVE_REALLOC 1
8644	>	_ACEOF
8645	>
8646	>	else
8647	>	cat >>confdefs.h <<\_ACEOF
8648	>	#define HAVE_REALLOC 0
8649	>	_ACEOF
8650	>
8651	>	case $LIBOBJS in
8652	>	"realloc.$ac_objext"   | \
8653	>	*" realloc.$ac_objext"   | \
8654	>	"realloc.$ac_objext "* | \
8655	>	*" realloc.$ac_objext "* ) ;;
8656	>	*) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8657	>	esac
8658	>
8659	>
8660	>	cat >>confdefs.h <<\_ACEOF
8661	>	#define realloc rpl_realloc
8662	>	_ACEOF
8663	>
8664	>	fi
8665	>
8666	>
8667	>
8668	>
8669	>
8670	>	for ac_header in sys/select.h sys/socket.h
8671	>	do
8672	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8673	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8674	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8675	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8676	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8677	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8678	>	fi
8679	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8680	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8681	>	else
8682	>	# Is the header compilable?
8683	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8684	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8685	>	cat >conftest.$ac_ext <<_ACEOF
8686	>	/* confdefs.h.  */
8687	>	_ACEOF
8688	>	cat confdefs.h >>conftest.$ac_ext
8689	>	cat >>conftest.$ac_ext <<_ACEOF
8690	>	/* end confdefs.h.  */
8691	>	$ac_includes_default
8692	>	#include <$ac_header>
8693	>	_ACEOF
8694	>	rm -f conftest.$ac_objext
8695	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8696	>	(eval $ac_compile) 2>conftest.er1
8697	>	ac_status=$?
8698	>	grep -v '^ *+' conftest.er1 >conftest.err
8699	>	rm -f conftest.er1
8700	>	cat conftest.err >&5
8701	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8702	>	(exit $ac_status); } &&
8703	>	{ ac_try='test -z "$ac_c_werror_flag"
8704	>	|| test ! -s conftest.err'
8705	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8706	>	(eval $ac_try) 2>&5
8707	>	ac_status=$?
8708	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8709	>	(exit $ac_status); }; } &&
8710	>	{ ac_try='test -s conftest.$ac_objext'
8711	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8712	>	(eval $ac_try) 2>&5
8713	>	ac_status=$?
8714	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8715	>	(exit $ac_status); }; }; then
8716	>	ac_header_compiler=yes
8717	>	else
8718	>	echo "$as_me: failed program was:" >&5
8719	>	sed 's/^/| /' conftest.$ac_ext >&5
8720	>
8721	>	ac_header_compiler=no
8722	>	fi
8723	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8724	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8725	>	echo "${ECHO_T}$ac_header_compiler" >&6
8726	>
8727	>	# Is the header present?
8728	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8729	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8730	>	cat >conftest.$ac_ext <<_ACEOF
8731	>	/* confdefs.h.  */
8732	>	_ACEOF
8733	>	cat confdefs.h >>conftest.$ac_ext
8734	>	cat >>conftest.$ac_ext <<_ACEOF
8735	>	/* end confdefs.h.  */
8736	>	#include <$ac_header>
8737	>	_ACEOF
8738	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8739	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8740	>	ac_status=$?
8741	>	grep -v '^ *+' conftest.er1 >conftest.err
8742	>	rm -f conftest.er1
8743	>	cat conftest.err >&5
8744	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8745	>	(exit $ac_status); } >/dev/null; then
8746	>	if test -s conftest.err; then
8747	>	ac_cpp_err=$ac_c_preproc_warn_flag
8748	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8749	>	else
8750	>	ac_cpp_err=
8751	>	fi
8752	>	else
8753	>	ac_cpp_err=yes
8754	>	fi
8755	>	if test -z "$ac_cpp_err"; then
8756	>	ac_header_preproc=yes
8757	>	else
8758	>	echo "$as_me: failed program was:" >&5
8759	>	sed 's/^/| /' conftest.$ac_ext >&5
8760	>
8761	>	ac_header_preproc=no
8762	>	fi
8763	>	rm -f conftest.err conftest.$ac_ext
8764	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8765	>	echo "${ECHO_T}$ac_header_preproc" >&6
8766	>
8767	>	# So?  What about this header?
8768	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8769	>	yes:no: )
8770	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8771	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8772	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8773	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8774	>	ac_header_preproc=yes
8775	>	;;
8776	>	no:yes:* )
8777	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8778	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8779	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8780	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8781	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8782	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8783	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8784	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8785	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8786	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8787	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8788	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8789	>	(
8790	>	cat <<\_ASBOX
8791	>	## ------------------------------ ##
8792	>	## Report this to gezelter@nd.edu ##
8793	>	## ------------------------------ ##
8794	>	_ASBOX
8795	>	) |
8796	>	sed "s/^/$as_me: WARNING:     /" >&2
8797	>	;;
8798	>	esac
8799	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8800	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8801	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8802	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8803	>	else
8804	>	eval "$as_ac_Header=\$ac_header_preproc"
8805	>	fi
8806	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8807	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8808	>
8809	>	fi
8810	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8811	>	cat >>confdefs.h <<_ACEOF
8812	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8813	>	_ACEOF
8814	>
8815	>	fi
8816	>
8817	>	done
8818	>
8819	>	echo "$as_me:$LINENO: checking types of arguments for select" >&5
8820	>	echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8821	>	if test "${ac_cv_func_select_args+set}" = set; then
8822	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8823	>	else
8824	>	for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8825	>	for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8826	>	for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8827	>	cat >conftest.$ac_ext <<_ACEOF
8828	>	/* confdefs.h.  */
8829	>	_ACEOF
8830	>	cat confdefs.h >>conftest.$ac_ext
8831	>	cat >>conftest.$ac_ext <<_ACEOF
8832	>	/* end confdefs.h.  */
8833	>	$ac_includes_default
8834	>	#if HAVE_SYS_SELECT_H
8835	>	# include <sys/select.h>
8836	>	#endif
8837	>	#if HAVE_SYS_SOCKET_H
8838	>	# include <sys/socket.h>
8839	>	#endif
8840	>
8841	>	#ifdef FC_DUMMY_MAIN
8842	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8843	>	#  ifdef __cplusplus
8844	>	extern "C"
8845	>	#  endif
8846	>	int FC_DUMMY_MAIN() { return 1; }
8847	>	#endif
8848	>	#endif
8849	>	int
8850	>	main ()
8851	>	{
8852	>	extern int select ($ac_arg1,
8853	>	$ac_arg234, $ac_arg234, $ac_arg234,
8854	>	$ac_arg5);
8855	>	;
8856	>	return 0;
8857	>	}
8858	>	_ACEOF
8859	>	rm -f conftest.$ac_objext
8860	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8861	>	(eval $ac_compile) 2>conftest.er1
8862	>	ac_status=$?
8863	>	grep -v '^ *+' conftest.er1 >conftest.err
8864	>	rm -f conftest.er1
8865	>	cat conftest.err >&5
8866	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8867	>	(exit $ac_status); } &&
8868	>	{ ac_try='test -z "$ac_c_werror_flag"
8869	>	|| test ! -s conftest.err'
8870	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8871	>	(eval $ac_try) 2>&5
8872	>	ac_status=$?
8873	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8874	>	(exit $ac_status); }; } &&
8875	>	{ ac_try='test -s conftest.$ac_objext'
8876	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8877	>	(eval $ac_try) 2>&5
8878	>	ac_status=$?
8879	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8880	>	(exit $ac_status); }; }; then
8881	>	ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8882	>	else
8883	>	echo "$as_me: failed program was:" >&5
8884	>	sed 's/^/| /' conftest.$ac_ext >&5
8885	>
8886	>	fi
8887	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8888	>	done
8889	>	done
8890	>	done
8891	>	# Provide a safe default value.
8892	>	: ${ac_cv_func_select_args='int,int *,struct timeval *'}
8893	>
8894	>	fi
8895	>	echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8896	>	echo "${ECHO_T}$ac_cv_func_select_args" >&6
8897	>	ac_save_IFS=$IFS; IFS=','
8898	>	set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8899	>	IFS=$ac_save_IFS
8900	>	shift
8901	>
8902	>	cat >>confdefs.h <<_ACEOF
8903	>	#define SELECT_TYPE_ARG1 $1
8904	>	_ACEOF
8905	>
8906	>
8907	>	cat >>confdefs.h <<_ACEOF
8908	>	#define SELECT_TYPE_ARG234 ($2)
8909	>	_ACEOF
8910	>
8911	>
8912	>	cat >>confdefs.h <<_ACEOF
8913	>	#define SELECT_TYPE_ARG5 ($3)
8914	>	_ACEOF
8915	>
8916	>	rm -f conftest*
8917	>
8918	>
8919	>	for ac_func in strftime
8920	>	do
8921	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8922	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
8923	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8924	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
8925	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8926	>	else
8927	>	cat >conftest.$ac_ext <<_ACEOF
8928	>	/* confdefs.h.  */
8929	>	_ACEOF
8930	>	cat confdefs.h >>conftest.$ac_ext
8931	>	cat >>conftest.$ac_ext <<_ACEOF
8932	>	/* end confdefs.h.  */
8933	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8934	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8935	>	#define $ac_func innocuous_$ac_func
8936	>
8937	>	/* System header to define __stub macros and hopefully few prototypes,
8938	>	which can conflict with char $ac_func (); below.
8939	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8940	>	<limits.h> exists even on freestanding compilers.  */
8941	>
8942	>	#ifdef __STDC__
8943	>	# include <limits.h>
8944	>	#else
8945	>	# include <assert.h>
8946	>	#endif
8947	>
8948	>	#undef $ac_func
8949	>
8950	>	/* Override any gcc2 internal prototype to avoid an error.  */
8951	>	#ifdef __cplusplus
8952	>	extern "C"
8953	>	{
8954	>	#endif
8955	>	/* We use char because int might match the return type of a gcc2
8956	>	builtin and then its argument prototype would still apply.  */
8957	>	char $ac_func ();
8958	>	/* The GNU C library defines this for functions which it implements
8959	>	to always fail with ENOSYS.  Some functions are actually named
8960	>	something starting with __ and the normal name is an alias.  */
8961	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8962	>	choke me
8963	>	#else
8964	>	char (*f) () = $ac_func;
8965	>	#endif
8966	>	#ifdef __cplusplus
8967	>	}
8968	>	#endif
8969	>
8970	>	#ifdef FC_DUMMY_MAIN
8971	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8972	>	#  ifdef __cplusplus
8973	>	extern "C"
8974	>	#  endif
8975	>	int FC_DUMMY_MAIN() { return 1; }
8976	>	#endif
8977	>	#endif
8978	>	int
8979	>	main ()
8980	>	{
8981	>	return f != $ac_func;
8982	>	;
8983	>	return 0;
8984	>	}
8985	>	_ACEOF
8986	>	rm -f conftest.$ac_objext conftest$ac_exeext
8987	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8988	>	(eval $ac_link) 2>conftest.er1
8989	>	ac_status=$?
8990	>	grep -v '^ *+' conftest.er1 >conftest.err
8991	>	rm -f conftest.er1
8992	>	cat conftest.err >&5
8993	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8994	>	(exit $ac_status); } &&
8995	>	{ ac_try='test -z "$ac_c_werror_flag"
8996	>	|| test ! -s conftest.err'
8997	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8998	>	(eval $ac_try) 2>&5
8999	>	ac_status=$?
9000	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9001	>	(exit $ac_status); }; } &&
9002	>	{ ac_try='test -s conftest$ac_exeext'
9003	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9004	>	(eval $ac_try) 2>&5
9005	>	ac_status=$?
9006	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9007	>	(exit $ac_status); }; }; then
9008	>	eval "$as_ac_var=yes"
9009	>	else
9010	>	echo "$as_me: failed program was:" >&5
9011	>	sed 's/^/| /' conftest.$ac_ext >&5
9012	>
9013	>	eval "$as_ac_var=no"
9014	>	fi
9015	>	rm -f conftest.err conftest.$ac_objext \
9016	>	conftest$ac_exeext conftest.$ac_ext
9017	>	fi
9018	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9019	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9020	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9021	>	cat >>confdefs.h <<_ACEOF
9022	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9023	>	_ACEOF
9024
9025	<
9026	<	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
9027	<	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
9028	<	if test "${ac_cv_header_stdc+set}" = set; then
9025	>	else
9026	>	# strftime is in -lintl on SCO UNIX.
9027	>	echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9028	>	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9029	>	if test "${ac_cv_lib_intl_strftime+set}" = set; then
9030		echo $ECHO_N "(cached) $ECHO_C" >&6
9031		else
9032	<	cat >conftest.$ac_ext <<_ACEOF
9032	>	ac_check_lib_save_LIBS=$LIBS
9033	>	LIBS="-lintl  $LIBS"
9034	>	cat >conftest.$ac_ext <<_ACEOF
9035		/* confdefs.h.  */
9036		_ACEOF
9037		cat confdefs.h >>conftest.$ac_ext
9038		cat >>conftest.$ac_ext <<_ACEOF
9039		/* end confdefs.h.  */
4799	–	#include <stdlib.h>
4800	–	#include <stdarg.h>
4801	–	#include <string.h>
4802	–	#include <float.h>
9040
9041	+	/* Override any gcc2 internal prototype to avoid an error.  */
9042	+	#ifdef __cplusplus
9043	+	extern "C"
9044	+	#endif
9045	+	/* We use char because int might match the return type of a gcc2
9046	+	builtin and then its argument prototype would still apply.  */
9047	+	char strftime ();
9048	+	#ifdef FC_DUMMY_MAIN
9049	+	#ifndef FC_DUMMY_MAIN_EQ_F77
9050	+	#  ifdef __cplusplus
9051	+	extern "C"
9052	+	#  endif
9053	+	int FC_DUMMY_MAIN() { return 1; }
9054	+	#endif
9055	+	#endif
9056		int
9057		main ()
9058		{
9059	<
9059	>	strftime ();
9060		;
9061		return 0;
9062		}
9063		_ACEOF
9064	<	rm -f conftest.$ac_objext
9065	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9066	<	(eval $ac_compile) 2>conftest.er1
9064	>	rm -f conftest.$ac_objext conftest$ac_exeext
9065	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9066	>	(eval $ac_link) 2>conftest.er1
9067		ac_status=$?
9068		grep -v '^ *+' conftest.er1 >conftest.err
9069		rm -f conftest.er1
9070		cat conftest.err >&5
9071		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9072		(exit $ac_status); } &&
9073	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9073	>	{ ac_try='test -z "$ac_c_werror_flag"
9074	>	|| test ! -s conftest.err'
9075		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9076		(eval $ac_try) 2>&5
9077		ac_status=$?
9078		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079		(exit $ac_status); }; } &&
9080	<	{ ac_try='test -s conftest.$ac_objext'
9080	>	{ ac_try='test -s conftest$ac_exeext'
9081		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9082		(eval $ac_try) 2>&5
9083		ac_status=$?
9084		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9085		(exit $ac_status); }; }; then
9086	<	ac_cv_header_stdc=yes
9086	>	ac_cv_lib_intl_strftime=yes
9087		else
9088		echo "$as_me: failed program was:" >&5
9089		sed 's/^/| /' conftest.$ac_ext >&5
9090
9091	<	ac_cv_header_stdc=no
9091	>	ac_cv_lib_intl_strftime=no
9092		fi
9093	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9094	<
9095	<	if test $ac_cv_header_stdc = yes; then
4843	<	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4844	<	cat >conftest.$ac_ext <<_ACEOF
4845	<	/* confdefs.h.  */
4846	<	_ACEOF
4847	<	cat confdefs.h >>conftest.$ac_ext
4848	<	cat >>conftest.$ac_ext <<_ACEOF
4849	<	/* end confdefs.h.  */
4850	<	#include <string.h>
4851	<
4852	<	_ACEOF
4853	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4854	<	$EGREP "memchr" >/dev/null 2>&1; then
4855	<	:
4856	<	else
4857	<	ac_cv_header_stdc=no
9093	>	rm -f conftest.err conftest.$ac_objext \
9094	>	conftest$ac_exeext conftest.$ac_ext
9095	>	LIBS=$ac_check_lib_save_LIBS
9096		fi
9097	<	rm -f conftest*
9098	<
9099	<	fi
9100	<
9101	<	if test $ac_cv_header_stdc = yes; then
4864	<	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
4865	<	cat >conftest.$ac_ext <<_ACEOF
4866	<	/* confdefs.h.  */
9097	>	echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9098	>	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9099	>	if test $ac_cv_lib_intl_strftime = yes; then
9100	>	cat >>confdefs.h <<\_ACEOF
9101	>	#define HAVE_STRFTIME 1
9102		_ACEOF
4868	–	cat confdefs.h >>conftest.$ac_ext
4869	–	cat >>conftest.$ac_ext <<_ACEOF
4870	–	/* end confdefs.h.  */
4871	–	#include <stdlib.h>
9103
9104	<	_ACEOF
4874	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4875	<	$EGREP "free" >/dev/null 2>&1; then
4876	<	:
4877	<	else
4878	<	ac_cv_header_stdc=no
9104	>	LIBS="-lintl $LIBS"
9105		fi
4880	–	rm -f conftest*
9106
9107		fi
9108	+	done
9109
9110	<	if test $ac_cv_header_stdc = yes; then
9111	<	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
9110	>	echo "$as_me:$LINENO: checking for working strtod" >&5
9111	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9112	>	if test "${ac_cv_func_strtod+set}" = set; then
9113	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9114	>	else
9115		if test "$cross_compiling" = yes; then
9116	<	:
9116	>	ac_cv_func_strtod=no
9117		else
9118		cat >conftest.$ac_ext <<_ACEOF
9119		/* confdefs.h.  */
#	Line 4892 | Line 9121 | cat >>conftest.$ac_ext <<_ACEOF
9121		cat confdefs.h >>conftest.$ac_ext
9122		cat >>conftest.$ac_ext <<_ACEOF
9123		/* end confdefs.h.  */
4895	–	#include <ctype.h>
4896	–	#if ((' ' & 0x0FF) == 0x020)
4897	–	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4898	–	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4899	–	#else
4900	–	# define ISLOWER(c) \
4901	–	(('a' <= (c) && (c) <= 'i') \
4902	–	|| ('j' <= (c) && (c) <= 'r') \
4903	–	|| ('s' <= (c) && (c) <= 'z'))
4904	–	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4905	–	#endif
9124
9125	<	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
9125	>	double strtod ();
9126		int
9127	<	main ()
9127	>	main()
9128		{
9129	<	int i;
9130	<	for (i = 0; i < 256; i++)
9131	<	if (XOR (islower (i), ISLOWER (i))
9132	<	|| toupper (i) != TOUPPER (i))
9133	<	exit(2);
9129	>	{
9130	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9131	>	char *string = " +69";
9132	>	char *term;
9133	>	double value;
9134	>	value = strtod (string, &term);
9135	>	if (value != 69 || term != (string + 4))
9136	>	exit (1);
9137	>	}
9138	>
9139	>	{
9140	>	/* Under Solaris 2.4, strtod returns the wrong value for the
9141	>	terminating character under some conditions.  */
9142	>	char *string = "NaN";
9143	>	char *term;
9144	>	strtod (string, &term);
9145	>	if (term != string && *(term - 1) == 0)
9146	>	exit (1);
9147	>	}
9148		exit (0);
9149		}
9150	+
9151		_ACEOF
9152		rm -f conftest$ac_exeext
9153		if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
#	Line 4927 | Line 9160 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9160		ac_status=$?
9161		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9162		(exit $ac_status); }; }; then
9163	<	:
9163	>	ac_cv_func_strtod=yes
9164		else
9165		echo "$as_me: program exited with status $ac_status" >&5
9166		echo "$as_me: failed program was:" >&5
9167		sed 's/^/| /' conftest.$ac_ext >&5
9168
9169		( exit $ac_status )
9170	<	ac_cv_header_stdc=no
9170	>	ac_cv_func_strtod=no
9171		fi
9172		rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9173		fi
9174		fi
9175	<	fi
9176	<	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9177	<	echo "${ECHO_T}$ac_cv_header_stdc" >&6
9178	<	if test $ac_cv_header_stdc = yes; then
9175	>	echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9176	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6
9177	>	if test $ac_cv_func_strtod = no; then
9178	>	case $LIBOBJS in
9179	>	"strtod.$ac_objext"   | \
9180	>	*" strtod.$ac_objext"   | \
9181	>	"strtod.$ac_objext "* | \
9182	>	*" strtod.$ac_objext "* ) ;;
9183	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9184	>	esac
9185
9186	<	cat >>confdefs.h <<\_ACEOF
9187	<	#define STDC_HEADERS 1
9188	<	_ACEOF
4950	<
4951	<	fi
4952	<
4953	<	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
4954	<
4955	<
4956	<
4957	<
4958	<
4959	<
4960	<
4961	<
4962	<
4963	<	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4964	<	inttypes.h stdint.h unistd.h
4965	<	do
4966	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4967	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
4968	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4969	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9186	>	echo "$as_me:$LINENO: checking for pow" >&5
9187	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6
9188	>	if test "${ac_cv_func_pow+set}" = set; then
9189		echo $ECHO_N "(cached) $ECHO_C" >&6
9190		else
9191		cat >conftest.$ac_ext <<_ACEOF
#	Line 4975 | Line 9194 | cat >>conftest.$ac_ext <<_ACEOF
9194		cat confdefs.h >>conftest.$ac_ext
9195		cat >>conftest.$ac_ext <<_ACEOF
9196		/* end confdefs.h.  */
9197	<	$ac_includes_default
9197	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
9198	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9199	>	#define pow innocuous_pow
9200
9201	<	#include <$ac_header>
9201	>	/* System header to define __stub macros and hopefully few prototypes,
9202	>	which can conflict with char pow (); below.
9203	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9204	>	<limits.h> exists even on freestanding compilers.  */
9205	>
9206	>	#ifdef __STDC__
9207	>	# include <limits.h>
9208	>	#else
9209	>	# include <assert.h>
9210	>	#endif
9211	>
9212	>	#undef pow
9213	>
9214	>	/* Override any gcc2 internal prototype to avoid an error.  */
9215	>	#ifdef __cplusplus
9216	>	extern "C"
9217	>	{
9218	>	#endif
9219	>	/* We use char because int might match the return type of a gcc2
9220	>	builtin and then its argument prototype would still apply.  */
9221	>	char pow ();
9222	>	/* The GNU C library defines this for functions which it implements
9223	>	to always fail with ENOSYS.  Some functions are actually named
9224	>	something starting with __ and the normal name is an alias.  */
9225	>	#if defined (__stub_pow) || defined (__stub___pow)
9226	>	choke me
9227	>	#else
9228	>	char (*f) () = pow;
9229	>	#endif
9230	>	#ifdef __cplusplus
9231	>	}
9232	>	#endif
9233	>
9234	>	#ifdef FC_DUMMY_MAIN
9235	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9236	>	#  ifdef __cplusplus
9237	>	extern "C"
9238	>	#  endif
9239	>	int FC_DUMMY_MAIN() { return 1; }
9240	>	#endif
9241	>	#endif
9242	>	int
9243	>	main ()
9244	>	{
9245	>	return f != pow;
9246	>	;
9247	>	return 0;
9248	>	}
9249		_ACEOF
9250	<	rm -f conftest.$ac_objext
9251	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9252	<	(eval $ac_compile) 2>conftest.er1
9250	>	rm -f conftest.$ac_objext conftest$ac_exeext
9251	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9252	>	(eval $ac_link) 2>conftest.er1
9253		ac_status=$?
9254		grep -v '^ *+' conftest.er1 >conftest.err
9255		rm -f conftest.er1
9256		cat conftest.err >&5
9257		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9258		(exit $ac_status); } &&
9259	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9259	>	{ ac_try='test -z "$ac_c_werror_flag"
9260	>	|| test ! -s conftest.err'
9261		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9262		(eval $ac_try) 2>&5
9263		ac_status=$?
9264		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9265		(exit $ac_status); }; } &&
9266	<	{ ac_try='test -s conftest.$ac_objext'
9266	>	{ ac_try='test -s conftest$ac_exeext'
9267		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9268		(eval $ac_try) 2>&5
9269		ac_status=$?
9270		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9271		(exit $ac_status); }; }; then
9272	<	eval "$as_ac_Header=yes"
9272	>	ac_cv_func_pow=yes
9273		else
9274		echo "$as_me: failed program was:" >&5
9275		sed 's/^/| /' conftest.$ac_ext >&5
9276
9277	<	eval "$as_ac_Header=no"
9277	>	ac_cv_func_pow=no
9278		fi
9279	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9279	>	rm -f conftest.err conftest.$ac_objext \
9280	>	conftest$ac_exeext conftest.$ac_ext
9281		fi
9282	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9283	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5014	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5015	<	cat >>confdefs.h <<_ACEOF
5016	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5017	<	_ACEOF
9282	>	echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9283	>	echo "${ECHO_T}$ac_cv_func_pow" >&6
9284
9285	<	fi
9286	<
9287	<	done
9288	<
5023	<
5024	<	#
5025	<	# Handle user hints
5026	<	#
5027	<	echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5028	<	echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5029	<
5030	<	# Check whether --with-zlib or --without-zlib was given.
5031	<	if test "${with_zlib+set}" = set; then
5032	<	withval="$with_zlib"
5033	<	if test "$withval" != no ; then
5034	<	echo "$as_me:$LINENO: result: yes" >&5
5035	<	echo "${ECHO_T}yes" >&6
5036	<	if test -d "$withval"
5037	<	then
5038	<	ZLIB_HOME="$withval"
5039	<	else
5040	<	{ echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5041	<	echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5042	<	fi
5043	<	else
5044	<	echo "$as_me:$LINENO: result: no" >&5
5045	<	echo "${ECHO_T}no" >&6
5046	<	fi
5047	<	fi;
5048	<
5049	<	ZLIB_HOME=/usr/local
5050	<	if test ! -f "${ZLIB_HOME}/include/zlib.h"
5051	<	then
5052	<	ZLIB_HOME=/usr
5053	<	fi
5054	<
5055	<	#
5056	<	# Locate zlib, if wanted
5057	<	#
5058	<	if test -n "${ZLIB_HOME}"
5059	<	then
5060	<	ZLIB_OLD_LDFLAGS=$LDFLAGS
5061	<	ZLIB_OLD_CPPFLAGS=$LDFLAGS
5062	<	LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5063	<	CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5064	<
5065	<
5066	<	ac_ext=c
5067	<	ac_cpp='$CPP $CPPFLAGS'
5068	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5069	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5070	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5071	<
5072	<	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5073	<	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5074	<	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
9285	>	if test $ac_cv_func_pow = no; then
9286	>	echo "$as_me:$LINENO: checking for pow in -lm" >&5
9287	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9288	>	if test "${ac_cv_lib_m_pow+set}" = set; then
9289		echo $ECHO_N "(cached) $ECHO_C" >&6
9290		else
9291		ac_check_lib_save_LIBS=$LIBS
9292	<	LIBS="-lz  $LIBS"
9292	>	LIBS="-lm  $LIBS"
9293		cat >conftest.$ac_ext <<_ACEOF
9294		/* confdefs.h.  */
9295		_ACEOF
#	Line 5089 | Line 9303 | extern "C"
9303		#endif
9304		/* We use char because int might match the return type of a gcc2
9305		builtin and then its argument prototype would still apply.  */
9306	<	char inflateEnd ();
9306	>	char pow ();
9307	>	#ifdef FC_DUMMY_MAIN
9308	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9309	>	#  ifdef __cplusplus
9310	>	extern "C"
9311	>	#  endif
9312	>	int FC_DUMMY_MAIN() { return 1; }
9313	>	#endif
9314	>	#endif
9315		int
9316		main ()
9317		{
9318	<	inflateEnd ();
9318	>	pow ();
9319		;
9320		return 0;
9321		}
#	Line 5107 | Line 9329 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9329		cat conftest.err >&5
9330		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9331		(exit $ac_status); } &&
9332	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9332	>	{ ac_try='test -z "$ac_c_werror_flag"
9333	>	|| test ! -s conftest.err'
9334		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9335		(eval $ac_try) 2>&5
9336		ac_status=$?
#	Line 5119 | Line 9342 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9342		ac_status=$?
9343		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9344		(exit $ac_status); }; }; then
9345	<	ac_cv_lib_z_inflateEnd=yes
9345	>	ac_cv_lib_m_pow=yes
9346		else
9347		echo "$as_me: failed program was:" >&5
9348		sed 's/^/| /' conftest.$ac_ext >&5
9349
9350	<	ac_cv_lib_z_inflateEnd=no
9350	>	ac_cv_lib_m_pow=no
9351		fi
9352		rm -f conftest.err conftest.$ac_objext \
9353		conftest$ac_exeext conftest.$ac_ext
9354		LIBS=$ac_check_lib_save_LIBS
9355		fi
9356	<	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
9357	<	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
9358	<	if test $ac_cv_lib_z_inflateEnd = yes; then
9359	<	zlib_cv_libz=yes
9356	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9357	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9358	>	if test $ac_cv_lib_m_pow = yes; then
9359	>	POW_LIB=-lm
9360		else
9361	<	zlib_cv_libz=no
9361	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9362	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9363		fi
9364
5141	–	if test "${ac_cv_header_zlib_h+set}" = set; then
5142	–	echo "$as_me:$LINENO: checking for zlib.h" >&5
5143	–	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5144	–	if test "${ac_cv_header_zlib_h+set}" = set; then
5145	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9365		fi
9366	<	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
9367	<	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9366	>
9367	>	fi
9368	>
9369	>
9370	>
9371	>
9372	>
9373	>
9374	>
9375	>
9376	>
9377	>
9378	>
9379	>
9380	>
9381	>
9382	>
9383	>
9384	>
9385	>
9386	>
9387	>
9388	>
9389	>
9390	>
9391	>
9392	>
9393	>
9394	>
9395	>
9396	>	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
9397	>	do
9398	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9399	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9400	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9401	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9402	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9403		else
9404	<	# Is the header compilable?
5151	<	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5152	<	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5153	<	cat >conftest.$ac_ext <<_ACEOF
9404	>	cat >conftest.$ac_ext <<_ACEOF
9405		/* confdefs.h.  */
9406		_ACEOF
9407		cat confdefs.h >>conftest.$ac_ext
9408		cat >>conftest.$ac_ext <<_ACEOF
9409		/* end confdefs.h.  */
9410	<	$ac_includes_default
9411	<	#include <zlib.h>
9410	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9411	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9412	>	#define $ac_func innocuous_$ac_func
9413	>
9414	>	/* System header to define __stub macros and hopefully few prototypes,
9415	>	which can conflict with char $ac_func (); below.
9416	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9417	>	<limits.h> exists even on freestanding compilers.  */
9418	>
9419	>	#ifdef __STDC__
9420	>	# include <limits.h>
9421	>	#else
9422	>	# include <assert.h>
9423	>	#endif
9424	>
9425	>	#undef $ac_func
9426	>
9427	>	/* Override any gcc2 internal prototype to avoid an error.  */
9428	>	#ifdef __cplusplus
9429	>	extern "C"
9430	>	{
9431	>	#endif
9432	>	/* We use char because int might match the return type of a gcc2
9433	>	builtin and then its argument prototype would still apply.  */
9434	>	char $ac_func ();
9435	>	/* The GNU C library defines this for functions which it implements
9436	>	to always fail with ENOSYS.  Some functions are actually named
9437	>	something starting with __ and the normal name is an alias.  */
9438	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9439	>	choke me
9440	>	#else
9441	>	char (*f) () = $ac_func;
9442	>	#endif
9443	>	#ifdef __cplusplus
9444	>	}
9445	>	#endif
9446	>
9447	>	#ifdef FC_DUMMY_MAIN
9448	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9449	>	#  ifdef __cplusplus
9450	>	extern "C"
9451	>	#  endif
9452	>	int FC_DUMMY_MAIN() { return 1; }
9453	>	#endif
9454	>	#endif
9455	>	int
9456	>	main ()
9457	>	{
9458	>	return f != $ac_func;
9459	>	;
9460	>	return 0;
9461	>	}
9462		_ACEOF
9463	<	rm -f conftest.$ac_objext
9464	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9465	<	(eval $ac_compile) 2>conftest.er1
9463	>	rm -f conftest.$ac_objext conftest$ac_exeext
9464	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9465	>	(eval $ac_link) 2>conftest.er1
9466		ac_status=$?
9467		grep -v '^ *+' conftest.er1 >conftest.err
9468		rm -f conftest.er1
9469		cat conftest.err >&5
9470		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9471		(exit $ac_status); } &&
9472	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9472	>	{ ac_try='test -z "$ac_c_werror_flag"
9473	>	|| test ! -s conftest.err'
9474		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9475		(eval $ac_try) 2>&5
9476		ac_status=$?
9477		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9478		(exit $ac_status); }; } &&
9479	<	{ ac_try='test -s conftest.$ac_objext'
9479	>	{ ac_try='test -s conftest$ac_exeext'
9480		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9481		(eval $ac_try) 2>&5
9482		ac_status=$?
9483		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9484		(exit $ac_status); }; }; then
9485	<	ac_header_compiler=yes
9485	>	eval "$as_ac_var=yes"
9486		else
9487		echo "$as_me: failed program was:" >&5
9488		sed 's/^/| /' conftest.$ac_ext >&5
9489
9490	<	ac_header_compiler=no
9490	>	eval "$as_ac_var=no"
9491		fi
9492	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9493	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5192	<	echo "${ECHO_T}$ac_header_compiler" >&6
5193	<
5194	<	# Is the header present?
5195	<	echo "$as_me:$LINENO: checking zlib.h presence" >&5
5196	<	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5197	<	cat >conftest.$ac_ext <<_ACEOF
5198	<	/* confdefs.h.  */
5199	<	_ACEOF
5200	<	cat confdefs.h >>conftest.$ac_ext
5201	<	cat >>conftest.$ac_ext <<_ACEOF
5202	<	/* end confdefs.h.  */
5203	<	#include <zlib.h>
5204	<	_ACEOF
5205	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5206	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5207	<	ac_status=$?
5208	<	grep -v '^ *+' conftest.er1 >conftest.err
5209	<	rm -f conftest.er1
5210	<	cat conftest.err >&5
5211	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5212	<	(exit $ac_status); } >/dev/null; then
5213	<	if test -s conftest.err; then
5214	<	ac_cpp_err=$ac_c_preproc_warn_flag
5215	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5216	<	else
5217	<	ac_cpp_err=
5218	<	fi
5219	<	else
5220	<	ac_cpp_err=yes
9492	>	rm -f conftest.err conftest.$ac_objext \
9493	>	conftest$ac_exeext conftest.$ac_ext
9494		fi
9495	<	if test -z "$ac_cpp_err"; then
9496	<	ac_header_preproc=yes
9497	<	else
9498	<	echo "$as_me: failed program was:" >&5
9499	<	sed 's/^/| /' conftest.$ac_ext >&5
9495	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9496	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9497	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9498	>	cat >>confdefs.h <<_ACEOF
9499	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9500	>	_ACEOF
9501
5228	–	ac_header_preproc=no
9502		fi
9503	<	rm -f conftest.err conftest.$ac_ext
5231	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5232	<	echo "${ECHO_T}$ac_header_preproc" >&6
9503	>	done
9504
5234	–	# So?  What about this header?
5235	–	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5236	–	yes:no: )
5237	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5238	–	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5239	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5240	–	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5241	–	ac_header_preproc=yes
5242	–	;;
5243	–	no:yes:* )
5244	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5245	–	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5246	–	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5247	–	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5248	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5249	–	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5250	–	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5251	–	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5252	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5253	–	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5254	–	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5255	–	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5256	–	(
5257	–	cat <<\_ASBOX
5258	–	## ------------------------------ ##
5259	–	## Report this to gezelter@nd.edu ##
5260	–	## ------------------------------ ##
5261	–	_ASBOX
5262	–	) |
5263	–	sed "s/^/$as_me: WARNING:     /" >&2
5264	–	;;
5265	–	esac
5266	–	echo "$as_me:$LINENO: checking for zlib.h" >&5
5267	–	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5268	–	if test "${ac_cv_header_zlib_h+set}" = set; then
5269	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5270	–	else
5271	–	ac_cv_header_zlib_h=$ac_header_preproc
5272	–	fi
5273	–	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5274	–	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9505
9506	<	fi
9507	<	if test $ac_cv_header_zlib_h = yes; then
9508	<	zlib_cv_zlib_h=yes
9509	<	else
5280	<	zlib_cv_zlib_h=no
5281	<	fi
5282	<
5283	<
5284	<	ac_ext=c
5285	<	ac_cpp='$CPP $CPPFLAGS'
5286	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5287	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5288	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5289	<
5290	<	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
5291	<	then
5292	<	#
5293	<	# If both library and header were found, use them
5294	<	#
5295	<
5296	<	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5297	<	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5298	<	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5299	<	echo $ECHO_N "(cached) $ECHO_C" >&6
5300	<	else
5301	<	ac_check_lib_save_LIBS=$LIBS
5302	<	LIBS="-lz  $LIBS"
9506	>	# special check for _system_configuration because AIX <4.3.2 do not
9507	>	# contain the `physmem' member.
9508	>	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9509	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9510		cat >conftest.$ac_ext <<_ACEOF
9511		/* confdefs.h.  */
9512		_ACEOF
9513		cat confdefs.h >>conftest.$ac_ext
9514		cat >>conftest.$ac_ext <<_ACEOF
9515		/* end confdefs.h.  */
9516	<
9517	<	/* Override any gcc2 internal prototype to avoid an error.  */
9518	<	#ifdef __cplusplus
9519	<	extern "C"
9516	>	#include <sys/systemcfg.h>
9517	>	#ifdef FC_DUMMY_MAIN
9518	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9519	>	#  ifdef __cplusplus
9520	>	extern "C"
9521	>	#  endif
9522	>	int FC_DUMMY_MAIN() { return 1; }
9523		#endif
9524	<	/* We use char because int might match the return type of a gcc2
5315	<	builtin and then its argument prototype would still apply.  */
5316	<	char inflateEnd ();
9524	>	#endif
9525		int
9526		main ()
9527		{
9528	<	inflateEnd ();
9528	>	double x = _system_configuration.physmem;
9529		;
9530		return 0;
9531		}
9532		_ACEOF
9533	<	rm -f conftest.$ac_objext conftest$ac_exeext
9534	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9535	<	(eval $ac_link) 2>conftest.er1
9533	>	rm -f conftest.$ac_objext
9534	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9535	>	(eval $ac_compile) 2>conftest.er1
9536		ac_status=$?
9537		grep -v '^ *+' conftest.er1 >conftest.err
9538		rm -f conftest.er1
9539		cat conftest.err >&5
9540		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541		(exit $ac_status); } &&
9542	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9542	>	{ ac_try='test -z "$ac_c_werror_flag"
9543	>	|| test ! -s conftest.err'
9544		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9545		(eval $ac_try) 2>&5
9546		ac_status=$?
9547		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9548		(exit $ac_status); }; } &&
9549	<	{ ac_try='test -s conftest$ac_exeext'
9549	>	{ ac_try='test -s conftest.$ac_objext'
9550		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9551		(eval $ac_try) 2>&5
9552		ac_status=$?
9553		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554		(exit $ac_status); }; }; then
9555	<	ac_cv_lib_z_inflateEnd=yes
9555	>	echo "$as_me:$LINENO: result: yes" >&5
9556	>	echo "${ECHO_T}yes" >&6
9557	>
9558	>	cat >>confdefs.h <<\_ACEOF
9559	>	#define HAVE__SYSTEM_CONFIGURATION 1
9560	>	_ACEOF
9561	>
9562		else
9563		echo "$as_me: failed program was:" >&5
9564		sed 's/^/| /' conftest.$ac_ext >&5
9565
9566	<	ac_cv_lib_z_inflateEnd=no
9566	>	echo "$as_me:$LINENO: result: no" >&5
9567	>	echo "${ECHO_T}no" >&6
9568		fi
9569	<	rm -f conftest.err conftest.$ac_objext \
5354	<	conftest$ac_exeext conftest.$ac_ext
5355	<	LIBS=$ac_check_lib_save_LIBS
5356	<	fi
5357	<	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5358	<	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5359	<	if test $ac_cv_lib_z_inflateEnd = yes; then
5360	<	cat >>confdefs.h <<_ACEOF
5361	<	#define HAVE_LIBZ 1
5362	<	_ACEOF
9569	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9570
9571	<	LIBS="-lz $LIBS"
9571	>	# clean out junk possibly left behind by a previous configuration
9572	>	rm -f src/getopt.h
9573	>	# Check for getopt_long support
9574
9575	<	fi
5367	<
5368	<	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5369	<	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5370	<	echo "$as_me:$LINENO: result: ok" >&5
5371	<	echo "${ECHO_T}ok" >&6
5372	<	else
5373	<	#
5374	<	# If either header or library was not found, revert and bomb
5375	<	#
5376	<	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5377	<	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5378	<	LDFLAGS="$ZLIB_OLD_LDFLAGS"
5379	<	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5380	<	echo "$as_me:$LINENO: result: failed" >&5
5381	<	echo "${ECHO_T}failed" >&6
5382	<	{ { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5383	<	echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5384	<	{ (exit 1); exit 1; }; }
5385	<	fi
5386	<	fi
5387	<
5388	<
5389	<
5390	<
5391	<
5392	<
5393	<
5394	<
5395	<	for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
9575	>	for ac_header in getopt.h
9576		do
9577		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9578		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 5425 | Line 9605 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9605		cat conftest.err >&5
9606		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9607		(exit $ac_status); } &&
9608	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9608	>	{ ac_try='test -z "$ac_c_werror_flag"
9609	>	|| test ! -s conftest.err'
9610		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9611		(eval $ac_try) 2>&5
9612		ac_status=$?
#	Line 5541 | Line 9722 | done
9722		done
9723
9724
9725	<
5545	<
5546	<
5547	<
5548	<	for ac_header in strstream.h iostream.h fstream.h math.h time.h
9725	>	for ac_func in getopt_long
9726		do
9727	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9728	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9729	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
9730	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5554	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9727	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9728	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9729	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9730	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9731		echo $ECHO_N "(cached) $ECHO_C" >&6
5556	–	fi
5557	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5558	–	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9732		else
9733	<	# Is the header compilable?
5561	<	echo "$as_me:$LINENO: checking $ac_header usability" >&5
5562	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5563	<	cat >conftest.$ac_ext <<_ACEOF
9733	>	cat >conftest.$ac_ext <<_ACEOF
9734		/* confdefs.h.  */
9735		_ACEOF
9736		cat confdefs.h >>conftest.$ac_ext
9737		cat >>conftest.$ac_ext <<_ACEOF
9738		/* end confdefs.h.  */
9739	<	$ac_includes_default
9740	<	#include <$ac_header>
9739	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9740	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9741	>	#define $ac_func innocuous_$ac_func
9742	>
9743	>	/* System header to define __stub macros and hopefully few prototypes,
9744	>	which can conflict with char $ac_func (); below.
9745	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9746	>	<limits.h> exists even on freestanding compilers.  */
9747	>
9748	>	#ifdef __STDC__
9749	>	# include <limits.h>
9750	>	#else
9751	>	# include <assert.h>
9752	>	#endif
9753	>
9754	>	#undef $ac_func
9755	>
9756	>	/* Override any gcc2 internal prototype to avoid an error.  */
9757	>	#ifdef __cplusplus
9758	>	extern "C"
9759	>	{
9760	>	#endif
9761	>	/* We use char because int might match the return type of a gcc2
9762	>	builtin and then its argument prototype would still apply.  */
9763	>	char $ac_func ();
9764	>	/* The GNU C library defines this for functions which it implements
9765	>	to always fail with ENOSYS.  Some functions are actually named
9766	>	something starting with __ and the normal name is an alias.  */
9767	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9768	>	choke me
9769	>	#else
9770	>	char (*f) () = $ac_func;
9771	>	#endif
9772	>	#ifdef __cplusplus
9773	>	}
9774	>	#endif
9775	>
9776	>	#ifdef FC_DUMMY_MAIN
9777	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9778	>	#  ifdef __cplusplus
9779	>	extern "C"
9780	>	#  endif
9781	>	int FC_DUMMY_MAIN() { return 1; }
9782	>	#endif
9783	>	#endif
9784	>	int
9785	>	main ()
9786	>	{
9787	>	return f != $ac_func;
9788	>	;
9789	>	return 0;
9790	>	}
9791		_ACEOF
9792	<	rm -f conftest.$ac_objext
9793	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9794	<	(eval $ac_compile) 2>conftest.er1
9792	>	rm -f conftest.$ac_objext conftest$ac_exeext
9793	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9794	>	(eval $ac_link) 2>conftest.er1
9795		ac_status=$?
9796		grep -v '^ *+' conftest.er1 >conftest.err
9797		rm -f conftest.er1
9798		cat conftest.err >&5
9799		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9800		(exit $ac_status); } &&
9801	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9801	>	{ ac_try='test -z "$ac_c_werror_flag"
9802	>	|| test ! -s conftest.err'
9803		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9804		(eval $ac_try) 2>&5
9805		ac_status=$?
9806		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9807		(exit $ac_status); }; } &&
9808	<	{ ac_try='test -s conftest.$ac_objext'
9808	>	{ ac_try='test -s conftest$ac_exeext'
9809		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9810		(eval $ac_try) 2>&5
9811		ac_status=$?
9812		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9813		(exit $ac_status); }; }; then
9814	<	ac_header_compiler=yes
9814	>	eval "$as_ac_var=yes"
9815		else
9816		echo "$as_me: failed program was:" >&5
9817		sed 's/^/| /' conftest.$ac_ext >&5
9818
9819	<	ac_header_compiler=no
9819	>	eval "$as_ac_var=no"
9820		fi
9821	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9822	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9823	<	echo "${ECHO_T}$ac_header_compiler" >&6
9821	>	rm -f conftest.err conftest.$ac_objext \
9822	>	conftest$ac_exeext conftest.$ac_ext
9823	>	fi
9824	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9825	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9826	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9827	>	cat >>confdefs.h <<_ACEOF
9828	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9829	>	_ACEOF
9830
9831	<	# Is the header present?
9832	<	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9833	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9831	>	else
9832	>	# FreeBSD has a gnugetopt library for this
9833	>	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9834	>	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9835	>	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9836	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9837	>	else
9838	>	ac_check_lib_save_LIBS=$LIBS
9839	>	LIBS="-lgnugetopt  $LIBS"
9840		cat >conftest.$ac_ext <<_ACEOF
9841		/* confdefs.h.  */
9842		_ACEOF
9843		cat confdefs.h >>conftest.$ac_ext
9844		cat >>conftest.$ac_ext <<_ACEOF
9845		/* end confdefs.h.  */
9846	<	#include <$ac_header>
9846	>
9847	>	/* Override any gcc2 internal prototype to avoid an error.  */
9848	>	#ifdef __cplusplus
9849	>	extern "C"
9850	>	#endif
9851	>	/* We use char because int might match the return type of a gcc2
9852	>	builtin and then its argument prototype would still apply.  */
9853	>	char getopt_long ();
9854	>	#ifdef FC_DUMMY_MAIN
9855	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9856	>	#  ifdef __cplusplus
9857	>	extern "C"
9858	>	#  endif
9859	>	int FC_DUMMY_MAIN() { return 1; }
9860	>	#endif
9861	>	#endif
9862	>	int
9863	>	main ()
9864	>	{
9865	>	getopt_long ();
9866	>	;
9867	>	return 0;
9868	>	}
9869		_ACEOF
9870	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9871	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9870	>	rm -f conftest.$ac_objext conftest$ac_exeext
9871	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9872	>	(eval $ac_link) 2>conftest.er1
9873		ac_status=$?
9874		grep -v '^ *+' conftest.er1 >conftest.err
9875		rm -f conftest.er1
9876		cat conftest.err >&5
9877		echo "$as_me:$LINENO: \$? = $ac_status" >&5
9878	<	(exit $ac_status); } >/dev/null; then
9879	<	if test -s conftest.err; then
9880	<	ac_cpp_err=$ac_c_preproc_warn_flag
9881	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9882	<	else
9883	<	ac_cpp_err=
9884	<	fi
9878	>	(exit $ac_status); } &&
9879	>	{ ac_try='test -z "$ac_c_werror_flag"
9880	>	|| test ! -s conftest.err'
9881	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9882	>	(eval $ac_try) 2>&5
9883	>	ac_status=$?
9884	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9885	>	(exit $ac_status); }; } &&
9886	>	{ ac_try='test -s conftest$ac_exeext'
9887	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9888	>	(eval $ac_try) 2>&5
9889	>	ac_status=$?
9890	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9891	>	(exit $ac_status); }; }; then
9892	>	ac_cv_lib_gnugetopt_getopt_long=yes
9893		else
5630	–	ac_cpp_err=yes
5631	–	fi
5632	–	if test -z "$ac_cpp_err"; then
5633	–	ac_header_preproc=yes
5634	–	else
9894		echo "$as_me: failed program was:" >&5
9895		sed 's/^/| /' conftest.$ac_ext >&5
9896
9897	<	ac_header_preproc=no
9897	>	ac_cv_lib_gnugetopt_getopt_long=no
9898		fi
9899	<	rm -f conftest.err conftest.$ac_ext
9900	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9901	<	echo "${ECHO_T}$ac_header_preproc" >&6
9899	>	rm -f conftest.err conftest.$ac_objext \
9900	>	conftest$ac_exeext conftest.$ac_ext
9901	>	LIBS=$ac_check_lib_save_LIBS
9902	>	fi
9903	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9904	>	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9905	>	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9906	>	cat >>confdefs.h <<\_ACEOF
9907	>	#define HAVE_GETOPT_LONG 1
9908	>	_ACEOF
9909
9910	<	# So?  What about this header?
9911	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9912	<	yes:no: )
9913	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9914	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9915	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9916	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9917	<	ac_header_preproc=yes
5652	<	;;
5653	<	no:yes:* )
5654	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5655	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5656	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5657	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5658	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5659	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5660	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5661	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5662	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5663	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5664	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5665	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5666	<	(
5667	<	cat <<\_ASBOX
5668	<	## ------------------------------ ##
5669	<	## Report this to gezelter@nd.edu ##
5670	<	## ------------------------------ ##
5671	<	_ASBOX
5672	<	) |
5673	<	sed "s/^/$as_me: WARNING:     /" >&2
5674	<	;;
9910	>	else
9911	>	# use the GNU replacement
9912	>	case $LIBOBJS in
9913	>	"getopt.$ac_objext"   | \
9914	>	*" getopt.$ac_objext"   | \
9915	>	"getopt.$ac_objext "* | \
9916	>	*" getopt.$ac_objext "* ) ;;
9917	>	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9918		esac
9919	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
9920	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9921	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9919	>
9920	>	case $LIBOBJS in
9921	>	"getopt1.$ac_objext"   | \
9922	>	*" getopt1.$ac_objext"   | \
9923	>	"getopt1.$ac_objext "* | \
9924	>	*" getopt1.$ac_objext "* ) ;;
9925	>	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9926	>	esac
9927	>
9928	>	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9929	>
9930	>	fi
9931	>
9932	>	fi
9933	>	done
9934	>
9935	>
9936	>	ac_ext=cc
9937	>	ac_cpp='$CXXCPP $CPPFLAGS'
9938	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9939	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9940	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9941	>
9942	>
9943	>	echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9944	>	echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9945	>	if test "${ac_cv_cxx_namespaces+set}" = set; then
9946		echo $ECHO_N "(cached) $ECHO_C" >&6
9947		else
9948	<	eval "$as_ac_Header=\$ac_header_preproc"
9949	<	fi
9950	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9951	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9948	>
9949	>
9950	>	ac_ext=cc
9951	>	ac_cpp='$CXXCPP $CPPFLAGS'
9952	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9953	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9954	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9955
9956	<	fi
9957	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5688	<	cat >>confdefs.h <<_ACEOF
5689	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9956	>	cat >conftest.$ac_ext <<_ACEOF
9957	>	/* confdefs.h.  */
9958		_ACEOF
9959	+	cat confdefs.h >>conftest.$ac_ext
9960	+	cat >>conftest.$ac_ext <<_ACEOF
9961	+	/* end confdefs.h.  */
9962	+	namespace Outer { namespace Inner { int i = 0; }}
9963	+	#ifdef FC_DUMMY_MAIN
9964	+	#ifndef FC_DUMMY_MAIN_EQ_F77
9965	+	#  ifdef __cplusplus
9966	+	extern "C"
9967	+	#  endif
9968	+	int FC_DUMMY_MAIN() { return 1; }
9969	+	#endif
9970	+	#endif
9971	+	int
9972	+	main ()
9973	+	{
9974	+	using namespace Outer::Inner; return i;
9975	+	;
9976	+	return 0;
9977	+	}
9978	+	_ACEOF
9979	+	rm -f conftest.$ac_objext
9980	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9981	+	(eval $ac_compile) 2>conftest.er1
9982	+	ac_status=$?
9983	+	grep -v '^ *+' conftest.er1 >conftest.err
9984	+	rm -f conftest.er1
9985	+	cat conftest.err >&5
9986	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9987	+	(exit $ac_status); } &&
9988	+	{ ac_try='test -z "$ac_cxx_werror_flag"
9989	+	|| test ! -s conftest.err'
9990	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9991	+	(eval $ac_try) 2>&5
9992	+	ac_status=$?
9993	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9994	+	(exit $ac_status); }; } &&
9995	+	{ ac_try='test -s conftest.$ac_objext'
9996	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9997	+	(eval $ac_try) 2>&5
9998	+	ac_status=$?
9999	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10000	+	(exit $ac_status); }; }; then
10001	+	ac_cv_cxx_namespaces=yes
10002	+	else
10003	+	echo "$as_me: failed program was:" >&5
10004	+	sed 's/^/| /' conftest.$ac_ext >&5
10005
10006	+	ac_cv_cxx_namespaces=no
10007		fi
10008	<
10009	<	done
5695	<
5696	<	ac_ext=cc
10008	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10009	>	ac_ext=cc
10010		ac_cpp='$CXXCPP $CPPFLAGS'
10011		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10012		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10013		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10014	+
10015	+
10016	+	fi
10017	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10018	+	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10019	+	if test "$ac_cv_cxx_namespaces" = yes; then
10020	+
10021	+	cat >>confdefs.h <<\_ACEOF
10022	+	#define HAVE_NAMESPACES
10023	+	_ACEOF
10024
10025	+	fi
10026	+
10027		ac_ext=cc
10028		ac_cpp='$CXXCPP $CPPFLAGS'
10029		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 5924 | Line 10249 | ac_ext=cc
10249		fi
10250
10251		ac_ext=cc
10252	+	ac_cpp='$CXXCPP $CPPFLAGS'
10253	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10254	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10255	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10256	+
10257	+
10258	+	echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10259	+	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10260	+	if test "${ac_cv_cxx_have_stl+set}" = set; then
10261	+	echo $ECHO_N "(cached) $ECHO_C" >&6
10262	+	else
10263	+
10264	+
10265	+
10266	+	ac_ext=cc
10267	+	ac_cpp='$CXXCPP $CPPFLAGS'
10268	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10269	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10270	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10271	+
10272	+	cat >conftest.$ac_ext <<_ACEOF
10273	+	/* confdefs.h.  */
10274	+	_ACEOF
10275	+	cat confdefs.h >>conftest.$ac_ext
10276	+	cat >>conftest.$ac_ext <<_ACEOF
10277	+	/* end confdefs.h.  */
10278	+	#include <list>
10279	+	#include <deque>
10280	+	#ifdef HAVE_NAMESPACES
10281	+	using namespace std;
10282	+	#endif
10283	+	#ifdef FC_DUMMY_MAIN
10284	+	#ifndef FC_DUMMY_MAIN_EQ_F77
10285	+	#  ifdef __cplusplus
10286	+	extern "C"
10287	+	#  endif
10288	+	int FC_DUMMY_MAIN() { return 1; }
10289	+	#endif
10290	+	#endif
10291	+	int
10292	+	main ()
10293	+	{
10294	+	list<int> x; x.push_back(5);
10295	+	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10296	+	;
10297	+	return 0;
10298	+	}
10299	+	_ACEOF
10300	+	rm -f conftest.$ac_objext
10301	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10302	+	(eval $ac_compile) 2>conftest.er1
10303	+	ac_status=$?
10304	+	grep -v '^ *+' conftest.er1 >conftest.err
10305	+	rm -f conftest.er1
10306	+	cat conftest.err >&5
10307	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10308	+	(exit $ac_status); } &&
10309	+	{ ac_try='test -z "$ac_cxx_werror_flag"
10310	+	|| test ! -s conftest.err'
10311	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10312	+	(eval $ac_try) 2>&5
10313	+	ac_status=$?
10314	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10315	+	(exit $ac_status); }; } &&
10316	+	{ ac_try='test -s conftest.$ac_objext'
10317	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10318	+	(eval $ac_try) 2>&5
10319	+	ac_status=$?
10320	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10321	+	(exit $ac_status); }; }; then
10322	+	ac_cv_cxx_have_stl=yes
10323	+	else
10324	+	echo "$as_me: failed program was:" >&5
10325	+	sed 's/^/| /' conftest.$ac_ext >&5
10326	+
10327	+	ac_cv_cxx_have_stl=no
10328	+	fi
10329	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10330	+	ac_ext=cc
10331		ac_cpp='$CXXCPP $CPPFLAGS'
10332		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10333		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10334		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10335
10336
10337	+	fi
10338	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10339	+	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10340	+	if test "$ac_cv_cxx_have_stl" = yes; then
10341
10342	+	cat >>confdefs.h <<\_ACEOF
10343	+	#define HAVE_STL
10344	+	_ACEOF
10345
10346	+	fi
10347
10348
10349
10350	<	for ac_header in ctype.h iostream fstream sstream strstream
10351	<	do
10352	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10353	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5942	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
5943	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5944	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10350	>	if test "${ac_cv_header_iostream+set}" = set; then
10351	>	echo "$as_me:$LINENO: checking for iostream" >&5
10352	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10353	>	if test "${ac_cv_header_iostream+set}" = set; then
10354		echo $ECHO_N "(cached) $ECHO_C" >&6
10355		fi
10356	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10357	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10356	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10357	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10358		else
10359		# Is the header compilable?
10360	<	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10361	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10360	>	echo "$as_me:$LINENO: checking iostream usability" >&5
10361	>	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10362		cat >conftest.$ac_ext <<_ACEOF
10363		/* confdefs.h.  */
10364		_ACEOF
#	Line 5957 | Line 10366 | $ac_includes_default
10366		cat >>conftest.$ac_ext <<_ACEOF
10367		/* end confdefs.h.  */
10368		$ac_includes_default
10369	<	#include <$ac_header>
10369	>	#include <iostream>
10370		_ACEOF
10371		rm -f conftest.$ac_objext
10372		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 5968 | Line 10377 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10377		cat conftest.err >&5
10378		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10379		(exit $ac_status); } &&
10380	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
10380	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10381	>	|| test ! -s conftest.err'
10382		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10383		(eval $ac_try) 2>&5
10384		ac_status=$?
#	Line 5992 | Line 10402 | echo "${ECHO_T}$ac_header_compiler" >&6
10402		echo "${ECHO_T}$ac_header_compiler" >&6
10403
10404		# Is the header present?
10405	<	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10406	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10405	>	echo "$as_me:$LINENO: checking iostream presence" >&5
10406	>	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10407		cat >conftest.$ac_ext <<_ACEOF
10408		/* confdefs.h.  */
10409		_ACEOF
10410		cat confdefs.h >>conftest.$ac_ext
10411		cat >>conftest.$ac_ext <<_ACEOF
10412		/* end confdefs.h.  */
10413	<	#include <$ac_header>
10413	>	#include <iostream>
10414		_ACEOF
10415		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10416		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 6034 | Line 10444 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
10444		# So?  What about this header?
10445		case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10446		yes:no: )
10447	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10448	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10449	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10450	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10447	>	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10448	>	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10449	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10450	>	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10451		ac_header_preproc=yes
10452		;;
10453		no:yes:* )
10454	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10455	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10456	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10457	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10458	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10459	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10460	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10461	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10462	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10463	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10464	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10465	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10454	>	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10455	>	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10456	>	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10457	>	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10458	>	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10459	>	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10460	>	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10461	>	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10462	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10463	>	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10464	>	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10465	>	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10466		(
10467		cat <<\_ASBOX
10468		## ------------------------------ ##
#	Line 6063 | Line 10473 | esac
10473		sed "s/^/$as_me: WARNING:     /" >&2
10474		;;
10475		esac
10476	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
10477	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10478	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10476	>	echo "$as_me:$LINENO: checking for iostream" >&5
10477	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10478	>	if test "${ac_cv_header_iostream+set}" = set; then
10479		echo $ECHO_N "(cached) $ECHO_C" >&6
10480		else
10481	<	eval "$as_ac_Header=\$ac_header_preproc"
10481	>	ac_cv_header_iostream=$ac_header_preproc
10482		fi
10483	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10484	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10483	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10484	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10485
10486		fi
10487	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
6078	<	cat >>confdefs.h <<_ACEOF
6079	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6080	<	_ACEOF
10487	>	if test $ac_cv_header_iostream = yes; then
10488
6082	–	fi
10489
10490	<	done
10490	>	cat >>confdefs.h <<\_ACEOF
10491	>	#define HAVE_IOSTREAM 1
10492	>	_ACEOF
10493
6086	–	ac_ext=c
6087	–	ac_cpp='$CPP $CPPFLAGS'
6088	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6089	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6090	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
10494
10495	+	else
10496
10497
10498	<
6095	<	for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10498	>	for ac_header in iostream.h
10499		do
10500		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10501		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6125 | Line 10528 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10528		cat conftest.err >&5
10529		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10530		(exit $ac_status); } &&
10531	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10531	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10532	>	|| test ! -s conftest.err'
10533		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10534		(eval $ac_try) 2>&5
10535		ac_status=$?
#	Line 6168 | Line 10572 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10572		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10573		(exit $ac_status); } >/dev/null; then
10574		if test -s conftest.err; then
10575	<	ac_cpp_err=$ac_c_preproc_warn_flag
10576	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10575	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10576	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10577		else
10578		ac_cpp_err=
10579		fi
#	Line 6189 | Line 10593 | echo "${ECHO_T}$ac_header_preproc" >&6
10593		echo "${ECHO_T}$ac_header_preproc" >&6
10594
10595		# So?  What about this header?
10596	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10596	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10597		yes:no: )
10598		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10599		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6241 | Line 10645 | done
10645		done
10646
10647
10648	+	fi
10649
10650
10651
10652	<	for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10652	>
10653	>	if test "${ac_cv_header_iomanip+set}" = set; then
10654	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10655	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10656	>	if test "${ac_cv_header_iomanip+set}" = set; then
10657	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10658	>	fi
10659	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10660	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10661	>	else
10662	>	# Is the header compilable?
10663	>	echo "$as_me:$LINENO: checking iomanip usability" >&5
10664	>	echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10665	>	cat >conftest.$ac_ext <<_ACEOF
10666	>	/* confdefs.h.  */
10667	>	_ACEOF
10668	>	cat confdefs.h >>conftest.$ac_ext
10669	>	cat >>conftest.$ac_ext <<_ACEOF
10670	>	/* end confdefs.h.  */
10671	>	$ac_includes_default
10672	>	#include <iomanip>
10673	>	_ACEOF
10674	>	rm -f conftest.$ac_objext
10675	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10676	>	(eval $ac_compile) 2>conftest.er1
10677	>	ac_status=$?
10678	>	grep -v '^ *+' conftest.er1 >conftest.err
10679	>	rm -f conftest.er1
10680	>	cat conftest.err >&5
10681	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10682	>	(exit $ac_status); } &&
10683	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10684	>	|| test ! -s conftest.err'
10685	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10686	>	(eval $ac_try) 2>&5
10687	>	ac_status=$?
10688	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10689	>	(exit $ac_status); }; } &&
10690	>	{ ac_try='test -s conftest.$ac_objext'
10691	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10692	>	(eval $ac_try) 2>&5
10693	>	ac_status=$?
10694	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10695	>	(exit $ac_status); }; }; then
10696	>	ac_header_compiler=yes
10697	>	else
10698	>	echo "$as_me: failed program was:" >&5
10699	>	sed 's/^/| /' conftest.$ac_ext >&5
10700	>
10701	>	ac_header_compiler=no
10702	>	fi
10703	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10704	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10705	>	echo "${ECHO_T}$ac_header_compiler" >&6
10706	>
10707	>	# Is the header present?
10708	>	echo "$as_me:$LINENO: checking iomanip presence" >&5
10709	>	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10710	>	cat >conftest.$ac_ext <<_ACEOF
10711	>	/* confdefs.h.  */
10712	>	_ACEOF
10713	>	cat confdefs.h >>conftest.$ac_ext
10714	>	cat >>conftest.$ac_ext <<_ACEOF
10715	>	/* end confdefs.h.  */
10716	>	#include <iomanip>
10717	>	_ACEOF
10718	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10719	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10720	>	ac_status=$?
10721	>	grep -v '^ *+' conftest.er1 >conftest.err
10722	>	rm -f conftest.er1
10723	>	cat conftest.err >&5
10724	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10725	>	(exit $ac_status); } >/dev/null; then
10726	>	if test -s conftest.err; then
10727	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10728	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10729	>	else
10730	>	ac_cpp_err=
10731	>	fi
10732	>	else
10733	>	ac_cpp_err=yes
10734	>	fi
10735	>	if test -z "$ac_cpp_err"; then
10736	>	ac_header_preproc=yes
10737	>	else
10738	>	echo "$as_me: failed program was:" >&5
10739	>	sed 's/^/| /' conftest.$ac_ext >&5
10740	>
10741	>	ac_header_preproc=no
10742	>	fi
10743	>	rm -f conftest.err conftest.$ac_ext
10744	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10745	>	echo "${ECHO_T}$ac_header_preproc" >&6
10746	>
10747	>	# So?  What about this header?
10748	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10749	>	yes:no: )
10750	>	{ echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10751	>	echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10752	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10753	>	echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10754	>	ac_header_preproc=yes
10755	>	;;
10756	>	no:yes:* )
10757	>	{ echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10758	>	echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10759	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10760	>	echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10761	>	{ echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10762	>	echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10763	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10764	>	echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10765	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10766	>	echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10767	>	{ echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10768	>	echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10769	>	(
10770	>	cat <<\_ASBOX
10771	>	## ------------------------------ ##
10772	>	## Report this to gezelter@nd.edu ##
10773	>	## ------------------------------ ##
10774	>	_ASBOX
10775	>	) |
10776	>	sed "s/^/$as_me: WARNING:     /" >&2
10777	>	;;
10778	>	esac
10779	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10780	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10781	>	if test "${ac_cv_header_iomanip+set}" = set; then
10782	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10783	>	else
10784	>	ac_cv_header_iomanip=$ac_header_preproc
10785	>	fi
10786	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10787	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10788	>
10789	>	fi
10790	>	if test $ac_cv_header_iomanip = yes; then
10791	>
10792	>
10793	>	cat >>confdefs.h <<\_ACEOF
10794	>	#define HAVE_IOMANIP 1
10795	>	_ACEOF
10796	>
10797	>
10798	>	else
10799	>
10800	>
10801	>	for ac_header in iomanip.h
10802		do
10803		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10804		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6277 | Line 10831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831		cat conftest.err >&5
10832		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10833		(exit $ac_status); } &&
10834	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10834	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10835	>	|| test ! -s conftest.err'
10836		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10837		(eval $ac_try) 2>&5
10838		ac_status=$?
#	Line 6320 | Line 10875 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10875		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10876		(exit $ac_status); } >/dev/null; then
10877		if test -s conftest.err; then
10878	<	ac_cpp_err=$ac_c_preproc_warn_flag
10879	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10878	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10879	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10880		else
10881		ac_cpp_err=
10882		fi
#	Line 6341 | Line 10896 | echo "${ECHO_T}$ac_header_preproc" >&6
10896		echo "${ECHO_T}$ac_header_preproc" >&6
10897
10898		# So?  What about this header?
10899	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10899	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10900		yes:no: )
10901		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10902		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6393 | Line 10948 | done
10948		done
10949
10950
10951	<	for ac_header in machine/hal_sysinfo.h
10951	>	fi
10952	>
10953	>
10954	>
10955	>
10956	>	for ac_header in cmath
10957		do
10958		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10959		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6426 | Line 10986 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10986		cat conftest.err >&5
10987		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10988		(exit $ac_status); } &&
10989	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10989	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10990	>	|| test ! -s conftest.err'
10991		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10992		(eval $ac_try) 2>&5
10993		ac_status=$?
#	Line 6469 | Line 11030 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11030		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11031		(exit $ac_status); } >/dev/null; then
11032		if test -s conftest.err; then
11033	<	ac_cpp_err=$ac_c_preproc_warn_flag
11034	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11033	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11034	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11035		else
11036		ac_cpp_err=
11037		fi
#	Line 6490 | Line 11051 | echo "${ECHO_T}$ac_header_preproc" >&6
11051		echo "${ECHO_T}$ac_header_preproc" >&6
11052
11053		# So?  What about this header?
11054	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11054	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11055		yes:no: )
11056		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11057		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6544 | Line 11105 | done
11105
11106
11107
11108	<
11109	<	for ac_func in rint snprintf sranddev strncasecmp
11110	<	do
6550	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6551	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
6552	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6553	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
11108	>	echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11109	>	echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11110	>	if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11111		echo $ECHO_N "(cached) $ECHO_C" >&6
11112		else
6556	–	cat >conftest.$ac_ext <<_ACEOF
6557	–	/* confdefs.h.  */
6558	–	_ACEOF
6559	–	cat confdefs.h >>conftest.$ac_ext
6560	–	cat >>conftest.$ac_ext <<_ACEOF
6561	–	/* end confdefs.h.  */
6562	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6563	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6564	–	#define $ac_func innocuous_$ac_func
11113
11114	<	/* System header to define __stub macros and hopefully few prototypes,
11115	<	which can conflict with char $ac_func (); below.
11116	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6569	<	<limits.h> exists even on freestanding compilers.  */
6570	<
6571	<	#ifdef __STDC__
6572	<	# include <limits.h>
6573	<	#else
6574	<	# include <assert.h>
6575	<	#endif
6576	<
6577	<	#undef $ac_func
6578	<
6579	<	/* Override any gcc2 internal prototype to avoid an error.  */
6580	<	#ifdef __cplusplus
6581	<	extern "C"
6582	<	{
6583	<	#endif
6584	<	/* We use char because int might match the return type of a gcc2
6585	<	builtin and then its argument prototype would still apply.  */
6586	<	char $ac_func ();
6587	<	/* The GNU C library defines this for functions which it implements
6588	<	to always fail with ENOSYS.  Some functions are actually named
6589	<	something starting with __ and the normal name is an alias.  */
6590	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6591	<	choke me
6592	<	#else
6593	<	char (*f) () = $ac_func;
6594	<	#endif
6595	<	#ifdef __cplusplus
6596	<	}
6597	<	#endif
6598	<
6599	<	int
6600	<	main ()
6601	<	{
6602	<	return f != $ac_func;
6603	<	;
6604	<	return 0;
6605	<	}
6606	<	_ACEOF
6607	<	rm -f conftest.$ac_objext conftest$ac_exeext
6608	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6609	<	(eval $ac_link) 2>conftest.er1
6610	<	ac_status=$?
6611	<	grep -v '^ *+' conftest.er1 >conftest.err
6612	<	rm -f conftest.er1
6613	<	cat conftest.err >&5
6614	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6615	<	(exit $ac_status); } &&
6616	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6617	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6618	<	(eval $ac_try) 2>&5
6619	<	ac_status=$?
6620	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6621	<	(exit $ac_status); }; } &&
6622	<	{ ac_try='test -s conftest$ac_exeext'
6623	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6624	<	(eval $ac_try) 2>&5
6625	<	ac_status=$?
6626	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6627	<	(exit $ac_status); }; }; then
6628	<	eval "$as_ac_var=yes"
6629	<	else
6630	<	echo "$as_me: failed program was:" >&5
6631	<	sed 's/^/| /' conftest.$ac_ext >&5
11114	>	ac_cv_cxx_have_std_iostream=no
11115	>	ac_cv_cxx_need_use_std_iostream=no
11116	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11117
6633	–	eval "$as_ac_var=no"
6634	–	fi
6635	–	rm -f conftest.err conftest.$ac_objext \
6636	–	conftest$ac_exeext conftest.$ac_ext
6637	–	fi
6638	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6639	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6640	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
6641	–	cat >>confdefs.h <<_ACEOF
6642	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6643	–	_ACEOF
11118
11119	<	fi
11120	<	done
11119	>	ac_ext=cc
11120	>	ac_cpp='$CXXCPP $CPPFLAGS'
11121	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11122	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11123	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11124
11125	<
6649	<
6650	<
6651	<
6652	<
6653	<	for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6654	<	do
6655	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6656	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
6657	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6658	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
6659	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6660	<	else
6661	<	cat >conftest.$ac_ext <<_ACEOF
11125	>	cat >conftest.$ac_ext <<_ACEOF
11126		/* confdefs.h.  */
11127		_ACEOF
11128		cat confdefs.h >>conftest.$ac_ext
11129		cat >>conftest.$ac_ext <<_ACEOF
11130		/* end confdefs.h.  */
6667	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6668	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6669	–	#define $ac_func innocuous_$ac_func
11131
11132	<	/* System header to define __stub macros and hopefully few prototypes,
11133	<	which can conflict with char $ac_func (); below.
6673	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6674	<	<limits.h> exists even on freestanding compilers.  */
6675	<
6676	<	#ifdef __STDC__
6677	<	# include <limits.h>
11132	>	#ifdef HAVE_IOSTREAM
11133	>	#include <iostream>
11134		#else
11135	<	# include <assert.h>
11135	>	#include <iostream.h>
11136		#endif
11137
11138	<	#undef $ac_func
11139	<
11140	<	/* Override any gcc2 internal prototype to avoid an error.  */
11141	<	#ifdef __cplusplus
11142	<	extern "C"
11143	<	{
11138	>	#ifdef FC_DUMMY_MAIN
11139	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11140	>	#  ifdef __cplusplus
11141	>	extern "C"
11142	>	#  endif
11143	>	int FC_DUMMY_MAIN() { return 1; }
11144		#endif
6689	–	/* We use char because int might match the return type of a gcc2
6690	–	builtin and then its argument prototype would still apply.  */
6691	–	char $ac_func ();
6692	–	/* The GNU C library defines this for functions which it implements
6693	–	to always fail with ENOSYS.  Some functions are actually named
6694	–	something starting with __ and the normal name is an alias.  */
6695	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6696	–	choke me
6697	–	#else
6698	–	char (*f) () = $ac_func;
11145		#endif
6700	–	#ifdef __cplusplus
6701	–	}
6702	–	#endif
6703	–
11146		int
11147		main ()
11148		{
11149	<	return f != $ac_func;
11149	>	std::cout<<"Hello World"<<std::endl;return 0;
11150		;
11151		return 0;
11152		}
11153		_ACEOF
6712	–	rm -f conftest.$ac_objext conftest$ac_exeext
6713	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6714	–	(eval $ac_link) 2>conftest.er1
6715	–	ac_status=$?
6716	–	grep -v '^ *+' conftest.er1 >conftest.err
6717	–	rm -f conftest.er1
6718	–	cat conftest.err >&5
6719	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6720	–	(exit $ac_status); } &&
6721	–	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6722	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6723	–	(eval $ac_try) 2>&5
6724	–	ac_status=$?
6725	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6726	–	(exit $ac_status); }; } &&
6727	–	{ ac_try='test -s conftest$ac_exeext'
6728	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6729	–	(eval $ac_try) 2>&5
6730	–	ac_status=$?
6731	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732	–	(exit $ac_status); }; }; then
6733	–	eval "$as_ac_var=yes"
6734	–	else
6735	–	echo "$as_me: failed program was:" >&5
6736	–	sed 's/^/| /' conftest.$ac_ext >&5
6737	–
6738	–	eval "$as_ac_var=no"
6739	–	fi
6740	–	rm -f conftest.err conftest.$ac_objext \
6741	–	conftest$ac_exeext conftest.$ac_ext
6742	–	fi
6743	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6744	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6745	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
6746	–	cat >>confdefs.h <<_ACEOF
6747	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6748	–	_ACEOF
6749	–
6750	–	fi
6751	–	done
6752	–
6753	–	# special check for _system_configuration because AIX <4.3.2 do not
6754	–	# contain the `physmem' member.
6755	–	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6756	–	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6757	–	cat >conftest.$ac_ext <<_ACEOF
6758	–	/* confdefs.h.  */
6759	–	_ACEOF
6760	–	cat confdefs.h >>conftest.$ac_ext
6761	–	cat >>conftest.$ac_ext <<_ACEOF
6762	–	/* end confdefs.h.  */
6763	–	#include <sys/systemcfg.h>
6764	–	int
6765	–	main ()
6766	–	{
6767	–	double x = _system_configuration.physmem;
6768	–	;
6769	–	return 0;
6770	–	}
6771	–	_ACEOF
11154		rm -f conftest.$ac_objext
11155		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11156		(eval $ac_compile) 2>conftest.er1
#	Line 6778 | Line 11160 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11160		cat conftest.err >&5
11161		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11162		(exit $ac_status); } &&
11163	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11163	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11164	>	|| test ! -s conftest.err'
11165		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11166		(eval $ac_try) 2>&5
11167		ac_status=$?
#	Line 6790 | Line 11173 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11173		ac_status=$?
11174		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11175		(exit $ac_status); }; }; then
11176	<	echo "$as_me:$LINENO: result: yes" >&5
6794	<	echo "${ECHO_T}yes" >&6
6795	<
6796	<	cat >>confdefs.h <<\_ACEOF
6797	<	#define HAVE__SYSTEM_CONFIGURATION 1
6798	<	_ACEOF
6799	<
11176	>	ac_cv_cxx_have_std_iostream=yes
11177		else
11178		echo "$as_me: failed program was:" >&5
11179		sed 's/^/| /' conftest.$ac_ext >&5
11180
6804	–	echo "$as_me:$LINENO: result: no" >&5
6805	–	echo "${ECHO_T}no" >&6
11181		fi
11182		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11183	<	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6809	<	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6810	<	if test "${ac_cv_header_time+set}" = set; then
6811	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6812	<	else
6813	<	cat >conftest.$ac_ext <<_ACEOF
11183	>	cat >conftest.$ac_ext <<_ACEOF
11184		/* confdefs.h.  */
11185		_ACEOF
11186		cat confdefs.h >>conftest.$ac_ext
11187		cat >>conftest.$ac_ext <<_ACEOF
11188		/* end confdefs.h.  */
6819	–	#include <sys/types.h>
6820	–	#include <sys/time.h>
6821	–	#include <time.h>
11189
11190	+	#define __USE_STD_IOSTREAM 1
11191	+	#ifdef HAVE_IOSTREAM
11192	+	#include <iostream>
11193	+	#else
11194	+	#include <iostream.h>
11195	+	#endif
11196	+
11197	+	#ifdef FC_DUMMY_MAIN
11198	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11199	+	#  ifdef __cplusplus
11200	+	extern "C"
11201	+	#  endif
11202	+	int FC_DUMMY_MAIN() { return 1; }
11203	+	#endif
11204	+	#endif
11205		int
11206		main ()
11207		{
11208	<	if ((struct tm *) 0)
6827	<	return 0;
11208	>	std::cout<<"Hello World"<<std::endl;return 0;
11209		;
11210		return 0;
11211		}
#	Line 6838 | Line 11219 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11219		cat conftest.err >&5
11220		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11221		(exit $ac_status); } &&
11222	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11222	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11223	>	|| test ! -s conftest.err'
11224		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11225		(eval $ac_try) 2>&5
11226		ac_status=$?
#	Line 6850 | Line 11232 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11232		ac_status=$?
11233		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11234		(exit $ac_status); }; }; then
11235	<	ac_cv_header_time=yes
11235	>	ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11236		else
11237		echo "$as_me: failed program was:" >&5
11238		sed 's/^/| /' conftest.$ac_ext >&5
11239
6858	–	ac_cv_header_time=no
11240		fi
11241		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11242	+	ac_ext=cc
11243	+	ac_cpp='$CXXCPP $CPPFLAGS'
11244	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11245	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11246	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11247	+
11248	+	fi
11249	+
11250		fi
11251	<	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11252	<	echo "${ECHO_T}$ac_cv_header_time" >&6
11253	<	if test $ac_cv_header_time = yes; then
11251	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11252	>	echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11253	>	if test "$ac_cv_cxx_have_std_iostream" = yes; then
11254
11255		cat >>confdefs.h <<\_ACEOF
11256	<	#define TIME_WITH_SYS_TIME 1
11256	>	#define HAVE_STD_IOSTREAM 1
11257		_ACEOF
11258
11259	<	fi
11259	>	fi
11260	>	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11261
11262	+	cat >>confdefs.h <<\_ACEOF
11263	+	#define __USE_STD_IOSTREAM 1
11264	+	_ACEOF
11265
11266	<	echo "$as_me:$LINENO: checking for clock_t" >&5
11267	<	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11268	<	if test "${ac_cv_type_clock_t+set}" = set; then
11266	>	fi
11267	>
11268	>
11269	>
11270	>
11271	>	echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11272	>	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11273	>	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11274		echo $ECHO_N "(cached) $ECHO_C" >&6
11275		else
11276	<	cat >conftest.$ac_ext <<_ACEOF
11276	>
11277	>	ac_cv_cxx_have_std_stl=no
11278	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11279	>
11280	>
11281	>	ac_ext=cc
11282	>	ac_cpp='$CXXCPP $CPPFLAGS'
11283	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11284	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11285	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11286	>
11287	>	cat >conftest.$ac_ext <<_ACEOF
11288		/* confdefs.h.  */
11289		_ACEOF
11290		cat confdefs.h >>conftest.$ac_ext
11291		cat >>conftest.$ac_ext <<_ACEOF
11292		/* end confdefs.h.  */
11293	<	$ac_includes_default
11293	>	#include <list>
11294	>
11295	>	#ifdef FC_DUMMY_MAIN
11296	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11297	>	#  ifdef __cplusplus
11298	>	extern "C"
11299	>	#  endif
11300	>	int FC_DUMMY_MAIN() { return 1; }
11301	>	#endif
11302	>	#endif
11303		int
11304		main ()
11305		{
11306	<	if ((clock_t *) 0)
6889	<	return 0;
6890	<	if (sizeof (clock_t))
6891	<	return 0;
11306	>	std::list<int> foo;return 0;
11307		;
11308		return 0;
11309		}
#	Line 6902 | Line 11317 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11317		cat conftest.err >&5
11318		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11319		(exit $ac_status); } &&
11320	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11320	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11321	>	|| test ! -s conftest.err'
11322		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11323		(eval $ac_try) 2>&5
11324		ac_status=$?
#	Line 6914 | Line 11330 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11330		ac_status=$?
11331		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11332		(exit $ac_status); }; }; then
11333	<	ac_cv_type_clock_t=yes
11333	>	ac_cv_cxx_have_std_stl=yes
11334		else
11335		echo "$as_me: failed program was:" >&5
11336		sed 's/^/| /' conftest.$ac_ext >&5
11337
6922	–	ac_cv_type_clock_t=no
11338		fi
11339		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11340	+	ac_ext=cc
11341	+	ac_cpp='$CXXCPP $CPPFLAGS'
11342	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11343	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11344	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11345	+
11346	+	fi
11347	+
11348		fi
11349	<	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11350	<	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11351	<	if test $ac_cv_type_clock_t = yes; then
11349	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11350	>	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11351	>	if test "$ac_cv_cxx_have_std_stl" = yes; then
11352
11353	<	cat >>confdefs.h <<_ACEOF
11354	<	#define HAVE_CLOCK_T 1
11353	>	cat >>confdefs.h <<\_ACEOF
11354	>	#define HAVE_STD_STL 1
11355		_ACEOF
11356
11357	+	fi
11358
6935	–	fi
11359
11360	<	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11361	<	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11362	<	if test "${ac_cv_c_const+set}" = set; then
11360	>
11361	>	echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11362	>	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11363	>	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11364		echo $ECHO_N "(cached) $ECHO_C" >&6
11365		else
11366	<	cat >conftest.$ac_ext <<_ACEOF
11366	>
11367	>	ac_cv_cxx_have_fstream_attach=no
11368	>
11369	>
11370	>	ac_ext=cc
11371	>	ac_cpp='$CXXCPP $CPPFLAGS'
11372	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11373	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11374	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11375	>
11376	>	cat >conftest.$ac_ext <<_ACEOF
11377		/* confdefs.h.  */
11378		_ACEOF
11379		cat confdefs.h >>conftest.$ac_ext
11380		cat >>conftest.$ac_ext <<_ACEOF
11381		/* end confdefs.h.  */
11382
11383	+	#ifdef HAVE_IOSTREAM
11384	+	#include <fstream>
11385	+	#else
11386	+	#include <fstream.h>
11387	+	#endif
11388	+	#ifdef HAVE_STD_IOSTREAM
11389	+	using namespace std;
11390	+	#endif
11391	+
11392	+	#ifdef FC_DUMMY_MAIN
11393	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11394	+	#  ifdef __cplusplus
11395	+	extern "C"
11396	+	#  endif
11397	+	int FC_DUMMY_MAIN() { return 1; }
11398	+	#endif
11399	+	#endif
11400		int
11401		main ()
11402		{
11403	<	/* FIXME: Include the comments suggested by Paul. */
6953	<	#ifndef __cplusplus
6954	<	/* Ultrix mips cc rejects this.  */
6955	<	typedef int charset[2];
6956	<	const charset x;
6957	<	/* SunOS 4.1.1 cc rejects this.  */
6958	<	char const *const *ccp;
6959	<	char **p;
6960	<	/* NEC SVR4.0.2 mips cc rejects this.  */
6961	<	struct point {int x, y;};
6962	<	static struct point const zero = {0,0};
6963	<	/* AIX XL C 1.02.0.0 rejects this.
6964	<	It does not let you subtract one const X* pointer from another in
6965	<	an arm of an if-expression whose if-part is not a constant
6966	<	expression */
6967	<	const char *g = "string";
6968	<	ccp = &g + (g ? g-g : 0);
6969	<	/* HPUX 7.0 cc rejects these. */
6970	<	++ccp;
6971	<	p = (char**) ccp;
6972	<	ccp = (char const *const *) p;
6973	<	{ /* SCO 3.2v4 cc rejects this.  */
6974	<	char *t;
6975	<	char const *s = 0 ? (char *) 0 : (char const *) 0;
6976	<
6977	<	*t++ = 0;
6978	<	}
6979	<	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6980	<	int x[] = {25, 17};
6981	<	const int *foo = &x[0];
6982	<	++foo;
6983	<	}
6984	<	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6985	<	typedef const int *iptr;
6986	<	iptr p = 0;
6987	<	++p;
6988	<	}
6989	<	{ /* AIX XL C 1.02.0.0 rejects this saying
6990	<	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6991	<	struct s { int j; const int *ap[3]; };
6992	<	struct s *b; b->j = 5;
6993	<	}
6994	<	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6995	<	const int foo = 10;
6996	<	}
6997	<	#endif
6998	<
11403	>	int fd=0;ofstream s;s.attach(fd);
11404		;
11405		return 0;
11406		}
#	Line 7009 | Line 11414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11414		cat conftest.err >&5
11415		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11416		(exit $ac_status); } &&
11417	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11417	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11418	>	|| test ! -s conftest.err'
11419		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11420		(eval $ac_try) 2>&5
11421		ac_status=$?
#	Line 7021 | Line 11427 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11427		ac_status=$?
11428		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11429		(exit $ac_status); }; }; then
11430	<	ac_cv_c_const=yes
11430	>	ac_cv_cxx_have_fstream_attach=yes
11431		else
11432		echo "$as_me: failed program was:" >&5
11433		sed 's/^/| /' conftest.$ac_ext >&5
11434
7029	–	ac_cv_c_const=no
11435		fi
11436		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11437	+	ac_ext=cc
11438	+	ac_cpp='$CXXCPP $CPPFLAGS'
11439	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11440	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11441	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11442	+
11443	+
11444		fi
11445	<	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
11446	<	echo "${ECHO_T}$ac_cv_c_const" >&6
11447	<	if test $ac_cv_c_const = no; then
11445	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11446	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11447	>	if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11448
11449		cat >>confdefs.h <<\_ACEOF
11450	<	#define const
11450	>	#define HAVE_FSTREAM_ATTACH 1
11451		_ACEOF
11452
11453	<	fi
11453	>	fi
11454
11455	<	echo "$as_me:$LINENO: checking for inline" >&5
11456	<	echo $ECHO_N "checking for inline... $ECHO_C" >&6
11457	<	if test "${ac_cv_c_inline+set}" = set; then
11455	>
11456	>
11457	>	echo "$as_me:$LINENO: checking for fstream::open()" >&5
11458	>	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11459	>	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11460		echo $ECHO_N "(cached) $ECHO_C" >&6
11461		else
11462	<	ac_cv_c_inline=no
11463	<	for ac_kw in inline __inline__ __inline; do
11464	<	cat >conftest.$ac_ext <<_ACEOF
11462	>
11463	>	ac_cv_cxx_have_fstream_open=no
11464	>	ac_cv_cxx_fstream_open_prot=no
11465	>
11466	>
11467	>	ac_ext=cc
11468	>	ac_cpp='$CXXCPP $CPPFLAGS'
11469	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11470	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11471	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11472	>
11473	>	# Try with 2 parameters
11474	>	cat >conftest.$ac_ext <<_ACEOF
11475		/* confdefs.h.  */
11476		_ACEOF
11477		cat confdefs.h >>conftest.$ac_ext
11478		cat >>conftest.$ac_ext <<_ACEOF
11479		/* end confdefs.h.  */
11480	<	#ifndef __cplusplus
11481	<	typedef int foo_t;
11482	<	static $ac_kw foo_t static_foo () {return 0; }
11483	<	$ac_kw foo_t foo () {return 0; }
11480	>
11481	>	#ifdef HAVE_IOSTREAM
11482	>	#include <fstream>
11483	>	#else
11484	>	#include <fstream.h>
11485		#endif
11486	+	#ifdef HAVE_STD_IOSTREAM
11487	+	using namespace std;
11488	+	#endif
11489
11490	+	#ifdef FC_DUMMY_MAIN
11491	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11492	+	#  ifdef __cplusplus
11493	+	extern "C"
11494	+	#  endif
11495	+	int FC_DUMMY_MAIN() { return 1; }
11496	+	#endif
11497	+	#endif
11498	+	int
11499	+	main ()
11500	+	{
11501	+	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11502	+	;
11503	+	return 0;
11504	+	}
11505		_ACEOF
11506		rm -f conftest.$ac_objext
11507		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 7069 | Line 11512 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11512		cat conftest.err >&5
11513		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11514		(exit $ac_status); } &&
11515	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11515	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11516	>	|| test ! -s conftest.err'
11517		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11518		(eval $ac_try) 2>&5
11519		ac_status=$?
#	Line 7081 | Line 11525 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11525		ac_status=$?
11526		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11527		(exit $ac_status); }; }; then
11528	<	ac_cv_c_inline=$ac_kw; break
7085	<	else
7086	<	echo "$as_me: failed program was:" >&5
7087	<	sed 's/^/| /' conftest.$ac_ext >&5
7088	<
7089	<	fi
7090	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7091	<	done
7092	<
7093	<	fi
7094	<	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7095	<	echo "${ECHO_T}$ac_cv_c_inline" >&6
7096	<
7097	<
7098	<	case $ac_cv_c_inline in
7099	<	inline | yes) ;;
7100	<	*)
7101	<	case $ac_cv_c_inline in
7102	<	no) ac_val=;;
7103	<	*) ac_val=$ac_cv_c_inline;;
7104	<	esac
7105	<	cat >>confdefs.h <<_ACEOF
7106	<	#ifndef __cplusplus
7107	<	#define inline $ac_val
7108	<	#endif
7109	<	_ACEOF
7110	<	;;
7111	<	esac
7112	<
7113	<
7114	<
7115	<
7116	<	for ac_func in rint sranddev
7117	<	do
7118	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7119	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
7120	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7121	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
7122	<	echo $ECHO_N "(cached) $ECHO_C" >&6
11528	>	ac_cv_cxx_have_fstream_open=yes
11529		else
11530	<	cat >conftest.$ac_ext <<_ACEOF
11530	>	echo "$as_me: failed program was:" >&5
11531	>	sed 's/^/| /' conftest.$ac_ext >&5
11532	>
11533	>	fi
11534	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11535	>	# Try with mode parameter
11536	>	cat >conftest.$ac_ext <<_ACEOF
11537		/* confdefs.h.  */
11538		_ACEOF
11539		cat confdefs.h >>conftest.$ac_ext
11540		cat >>conftest.$ac_ext <<_ACEOF
11541		/* end confdefs.h.  */
7130	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7131	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7132	–	#define $ac_func innocuous_$ac_func
11542
11543	<	/* System header to define __stub macros and hopefully few prototypes,
11544	<	which can conflict with char $ac_func (); below.
7136	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7137	<	<limits.h> exists even on freestanding compilers.  */
7138	<
7139	<	#ifdef __STDC__
7140	<	# include <limits.h>
11543	>	#ifdef HAVE_IOSTREAM
11544	>	#include <fstream>
11545		#else
11546	<	# include <assert.h>
11546	>	#include <fstream.h>
11547		#endif
11548	+	#ifdef HAVE_STD_IOSTREAM
11549	+	using namespace std;
11550	+	#endif
11551
11552	<	#undef $ac_func
11553	<
11554	<	/* Override any gcc2 internal prototype to avoid an error.  */
11555	<	#ifdef __cplusplus
11556	<	extern "C"
11557	<	{
11552	>	#ifdef FC_DUMMY_MAIN
11553	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11554	>	#  ifdef __cplusplus
11555	>	extern "C"
11556	>	#  endif
11557	>	int FC_DUMMY_MAIN() { return 1; }
11558		#endif
7152	–	/* We use char because int might match the return type of a gcc2
7153	–	builtin and then its argument prototype would still apply.  */
7154	–	char $ac_func ();
7155	–	/* The GNU C library defines this for functions which it implements
7156	–	to always fail with ENOSYS.  Some functions are actually named
7157	–	something starting with __ and the normal name is an alias.  */
7158	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7159	–	choke me
7160	–	#else
7161	–	char (*f) () = $ac_func;
11559		#endif
7163	–	#ifdef __cplusplus
7164	–	}
7165	–	#endif
7166	–
11560		int
11561		main ()
11562		{
11563	<	return f != $ac_func;
11563	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11564		;
11565		return 0;
11566		}
11567		_ACEOF
11568	<	rm -f conftest.$ac_objext conftest$ac_exeext
11569	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11570	<	(eval $ac_link) 2>conftest.er1
11568	>	rm -f conftest.$ac_objext
11569	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11570	>	(eval $ac_compile) 2>conftest.er1
11571		ac_status=$?
11572		grep -v '^ *+' conftest.er1 >conftest.err
11573		rm -f conftest.er1
11574		cat conftest.err >&5
11575		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11576		(exit $ac_status); } &&
11577	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11577	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11578	>	|| test ! -s conftest.err'
11579		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11580		(eval $ac_try) 2>&5
11581		ac_status=$?
11582		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11583		(exit $ac_status); }; } &&
11584	<	{ ac_try='test -s conftest$ac_exeext'
11584	>	{ ac_try='test -s conftest.$ac_objext'
11585		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11586		(eval $ac_try) 2>&5
11587		ac_status=$?
11588		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11589		(exit $ac_status); }; }; then
11590	<	eval "$as_ac_var=yes"
11590	>	ac_cv_cxx_fstream_open_prot=yes
11591		else
11592		echo "$as_me: failed program was:" >&5
11593		sed 's/^/| /' conftest.$ac_ext >&5
11594
7201	–	eval "$as_ac_var=no"
11595		fi
11596	<	rm -f conftest.err conftest.$ac_objext \
11597	<	conftest$ac_exeext conftest.$ac_ext
11596	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11597	>	ac_ext=cc
11598	>	ac_cpp='$CXXCPP $CPPFLAGS'
11599	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11600	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11601	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11602	>
11603	>
11604		fi
11605	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11606	<	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11607	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
11608	<	cat >>confdefs.h <<_ACEOF
11609	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11605	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11606	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11607	>	if test "$ac_cv_cxx_have_fstream_open" = yes; then
11608	>
11609	>	cat >>confdefs.h <<\_ACEOF
11610	>	#define HAVE_FSTREAM_OPEN 1
11611		_ACEOF
11612
11613	<	fi
11614	<	done
11613	>	fi
11614	>	if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11615
11616	+	cat >>confdefs.h <<\_ACEOF
11617	+	#define FSTREAM_OPEN_PROT 1
11618	+	_ACEOF
11619
11620	<	# clean out junk possibly left behind by a previous configuration
7218	<	rm -f src/getopt.h
7219	<	# Check for getopt_long support
11620	>	fi
11621
11622	<	for ac_header in getopt.h
11622	>
11623	>
11624	>
11625	>
11626	>
11627	>
11628	>	for ac_header in ctype.h iostream fstream sstream strstream
11629		do
11630		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11631		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 7251 | Line 11658 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11658		cat conftest.err >&5
11659		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11660		(exit $ac_status); } &&
11661	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11661	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11662	>	|| test ! -s conftest.err'
11663		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11664		(eval $ac_try) 2>&5
11665		ac_status=$?
#	Line 7294 | Line 11702 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11702		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11703		(exit $ac_status); } >/dev/null; then
11704		if test -s conftest.err; then
11705	<	ac_cpp_err=$ac_c_preproc_warn_flag
11706	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11705	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11706	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11707		else
11708		ac_cpp_err=
11709		fi
#	Line 7315 | Line 11723 | echo "${ECHO_T}$ac_header_preproc" >&6
11723		echo "${ECHO_T}$ac_header_preproc" >&6
11724
11725		# So?  What about this header?
11726	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11726	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11727		yes:no: )
11728		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11729		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 7366 | Line 11774 | done
11774
11775		done
11776
11777	+	# AC_CPP_FUNC
11778	+	# ------------------ #
11779	+	# Checks to see if ANSI C99 CPP variable __func__ works.
11780	+	# If not, perhaps __FUNCTION__ works instead.
11781	+	# If not, we'll just define __func__ to "".
11782	+	# AC_CPP_FUNC
11783
11784	<	for ac_func in getopt_long
11785	<	do
11786	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11787	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
7374	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7375	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
11784	>
11785	>	echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11786	>	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11787	>	if test "${ac_cv_cpp_func+set}" = set; then
11788		echo $ECHO_N "(cached) $ECHO_C" >&6
11789		else
11790		cat >conftest.$ac_ext <<_ACEOF
#	Line 7381 | Line 11793 | cat >>conftest.$ac_ext <<_ACEOF
11793		cat confdefs.h >>conftest.$ac_ext
11794		cat >>conftest.$ac_ext <<_ACEOF
11795		/* end confdefs.h.  */
7384	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7385	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7386	–	#define $ac_func innocuous_$ac_func
11796
11797	<	/* System header to define __stub macros and hopefully few prototypes,
11798	<	which can conflict with char $ac_func (); below.
11799	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11800	<	<limits.h> exists even on freestanding compilers.  */
11801	<
11802	<	#ifdef __STDC__
7394	<	# include <limits.h>
7395	<	#else
7396	<	# include <assert.h>
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
7398	–
7399	–	#undef $ac_func
7400	–
7401	–	/* Override any gcc2 internal prototype to avoid an error.  */
7402	–	#ifdef __cplusplus
7403	–	extern "C"
7404	–	{
11804		#endif
7406	–	/* We use char because int might match the return type of a gcc2
7407	–	builtin and then its argument prototype would still apply.  */
7408	–	char $ac_func ();
7409	–	/* The GNU C library defines this for functions which it implements
7410	–	to always fail with ENOSYS.  Some functions are actually named
7411	–	something starting with __ and the normal name is an alias.  */
7412	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7413	–	choke me
7414	–	#else
7415	–	char (*f) () = $ac_func;
7416	–	#endif
7417	–	#ifdef __cplusplus
7418	–	}
7419	–	#endif
7420	–
11805		int
11806		main ()
11807		{
11808	<	return f != $ac_func;
11808	>	const char *foo = __func__;
11809		;
11810		return 0;
11811		}
11812		_ACEOF
11813	<	rm -f conftest.$ac_objext conftest$ac_exeext
11814	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11815	<	(eval $ac_link) 2>conftest.er1
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_c_werror_flag"                   || test ! -s conftest.err'
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_exeext'
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	<	eval "$as_ac_var=yes"
11835	>	ac_cv_cpp_func=yes
11836		else
11837		echo "$as_me: failed program was:" >&5
11838		sed 's/^/| /' conftest.$ac_ext >&5
11839
7455	–	eval "$as_ac_var=no"
7456	–	fi
7457	–	rm -f conftest.err conftest.$ac_objext \
7458	–	conftest$ac_exeext conftest.$ac_ext
7459	–	fi
7460	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7461	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7462	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
7463	–	cat >>confdefs.h <<_ACEOF
7464	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7465	–	_ACEOF
7466	–
7467	–	else
7468	–	# FreeBSD has a gnugetopt library for this
7469	–	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7470	–	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7471	–	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7472	–	echo $ECHO_N "(cached) $ECHO_C" >&6
7473	–	else
7474	–	ac_check_lib_save_LIBS=$LIBS
7475	–	LIBS="-lgnugetopt  $LIBS"
11840		cat >conftest.$ac_ext <<_ACEOF
11841		/* confdefs.h.  */
11842		_ACEOF
#	Line 7480 | Line 11844 | cat >>conftest.$ac_ext <<_ACEOF
11844		cat >>conftest.$ac_ext <<_ACEOF
11845		/* end confdefs.h.  */
11846
11847	<	/* Override any gcc2 internal prototype to avoid an error.  */
11848	<	#ifdef __cplusplus
11849	<	extern "C"
11847	>	#ifdef FC_DUMMY_MAIN
11848	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11849	>	#  ifdef __cplusplus
11850	>	extern "C"
11851	>	#  endif
11852	>	int FC_DUMMY_MAIN() { return 1; }
11853		#endif
11854	<	/* We use char because int might match the return type of a gcc2
7488	<	builtin and then its argument prototype would still apply.  */
7489	<	char getopt_long ();
11854	>	#endif
11855		int
11856		main ()
11857		{
11858	<	getopt_long ();
11858	>	const char *foo = __FUNCTION__;
11859		;
11860		return 0;
11861		}
11862		_ACEOF
11863	<	rm -f conftest.$ac_objext conftest$ac_exeext
11864	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11865	<	(eval $ac_link) 2>conftest.er1
11863	>	rm -f conftest.$ac_objext
11864	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11865	>	(eval $ac_compile) 2>conftest.er1
11866		ac_status=$?
11867		grep -v '^ *+' conftest.er1 >conftest.err
11868		rm -f conftest.er1
11869		cat conftest.err >&5
11870		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11871		(exit $ac_status); } &&
11872	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11872	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11873	>	|| test ! -s conftest.err'
11874		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11875		(eval $ac_try) 2>&5
11876		ac_status=$?
11877		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11878		(exit $ac_status); }; } &&
11879	<	{ ac_try='test -s conftest$ac_exeext'
11879	>	{ ac_try='test -s conftest.$ac_objext'
11880		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11881		(eval $ac_try) 2>&5
11882		ac_status=$?
11883		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11884		(exit $ac_status); }; }; then
11885	<	ac_cv_lib_gnugetopt_getopt_long=yes
11885	>	ac_cv_cpp_func=__FUNCTION__
11886		else
11887		echo "$as_me: failed program was:" >&5
11888		sed 's/^/| /' conftest.$ac_ext >&5
11889
11890	<	ac_cv_lib_gnugetopt_getopt_long=no
11890	>	ac_cv_cpp_func=no
11891		fi
11892	<	rm -f conftest.err conftest.$ac_objext \
7527	<	conftest$ac_exeext conftest.$ac_ext
7528	<	LIBS=$ac_check_lib_save_LIBS
11892	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11893		fi
11894	<	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11895	<	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11896	<	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11897	<	cat >>confdefs.h <<\_ACEOF
11898	<	#define HAVE_GETOPT_LONG 1
11894	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11895	>	fi
11896	>	echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11897	>	echo "${ECHO_T}$ac_cv_cpp_func" >&6
11898	>	if test $ac_cv_cpp_func = __FUNCTION__; then
11899	>
11900	>	cat >>confdefs.h <<\_ACEOF
11901	>	#define __func__ __FUNCTION__
11902		_ACEOF
11903
11904	<	else
7538	<	# use the GNU replacement
7539	<	case $LIBOBJS in
7540	<	"getopt.$ac_objext"   | \
7541	<	*" getopt.$ac_objext"   | \
7542	<	"getopt.$ac_objext "* | \
7543	<	*" getopt.$ac_objext "* ) ;;
7544	<	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7545	<	esac
11904	>	elif test $ac_cv_cpp_func = no; then
11905
11906	<	case $LIBOBJS in
11907	<	"getopt1.$ac_objext"   | \
11908	<	*" getopt1.$ac_objext"   | \
7550	<	"getopt1.$ac_objext "* | \
7551	<	*" getopt1.$ac_objext "* ) ;;
7552	<	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7553	<	esac
11906	>	cat >>confdefs.h <<\_ACEOF
11907	>	#define __func__ ""
11908	>	_ACEOF
11909
7555	–	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7556	–
11910		fi
11911
7559	–	fi
7560	–	done
11912
11913
11914
11915	+
11916		case $debug in
11917		1)
11918		;;
#	Line 7569 | Line 11921 | case $debug in
11921
11922
11923
11924	+	# Try to determine "good" native compiler flags if none specified on command
11925	+	# line
11926
11927	+	if test "$ac_test_FFLAGS" != "set"; then
11928	+	FCFLAGS=""
11929	+	case "${host_cpu}-${host_os}" in
11930
11931	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11932	+	FCFLAGS="-O3 -ip -no-prec-div"
11933	+	fi;;
11934	+	rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11935	+	FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11936	+	fi;;
11937	+	powerpc*-aix*)
11938	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11939	+	FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11940	+	echo "*******************************************************"
11941	+	echo "*  You have AIX on an unknown powerpc system.  It is  *"
11942	+	echo "*  recommended that you use                           *"
11943	+	echo "*                                                     *"
11944	+	echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11945	+	echo "*                                 ^^^                 *"
11946	+	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11947	+	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11948	+	echo "*******************************************************"
11949	+	fi;;
11950	+	*darwin*)
11951	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11952	+	FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11953	+	fi
11954	+	if test "$FC" = ifort; then
11955	+	FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11956	+	fi;;
11957	+	esac
11958	+
11959	+	if test -n "$CPU_FLAGS"; then
11960	+	FCFLAGS="$FCFLAGS $CPU_FLAGS"
11961	+	fi
11962	+
11963	+	if test -z "$FCFLAGS"; then
11964	+	echo ""
11965	+	echo "*********************************************************"
11966	+	echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11967	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11968	+	echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11969	+	echo "*********************************************************"
11970	+	echo ""
11971	+	FCFLAGS="-O3"
11972	+	fi
11973	+
11974	+
11975	+	echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11976	+	echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11977	+	if test "${ac_guessed_f90flags+set}" = set; then
11978	+	echo $ECHO_N "(cached) $ECHO_C" >&6
11979	+	else
11980	+
11981	+
11982	+
11983	+	ac_ext=${FC_SRCEXT-f}
11984	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11985	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11986	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11987	+
11988	+	echo 'program main' > conftest.$ac_ext
11989	+	echo 'end program main' >> conftest.$ac_ext
11990	+	ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11991	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11992	+	(eval $ac_compile) 2>&5
11993	+	ac_status=$?
11994	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11995	+	(exit $ac_status); }; then
11996	+	ac_guessed_f90flags=yes
11997	+	else
11998	+	ac_guessed_f90flags=no
11999	+	fi
12000	+	rm -f conftest*
12001	+	ac_ext=cc
12002	+	ac_cpp='$CXXCPP $CPPFLAGS'
12003	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12004	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12005	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12006	+
12007	+
12008	+	fi
12009	+	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12010	+	echo "${ECHO_T}$ac_guessed_f90flags" >&6
12011	+	if test "$ac_guessed_f90flags" = yes; then
12012	+	:
12013	+
12014	+	else
12015	+	:
12016	+
12017	+	echo ""
12018	+	echo "**********************************************************"
12019	+	echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12020	+	echo "* your compiler.                                        *"
12021	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12022	+	echo "*********************************************************"
12023	+	echo ""
12024	+	FCFLAGS=""
12025	+
12026	+	fi
12027	+
12028	+
12029	+	fi
12030	+
12031	+
12032	+
12033	+
12034	+
12035	+
12036	+
12037		echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12038		echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12039		if test "${ac_cv_prog_really_gcc+set}" = set; then
#	Line 7579 | Line 12042 | cat > conftest.c <<EOF
12042
12043		cat > conftest.c <<EOF
12044		#ifdef __GNUC__
12045	<	#ifndef __INTEL_COMPILER
12045	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12046	>	no;
12047	>	#else
12048		yes;
12049		#endif
12050		#endif
#	Line 7617 | Line 12082 | if test "$ac_test_CFLAGS" != "set"; then
12082		CFLAGS="-O"
12083		fi;;
12084		sparc-solaris2*) if test "$CC" = cc; then
12085	<	CFLAGS="-native -fast -xO5 -dalign"
12085	>	CFLAGS="-O -dalign"
12086		fi;;
12087
12088		alpha*-osf*)  if test "$CC" = cc; then
#	Line 7647 | Line 12112 | if test "$ac_test_CFLAGS" != "set"; then
12112		*darwin*)
12113		if test "$CC" = xlc -o "$CC" = cc; then
12114		CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12115	+	fi
12116	+	if test "$CC" = icc; then
12117	+	CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12118		fi;;
12119		esac
12120
#	Line 7660 | Line 12128 | if test "$ac_test_CFLAGS" != "set"; then
12128		# -malign-double for x86 systems
12129
12130
12131	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12132	<	echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12131	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12132	>	echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12133		if test "${ac_align_double+set}" = set; then
12134		echo $ECHO_N "(cached) $ECHO_C" >&6
12135		else
12136		echo 'void f(){}' > conftest.c
12137	<	if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12137	>	if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12138		ac_align_double=yes
12139		else
12140		ac_align_double=no
#	Line 7687 | Line 12155 | fi
12155		# -fstrict-aliasing for gcc-2.95+
12156
12157
12158	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12159	<	echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12158	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12159	>	echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12160		if test "${ac_fstrict_aliasing+set}" = set; then
12161		echo $ECHO_N "(cached) $ECHO_C" >&6
12162		else
12163		echo 'void f(){}' > conftest.c
12164	<	if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12164	>	if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12165		ac_fstrict_aliasing=yes
12166		else
12167		ac_fstrict_aliasing=no
#	Line 7718 | Line 12186 | fi
12186		case "${host_cpu}" in
12187		i586*)
12188
12189	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12190	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12189	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12190	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12191		if test "${ac_cpu_pentium+set}" = set; then
12192		echo $ECHO_N "(cached) $ECHO_C" >&6
12193		else
12194		echo 'void f(){}' > conftest.c
12195	<	if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12195	>	if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12196		ac_cpu_pentium=yes
12197		else
12198		ac_cpu_pentium=no
#	Line 7741 | Line 12209 | else
12209		:
12210
12211
12212	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12213	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12212	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12213	>	echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12214		if test "${ac_pentium+set}" = set; then
12215		echo $ECHO_N "(cached) $ECHO_C" >&6
12216		else
12217		echo 'void f(){}' > conftest.c
12218	<	if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12218	>	if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12219		ac_pentium=yes
12220		else
12221		ac_pentium=no
#	Line 7770 | Line 12238 | fi
12238		;;
12239		i686*)
12240
12241	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12242	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12241	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12242	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12243		if test "${ac_cpu_pentiumpro+set}" = set; then
12244		echo $ECHO_N "(cached) $ECHO_C" >&6
12245		else
12246		echo 'void f(){}' > conftest.c
12247	<	if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12247	>	if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12248		ac_cpu_pentiumpro=yes
12249		else
12250		ac_cpu_pentiumpro=no
#	Line 7793 | Line 12261 | else
12261		:
12262
12263
12264	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12265	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12264	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12265	>	echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12266		if test "${ac_pentiumpro+set}" = set; then
12267		echo $ECHO_N "(cached) $ECHO_C" >&6
12268		else
12269		echo 'void f(){}' > conftest.c
12270	<	if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12270	>	if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12271		ac_pentiumpro=yes
12272		else
12273		ac_pentiumpro=no
#	Line 7826 | Line 12294 | fi
12294		if test -n "$is60x"; then
12295
12296
12297	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12298	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12297	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12298	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12299		if test "${ac_m_cpu_60x+set}" = set; then
12300		echo $ECHO_N "(cached) $ECHO_C" >&6
12301		else
12302		echo 'void f(){}' > conftest.c
12303	<	if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12303	>	if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12304		ac_m_cpu_60x=yes
12305		else
12306		ac_m_cpu_60x=no
#	Line 7884 | Line 12352 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12352		:
12353
12354
12355	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12356	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12355	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12356	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12357		if test "${ac_m_cpu_750+set}" = set; then
12358		echo $ECHO_N "(cached) $ECHO_C" >&6
12359		else
12360		echo 'void f(){}' > conftest.c
12361	<	if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12361	>	if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12362		ac_m_cpu_750=yes
12363		else
12364		ac_m_cpu_750=no
#	Line 7917 | Line 12385 | fi
12385		if test -z "$CPU_FLAGS"; then
12386
12387
12388	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12389	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12388	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12389	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12390		if test "${ac_m_cpu_powerpc+set}" = set; then
12391		echo $ECHO_N "(cached) $ECHO_C" >&6
12392		else
12393		echo 'void f(){}' > conftest.c
12394	<	if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12394	>	if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12395		ac_m_cpu_powerpc=yes
12396		else
12397		ac_m_cpu_powerpc=no
#	Line 7945 | Line 12413 | fi
12413		if test -z "$CPU_FLAGS"; then
12414
12415
12416	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12417	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12416	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12417	>	echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12418		if test "${ac_m_powerpc+set}" = set; then
12419		echo $ECHO_N "(cached) $ECHO_C" >&6
12420		else
12421		echo 'void f(){}' > conftest.c
12422	<	if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12422	>	if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12423		ac_m_powerpc=yes
12424		else
12425		ac_m_powerpc=no
#	Line 7990 | Line 12458 | fi
12458
12459
12460
12461	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12462	<	echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12461	>	echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12462	>	echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12463		if test "${ac_guessed_cflags+set}" = set; then
12464		echo $ECHO_N "(cached) $ECHO_C" >&6
12465		else
12466		echo 'void f(){}' > conftest.c
12467	<	if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12467	>	if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12468		ac_guessed_cflags=yes
12469		else
12470		ac_guessed_cflags=no
#	Line 8040 | Line 12508 | cat > conftest.cpp <<EOF
12508
12509		cat > conftest.cpp <<EOF
12510		#ifdef __GNUC__
12511	<	#ifndef __INTEL_COMPILER
12511	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12512	>	no;
12513	>	#else
12514		yes;
12515		#endif
12516		#endif
#	Line 8078 | Line 12548 | if test "$ac_test_CXXFLAGS" != "set"; then
12548		CXXFLAGS="-O"
12549		fi;;
12550		sparc-solaris2*) if test "$CXX" = CC; then
12551	<	CXXFLAGS="-native -fast -xO5 -dalign"
12551	>	CXXFLAGS="-features=extensions -O -dalign"
12552		fi;;
12553		rs6000*-aix*)  if test "$CXX" = xlC; then
12554		CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
#	Line 8099 | Line 12569 | if test "$ac_test_CXXFLAGS" != "set"; then
12569		*darwin*)
12570		if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12571		CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12572	+	fi
12573	+	if test "$CXX" = icpc; then
12574	+	CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12575		fi;;
12576		esac
12577
#	Line 8112 | Line 12585 | if test "$ac_test_CXXFLAGS" != "set"; then
12585		# -malign-double for x86 systems
12586
12587
12588	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12589	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12588	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12589	>	echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12590		if test "${ac_align_double+set}" = set; then
12591		echo $ECHO_N "(cached) $ECHO_C" >&6
12592		else
12593		echo 'void f(){}' > conftest.cpp
12594	<	if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12594	>	if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12595		ac_align_double=yes
12596		else
12597		ac_align_double=no
#	Line 8139 | Line 12612 | fi
12612		# -fstrict-aliasing for gcc-2.95+
12613
12614
12615	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12616	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12615	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12616	>	echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12617		if test "${ac_fstrict_aliasing+set}" = set; then
12618		echo $ECHO_N "(cached) $ECHO_C" >&6
12619		else
12620		echo 'void f(){}' > conftest.cpp
12621	<	if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12621	>	if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12622		ac_fstrict_aliasing=yes
12623		else
12624		ac_fstrict_aliasing=no
#	Line 8170 | Line 12643 | fi
12643		case "${host_cpu}" in
12644		i586*)
12645
12646	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12647	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12646	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12647	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12648		if test "${ac_cpu_pentium+set}" = set; then
12649		echo $ECHO_N "(cached) $ECHO_C" >&6
12650		else
12651		echo 'void f(){}' > conftest.cpp
12652	<	if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12652	>	if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12653		ac_cpu_pentium=yes
12654		else
12655		ac_cpu_pentium=no
#	Line 8193 | Line 12666 | else
12666		:
12667
12668
12669	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12670	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12669	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12670	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12671		if test "${ac_pentium+set}" = set; then
12672		echo $ECHO_N "(cached) $ECHO_C" >&6
12673		else
12674		echo 'void f(){}' > conftest.cpp
12675	<	if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12675	>	if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12676		ac_pentium=yes
12677		else
12678		ac_pentium=no
#	Line 8222 | Line 12695 | fi
12695		;;
12696		i686*)
12697
12698	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12699	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12698	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12699	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12700		if test "${ac_cpu_pentiumpro+set}" = set; then
12701		echo $ECHO_N "(cached) $ECHO_C" >&6
12702		else
12703		echo 'void f(){}' > conftest.cpp
12704	<	if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12704	>	if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12705		ac_cpu_pentiumpro=yes
12706		else
12707		ac_cpu_pentiumpro=no
#	Line 8245 | Line 12718 | else
12718		:
12719
12720
12721	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12722	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12721	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12722	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12723		if test "${ac_pentiumpro+set}" = set; then
12724		echo $ECHO_N "(cached) $ECHO_C" >&6
12725		else
12726		echo 'void f(){}' > conftest.cpp
12727	<	if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12727	>	if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12728		ac_pentiumpro=yes
12729		else
12730		ac_pentiumpro=no
#	Line 8278 | Line 12751 | fi
12751		if test -n "$is60x"; then
12752
12753
12754	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12755	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12754	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12755	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12756		if test "${ac_m_cpu_60x+set}" = set; then
12757		echo $ECHO_N "(cached) $ECHO_C" >&6
12758		else
12759		echo 'void f(){}' > conftest.cpp
12760	<	if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12760	>	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12761		ac_m_cpu_60x=yes
12762		else
12763		ac_m_cpu_60x=no
#	Line 8308 | Line 12781 | if test "${ac_cv_prog_gxx_2_95+set}" = set; then
12781		echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
12782		echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
12783		if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8311	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8312	–	else
8313	–
8314	–	cat > conftest.cpp <<EOF
8315	–	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8316	–	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8317	–	yes;
8318	–	#  endif
8319	–	#endif
8320	–	EOF
8321	–	if { ac_try='${CXX-c++} -E conftest.cpp'
8322	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8323	–	(eval $ac_try) 2>&5
8324	–	ac_status=$?
8325	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8326	–	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8327	–	ac_cv_prog_gxx_2_95=yes
8328	–	else
8329	–	ac_cv_prog_gxx_2_95=no
8330	–	fi
8331	–
8332	–	fi
8333	–	echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8334	–	echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8335	–	if test "$ac_cv_prog_gxx_2_95" = yes; then
8336	–	:
8337	–
8338	–
8339	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
8340	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
8341	–	if test "${ac_m_cpu_750+set}" = set; then
8342	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8343	–	else
8344	–	echo 'void f(){}' > conftest.cpp
8345	–	if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
8346	–	ac_m_cpu_750=yes
8347	–	else
8348	–	ac_m_cpu_750=no
8349	–	fi
8350	–	rm -f conftest*
8351	–
8352	–	fi
8353	–	echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8354	–	echo "${ECHO_T}$ac_m_cpu_750" >&6
8355	–	if test "$ac_m_cpu_750" = yes; then
8356	–	:
8357	–	CPU_FLAGS=-mcpu=750
8358	–	else
8359	–	:
8360	–
8361	–	fi
8362	–
8363	–	else
8364	–	:
8365	–
8366	–	fi
8367	–
8368	–	fi
8369	–	if test -z "$CPU_FLAGS"; then
8370	–
8371	–
8372	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
8373	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
8374	–	if test "${ac_m_cpu_powerpc+set}" = set; then
8375	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8376	–	else
8377	–	echo 'void f(){}' > conftest.cpp
8378	–	if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
8379	–	ac_m_cpu_powerpc=yes
8380	–	else
8381	–	ac_m_cpu_powerpc=no
8382	–	fi
8383	–	rm -f conftest*
8384	–
8385	–	fi
8386	–	echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
8387	–	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8388	–	if test "$ac_m_cpu_powerpc" = yes; then
8389	–	:
8390	–	CPU_FLAGS=-mcpu=powerpc
8391	–	else
8392	–	:
8393	–
8394	–	fi
8395	–
8396	–	fi
8397	–	if test -z "$CPU_FLAGS"; then
8398	–
8399	–
8400	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8401	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8402	–	if test "${ac_m_powerpc+set}" = set; then
8403	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8404	–	else
8405	–	echo 'void f(){}' > conftest.cpp
8406	–	if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8407	–	ac_m_powerpc=yes
8408	–	else
8409	–	ac_m_powerpc=no
8410	–	fi
8411	–	rm -f conftest*
8412	–
8413	–	fi
8414	–	echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8415	–	echo "${ECHO_T}$ac_m_powerpc" >&6
8416	–	if test "$ac_m_powerpc" = yes; then
8417	–	:
8418	–	CPU_FLAGS=-mpowerpc
8419	–	else
8420	–	:
8421	–
8422	–	fi
8423	–
8424	–	fi
8425	–	esac
8426	–	fi
8427	–
8428	–	if test -n "$CPU_FLAGS"; then
8429	–	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8430	–	fi
8431	–
8432	–	if test -z "$CXXFLAGS"; then
8433	–	echo ""
8434	–	echo "**********************************************************"
8435	–	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8436	–	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8437	–	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8438	–	echo "**********************************************************"
8439	–	echo ""
8440	–	CXXFLAGS="-O3"
8441	–	fi
8442	–
8443	–
8444	–
8445	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8446	–	echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8447	–	if test "${ac_guessed_cxxflags+set}" = set; then
8448	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8449	–	else
8450	–	echo 'void f(){}' > conftest.cpp
8451	–	if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8452	–	ac_guessed_cxxflags=yes
8453	–	else
8454	–	ac_guessed_cxxflags=no
8455	–	fi
8456	–	rm -f conftest*
8457	–
8458	–	fi
8459	–	echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
8460	–	echo "${ECHO_T}$ac_guessed_cxxflags" >&6
8461	–	if test "$ac_guessed_cxxflags" = yes; then
8462	–	:
8463	–
8464	–	else
8465	–	:
8466	–
8467	–	echo ""
8468	–	echo "**********************************************************"
8469	–	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8470	–	echo "* your compiler.                                         *"
8471	–	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8472	–	echo "**********************************************************"
8473	–	echo ""
8474	–	CXXFLAGS=""
8475	–
8476	–	fi
8477	–
8478	–
8479	–	fi
8480	–
8481	–
8482	–
8483	–
8484	–
8485	–	# Try to determine "good" native compiler flags if none specified on command
8486	–	# line
8487	–
8488	–	if test x"$F90FLAGS" = x ; then
8489	–	F90FLAGS=""
8490	–	case "${host_cpu}-${host_os}" in
8491	–
8492	–	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8493	–	F90FLAGS="-O"
8494	–	fi;;
8495	–	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8496	–	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8497	–	fi;;
8498	–	powerpc*-aix*)
8499	–	if test "$F90" = f90 -o "$F90" = xlf90; then
8500	–	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8501	–	echo "*******************************************************"
8502	–	echo "*  You have AIX on an unknown powerpc system.  It is  *"
8503	–	echo "*  recommended that you use                           *"
8504	–	echo "*                                                     *"
8505	–	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8506	–	echo "*                                 ^^^                 *"
8507	–	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8508	–	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8509	–	echo "*******************************************************"
8510	–	fi;;
8511	–	*darwin*)
8512	–	if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8513	–	F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8514	–	fi;;
8515	–	esac
8516	–
8517	–	if test -n "$CPU_FLAGS"; then
8518	–	F90FLAGS="$F90FLAGS $CPU_FLAGS"
8519	–	fi
8520	–
8521	–	if test -z "$F90FLAGS"; then
8522	–	echo ""
8523	–	echo "**********************************************************"
8524	–	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8525	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8526	–	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8527	–	echo "**********************************************************"
8528	–	echo ""
8529	–	F90FLAGS="-O3"
8530	–	fi
8531	–
8532	–
8533	–	echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8534	–	echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8535	–	if test "${ac_guessed_f90flags+set}" = set; then
12784		echo $ECHO_N "(cached) $ECHO_C" >&6
12785		else
12786
12787	<
12788	<
12789	<	ac_ext=f90
12790	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
12791	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12792	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
12793	<
12794	<	echo 'program main' > conftest.$ac_ext
12795	<	echo 'end program main' >> conftest.$ac_ext
12796	<	ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
12797	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12798	<	(eval $ac_compile) 2>&5
12799	<	ac_status=$?
12800	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8553	<	(exit $ac_status); }; then
8554	<	ac_guessed_f90flags=yes
8555	<	else
8556	<	ac_guessed_f90flags=no
8557	<	fi
8558	<	rm -f conftest*
8559	<	ac_ext=c
8560	<	ac_cpp='$CPP $CPPFLAGS'
8561	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8562	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8563	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
8564	<
8565	<
8566	<	fi
8567	<	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8568	<	echo "${ECHO_T}$ac_guessed_f90flags" >&6
8569	<	if test "$ac_guessed_f90flags" = yes; then
8570	<	:
8571	<
8572	<	else
8573	<	:
8574	<
8575	<	echo ""
8576	<	echo "**********************************************************"
8577	<	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8578	<	echo "* your compiler.                                         *"
8579	<	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8580	<	echo "**********************************************************"
8581	<	echo ""
8582	<	F90FLAGS=""
8583	<
8584	<	fi
8585	<
8586	<
8587	<	fi
8588	<
8589	<	;;
8590	<	esac
8591	<
8592	<	# Find a good install program.  We prefer a C program (faster),
8593	<	# so one script is as good as another.  But avoid the broken or
8594	<	# incompatible versions:
8595	<	# SysV /etc/install, /usr/sbin/install
8596	<	# SunOS /usr/etc/install
8597	<	# IRIX /sbin/install
8598	<	# AIX /bin/install
8599	<	# AmigaOS /C/install, which installs bootblocks on floppy discs
8600	<	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8601	<	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
8602	<	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8603	<	# OS/2's system install, which has a completely different semantic
8604	<	# ./install, which can be erroneously created by make from ./install.sh.
8605	<	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8606	<	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8607	<	if test -z "$INSTALL"; then
8608	<	if test "${ac_cv_path_install+set}" = set; then
8609	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8610	<	else
8611	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8612	<	for as_dir in $PATH
8613	<	do
8614	<	IFS=$as_save_IFS
8615	<	test -z "$as_dir" && as_dir=.
8616	<	# Account for people who put trailing slashes in PATH elements.
8617	<	case $as_dir/ in
8618	<	./ | .// | /cC/* | \
8619	<	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8620	<	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8621	<	/usr/ucb/* ) ;;
8622	<	*)
8623	<	# OSF1 and SCO ODT 3.0 have their own names for install.
8624	<	# Don't use installbsd from OSF since it installs stuff as root
8625	<	# by default.
8626	<	for ac_prog in ginstall scoinst install; do
8627	<	for ac_exec_ext in '' $ac_executable_extensions; do
8628	<	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8629	<	if test $ac_prog = install &&
8630	<	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8631	<	# AIX install.  It has an incompatible calling convention.
8632	<	:
8633	<	elif test $ac_prog = install &&
8634	<	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8635	<	# program-specific install script used by HP pwplus--don't use.
8636	<	:
8637	<	else
8638	<	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8639	<	break 3
8640	<	fi
8641	<	fi
8642	<	done
8643	<	done
8644	<	;;
8645	<	esac
8646	<	done
8647	<
8648	<
8649	<	fi
8650	<	if test "${ac_cv_path_install+set}" = set; then
8651	<	INSTALL=$ac_cv_path_install
8652	<	else
8653	<	# As a last resort, use the slow shell script.  We don't cache a
8654	<	# path for INSTALL within a source directory, because that will
8655	<	# break other packages using the cache if that directory is
8656	<	# removed, or if the path is relative.
8657	<	INSTALL=$ac_install_sh
8658	<	fi
8659	<	fi
8660	<	echo "$as_me:$LINENO: result: $INSTALL" >&5
8661	<	echo "${ECHO_T}$INSTALL" >&6
8662	<
8663	<	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8664	<	# It thinks the first close brace ends the variable substitution.
8665	<	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8666	<
8667	<	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8668	<
8669	<	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8670	<
8671	<	echo "$as_me:$LINENO: checking whether ln -s works" >&5
8672	<	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8673	<	LN_S=$as_ln_s
8674	<	if test "$LN_S" = "ln -s"; then
8675	<	echo "$as_me:$LINENO: result: yes" >&5
8676	<	echo "${ECHO_T}yes" >&6
8677	<	else
8678	<	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8679	<	echo "${ECHO_T}no, using $LN_S" >&6
8680	<	fi
8681	<
8682	<	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8683	<	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8684	<	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8685	<	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8686	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8687	<	else
8688	<	cat >conftest.make <<\_ACEOF
8689	<	all:
8690	<	@echo 'ac_maketemp="$(MAKE)"'
8691	<	_ACEOF
8692	<	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8693	<	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8694	<	if test -n "$ac_maketemp"; then
8695	<	eval ac_cv_prog_make_${ac_make}_set=yes
8696	<	else
8697	<	eval ac_cv_prog_make_${ac_make}_set=no
8698	<	fi
8699	<	rm -f conftest.make
8700	<	fi
8701	<	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
8702	<	echo "$as_me:$LINENO: result: yes" >&5
8703	<	echo "${ECHO_T}yes" >&6
8704	<	SET_MAKE=
8705	<	else
8706	<	echo "$as_me:$LINENO: result: no" >&5
8707	<	echo "${ECHO_T}no" >&6
8708	<	SET_MAKE="MAKE=${MAKE-make}"
8709	<	fi
8710	<
8711	<	if test -n "$ac_tool_prefix"; then
8712	<	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
8713	<	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
8714	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
8715	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8716	<	if test "${ac_cv_prog_RANLIB+set}" = set; then
8717	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8718	<	else
8719	<	if test -n "$RANLIB"; then
8720	<	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8721	<	else
8722	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723	<	for as_dir in $PATH
8724	<	do
8725	<	IFS=$as_save_IFS
8726	<	test -z "$as_dir" && as_dir=.
8727	<	for ac_exec_ext in '' $ac_executable_extensions; do
8728	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729	<	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8730	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731	<	break 2
8732	<	fi
8733	<	done
8734	<	done
8735	<
8736	<	fi
8737	<	fi
8738	<	RANLIB=$ac_cv_prog_RANLIB
8739	<	if test -n "$RANLIB"; then
8740	<	echo "$as_me:$LINENO: result: $RANLIB" >&5
8741	<	echo "${ECHO_T}$RANLIB" >&6
8742	<	else
8743	<	echo "$as_me:$LINENO: result: no" >&5
8744	<	echo "${ECHO_T}no" >&6
8745	<	fi
8746	<
8747	<	fi
8748	<	if test -z "$ac_cv_prog_RANLIB"; then
8749	<	ac_ct_RANLIB=$RANLIB
8750	<	# Extract the first word of "ranlib", so it can be a program name with args.
8751	<	set dummy ranlib; ac_word=$2
8752	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
8753	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8754	<	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
8755	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8756	<	else
8757	<	if test -n "$ac_ct_RANLIB"; then
8758	<	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
8759	<	else
8760	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8761	<	for as_dir in $PATH
8762	<	do
8763	<	IFS=$as_save_IFS
8764	<	test -z "$as_dir" && as_dir=.
8765	<	for ac_exec_ext in '' $ac_executable_extensions; do
8766	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8767	<	ac_cv_prog_ac_ct_RANLIB="ranlib"
8768	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8769	<	break 2
8770	<	fi
8771	<	done
8772	<	done
8773	<
8774	<	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
8775	<	fi
8776	<	fi
8777	<	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
8778	<	if test -n "$ac_ct_RANLIB"; then
8779	<	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
8780	<	echo "${ECHO_T}$ac_ct_RANLIB" >&6
8781	<	else
8782	<	echo "$as_me:$LINENO: result: no" >&5
8783	<	echo "${ECHO_T}no" >&6
8784	<	fi
8785	<
8786	<	RANLIB=$ac_ct_RANLIB
12787	>	cat > conftest.cpp <<EOF
12788	>	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12789	>	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12790	>	yes;
12791	>	#  endif
12792	>	#endif
12793	>	EOF
12794	>	if { ac_try='${CXX-c++} -E conftest.cpp'
12795	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12796	>	(eval $ac_try) 2>&5
12797	>	ac_status=$?
12798	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12799	>	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12800	>	ac_cv_prog_gxx_2_95=yes
12801		else
12802	<	RANLIB="$ac_cv_prog_RANLIB"
12802	>	ac_cv_prog_gxx_2_95=no
12803		fi
12804
8791	–	for ac_prog in 'bison -y' byacc
8792	–	do
8793	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
8794	–	set dummy $ac_prog; ac_word=$2
8795	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
8796	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797	–	if test "${ac_cv_prog_YACC+set}" = set; then
8798	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8799	–	else
8800	–	if test -n "$YACC"; then
8801	–	ac_cv_prog_YACC="$YACC" # Let the user override the test.
8802	–	else
8803	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804	–	for as_dir in $PATH
8805	–	do
8806	–	IFS=$as_save_IFS
8807	–	test -z "$as_dir" && as_dir=.
8808	–	for ac_exec_ext in '' $ac_executable_extensions; do
8809	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810	–	ac_cv_prog_YACC="$ac_prog"
8811	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812	–	break 2
8813	–	fi
8814	–	done
8815	–	done
8816	–
12805		fi
12806	<	fi
12807	<	YACC=$ac_cv_prog_YACC
12808	<	if test -n "$YACC"; then
12809	<	echo "$as_me:$LINENO: result: $YACC" >&5
8822	<	echo "${ECHO_T}$YACC" >&6
8823	<	else
8824	<	echo "$as_me:$LINENO: result: no" >&5
8825	<	echo "${ECHO_T}no" >&6
8826	<	fi
12806	>	echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12807	>	echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12808	>	if test "$ac_cv_prog_gxx_2_95" = yes; then
12809	>	:
12810
8828	–	test -n "$YACC" && break
8829	–	done
8830	–	test -n "$YACC" || YACC="yacc"
12811
12812	<	for ac_prog in flex lex
12813	<	do
12814	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
8835	<	set dummy $ac_prog; ac_word=$2
8836	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
8837	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8838	<	if test "${ac_cv_prog_LEX+set}" = set; then
12812	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12813	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12814	>	if test "${ac_m_cpu_750+set}" = set; then
12815		echo $ECHO_N "(cached) $ECHO_C" >&6
12816		else
12817	<	if test -n "$LEX"; then
12818	<	ac_cv_prog_LEX="$LEX" # Let the user override the test.
12817	>	echo 'void f(){}' > conftest.cpp
12818	>	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12819	>	ac_m_cpu_750=yes
12820		else
12821	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12822	<	for as_dir in $PATH
12823	<	do
8847	<	IFS=$as_save_IFS
8848	<	test -z "$as_dir" && as_dir=.
8849	<	for ac_exec_ext in '' $ac_executable_extensions; do
8850	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8851	<	ac_cv_prog_LEX="$ac_prog"
8852	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8853	<	break 2
8854	<	fi
8855	<	done
8856	<	done
12821	>	ac_m_cpu_750=no
12822	>	fi
12823	>	rm -f conftest*
12824
12825		fi
12826	<	fi
12827	<	LEX=$ac_cv_prog_LEX
12828	<	if test -n "$LEX"; then
12829	<	echo "$as_me:$LINENO: result: $LEX" >&5
12830	<	echo "${ECHO_T}$LEX" >&6
12826	>	echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12827	>	echo "${ECHO_T}$ac_m_cpu_750" >&6
12828	>	if test "$ac_m_cpu_750" = yes; then
12829	>	:
12830	>	CPU_FLAGS=-mcpu=750
12831		else
12832	<	echo "$as_me:$LINENO: result: no" >&5
12833	<	echo "${ECHO_T}no" >&6
12832	>	:
12833	>
12834		fi
12835
8869	–	test -n "$LEX" && break
8870	–	done
8871	–	test -n "$LEX" || LEX=":"
8872	–
8873	–	if test -z "$LEXLIB"
8874	–	then
8875	–	echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8876	–	echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8877	–	if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8878	–	echo $ECHO_N "(cached) $ECHO_C" >&6
12836		else
12837	<	ac_check_lib_save_LIBS=$LIBS
8881	<	LIBS="-lfl  $LIBS"
8882	<	cat >conftest.$ac_ext <<_ACEOF
8883	<	/* confdefs.h.  */
8884	<	_ACEOF
8885	<	cat confdefs.h >>conftest.$ac_ext
8886	<	cat >>conftest.$ac_ext <<_ACEOF
8887	<	/* end confdefs.h.  */
12837	>	:
12838
8889	–	/* Override any gcc2 internal prototype to avoid an error.  */
8890	–	#ifdef __cplusplus
8891	–	extern "C"
8892	–	#endif
8893	–	/* We use char because int might match the return type of a gcc2
8894	–	builtin and then its argument prototype would still apply.  */
8895	–	char yywrap ();
8896	–	int
8897	–	main ()
8898	–	{
8899	–	yywrap ();
8900	–	;
8901	–	return 0;
8902	–	}
8903	–	_ACEOF
8904	–	rm -f conftest.$ac_objext conftest$ac_exeext
8905	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8906	–	(eval $ac_link) 2>conftest.er1
8907	–	ac_status=$?
8908	–	grep -v '^ *+' conftest.er1 >conftest.err
8909	–	rm -f conftest.er1
8910	–	cat conftest.err >&5
8911	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8912	–	(exit $ac_status); } &&
8913	–	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8914	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8915	–	(eval $ac_try) 2>&5
8916	–	ac_status=$?
8917	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8918	–	(exit $ac_status); }; } &&
8919	–	{ ac_try='test -s conftest$ac_exeext'
8920	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8921	–	(eval $ac_try) 2>&5
8922	–	ac_status=$?
8923	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8924	–	(exit $ac_status); }; }; then
8925	–	ac_cv_lib_fl_yywrap=yes
8926	–	else
8927	–	echo "$as_me: failed program was:" >&5
8928	–	sed 's/^/| /' conftest.$ac_ext >&5
8929	–
8930	–	ac_cv_lib_fl_yywrap=no
12839		fi
12840	<	rm -f conftest.err conftest.$ac_objext \
12841	<	conftest$ac_exeext conftest.$ac_ext
12842	<	LIBS=$ac_check_lib_save_LIBS
12843	<	fi
12844	<	echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
12845	<	echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
12846	<	if test $ac_cv_lib_fl_yywrap = yes; then
12847	<	LEXLIB="-lfl"
8940	<	else
8941	<	echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8942	<	echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8943	<	if test "${ac_cv_lib_l_yywrap+set}" = set; then
12840	>
12841	>	fi
12842	>	if test -z "$CPU_FLAGS"; then
12843	>
12844	>
12845	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12846	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12847	>	if test "${ac_m_cpu_powerpc+set}" = set; then
12848		echo $ECHO_N "(cached) $ECHO_C" >&6
12849		else
12850	<	ac_check_lib_save_LIBS=$LIBS
12851	<	LIBS="-ll  $LIBS"
12852	<	cat >conftest.$ac_ext <<_ACEOF
8949	<	/* confdefs.h.  */
8950	<	_ACEOF
8951	<	cat confdefs.h >>conftest.$ac_ext
8952	<	cat >>conftest.$ac_ext <<_ACEOF
8953	<	/* end confdefs.h.  */
8954	<
8955	<	/* Override any gcc2 internal prototype to avoid an error.  */
8956	<	#ifdef __cplusplus
8957	<	extern "C"
8958	<	#endif
8959	<	/* We use char because int might match the return type of a gcc2
8960	<	builtin and then its argument prototype would still apply.  */
8961	<	char yywrap ();
8962	<	int
8963	<	main ()
8964	<	{
8965	<	yywrap ();
8966	<	;
8967	<	return 0;
8968	<	}
8969	<	_ACEOF
8970	<	rm -f conftest.$ac_objext conftest$ac_exeext
8971	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8972	<	(eval $ac_link) 2>conftest.er1
8973	<	ac_status=$?
8974	<	grep -v '^ *+' conftest.er1 >conftest.err
8975	<	rm -f conftest.er1
8976	<	cat conftest.err >&5
8977	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8978	<	(exit $ac_status); } &&
8979	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8980	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8981	<	(eval $ac_try) 2>&5
8982	<	ac_status=$?
8983	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8984	<	(exit $ac_status); }; } &&
8985	<	{ ac_try='test -s conftest$ac_exeext'
8986	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987	<	(eval $ac_try) 2>&5
8988	<	ac_status=$?
8989	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990	<	(exit $ac_status); }; }; then
8991	<	ac_cv_lib_l_yywrap=yes
12850	>	echo 'void f(){}' > conftest.cpp
12851	>	if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12852	>	ac_m_cpu_powerpc=yes
12853		else
12854	<	echo "$as_me: failed program was:" >&5
8994	<	sed 's/^/| /' conftest.$ac_ext >&5
8995	<
8996	<	ac_cv_lib_l_yywrap=no
12854	>	ac_m_cpu_powerpc=no
12855		fi
12856	<	rm -f conftest.err conftest.$ac_objext \
8999	<	conftest$ac_exeext conftest.$ac_ext
9000	<	LIBS=$ac_check_lib_save_LIBS
9001	<	fi
9002	<	echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9003	<	echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9004	<	if test $ac_cv_lib_l_yywrap = yes; then
9005	<	LEXLIB="-ll"
9006	<	fi
12856	>	rm -f conftest*
12857
12858		fi
12859	+	echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12860	+	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12861	+	if test "$ac_m_cpu_powerpc" = yes; then
12862	+	:
12863	+	CPU_FLAGS=-mcpu=powerpc
12864	+	else
12865	+	:
12866
12867		fi
12868
12869	<	if test "x$LEX" != "x:"; then
12870	<	echo "$as_me:$LINENO: checking lex output file root" >&5
9014	<	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9015	<	if test "${ac_cv_prog_lex_root+set}" = set; then
9016	<	echo $ECHO_N "(cached) $ECHO_C" >&6
9017	<	else
9018	<	# The minimal lex program is just a single line: %%.  But some broken lexes
9019	<	# (Solaris, I think it was) want two %% lines, so accommodate them.
9020	<	cat >conftest.l <<_ACEOF
9021	<	%%
9022	<	%%
9023	<	_ACEOF
9024	<	{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9025	<	(eval $LEX conftest.l) 2>&5
9026	<	ac_status=$?
9027	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9028	<	(exit $ac_status); }
9029	<	if test -f lex.yy.c; then
9030	<	ac_cv_prog_lex_root=lex.yy
9031	<	elif test -f lexyy.c; then
9032	<	ac_cv_prog_lex_root=lexyy
9033	<	else
9034	<	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9035	<	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9036	<	{ (exit 1); exit 1; }; }
9037	<	fi
9038	<	fi
9039	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9040	<	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9041	<	rm -f conftest.l
9042	<	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12869	>	fi
12870	>	if test -z "$CPU_FLAGS"; then
12871
12872	<	echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
12873	<	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
12874	<	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
12872	>
12873	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12874	>	echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12875	>	if test "${ac_m_powerpc+set}" = set; then
12876		echo $ECHO_N "(cached) $ECHO_C" >&6
12877		else
12878	<	# POSIX says lex can declare yytext either as a pointer or an array; the
12879	<	# default is implementation-dependent. Figure out which it is, since
12880	<	# not all implementations provide the %pointer and %array declarations.
9052	<	ac_cv_prog_lex_yytext_pointer=no
9053	<	echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9054	<	ac_save_LIBS=$LIBS
9055	<	LIBS="$LIBS $LEXLIB"
9056	<	cat >conftest.$ac_ext <<_ACEOF
9057	<	`cat $LEX_OUTPUT_ROOT.c`
9058	<	_ACEOF
9059	<	rm -f conftest.$ac_objext conftest$ac_exeext
9060	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9061	<	(eval $ac_link) 2>conftest.er1
9062	<	ac_status=$?
9063	<	grep -v '^ *+' conftest.er1 >conftest.err
9064	<	rm -f conftest.er1
9065	<	cat conftest.err >&5
9066	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067	<	(exit $ac_status); } &&
9068	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9069	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9070	<	(eval $ac_try) 2>&5
9071	<	ac_status=$?
9072	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073	<	(exit $ac_status); }; } &&
9074	<	{ ac_try='test -s conftest$ac_exeext'
9075	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9076	<	(eval $ac_try) 2>&5
9077	<	ac_status=$?
9078	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079	<	(exit $ac_status); }; }; then
9080	<	ac_cv_prog_lex_yytext_pointer=yes
12878	>	echo 'void f(){}' > conftest.cpp
12879	>	if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12880	>	ac_m_powerpc=yes
12881		else
12882	<	echo "$as_me: failed program was:" >&5
9083	<	sed 's/^/| /' conftest.$ac_ext >&5
9084	<
12882	>	ac_m_powerpc=no
12883		fi
12884	<	rm -f conftest.err conftest.$ac_objext \
9087	<	conftest$ac_exeext conftest.$ac_ext
9088	<	LIBS=$ac_save_LIBS
9089	<	rm -f "${LEX_OUTPUT_ROOT}.c"
12884	>	rm -f conftest*
12885
12886		fi
12887	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
12888	<	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
12889	<	if test $ac_cv_prog_lex_yytext_pointer = yes; then
12887	>	echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12888	>	echo "${ECHO_T}$ac_m_powerpc" >&6
12889	>	if test "$ac_m_powerpc" = yes; then
12890	>	:
12891	>	CPU_FLAGS=-mpowerpc
12892	>	else
12893	>	:
12894
9096	–	cat >>confdefs.h <<\_ACEOF
9097	–	#define YYTEXT_POINTER 1
9098	–	_ACEOF
9099	–
12895		fi
12896
12897	<	fi
12897	>	fi
12898	>	esac
12899	>	fi
12900
12901	<	# Extract the first word of "perl", so it can be a program name with args.
12902	<	set dummy perl; ac_word=$2
9106	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
9107	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9108	<	if test "${ac_cv_path_PERLINTERP+set}" = set; then
9109	<	echo $ECHO_N "(cached) $ECHO_C" >&6
9110	<	else
9111	<	case $PERLINTERP in
9112	<	[\\/]* | ?:[\\/]*)
9113	<	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9114	<	;;
9115	<	*)
9116	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9117	<	for as_dir in $PATH
9118	<	do
9119	<	IFS=$as_save_IFS
9120	<	test -z "$as_dir" && as_dir=.
9121	<	for ac_exec_ext in '' $ac_executable_extensions; do
9122	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9123	<	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9124	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9125	<	break 2
12901	>	if test -n "$CPU_FLAGS"; then
12902	>	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12903		fi
9127	–	done
9128	–	done
12904
12905	<	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
12906	<	;;
12907	<	esac
12908	<	fi
12909	<	PERLINTERP=$ac_cv_path_PERLINTERP
12905	>	if test -z "$CXXFLAGS"; then
12906	>	echo ""
12907	>	echo "**********************************************************"
12908	>	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12909	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12910	>	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12911	>	echo "**********************************************************"
12912	>	echo ""
12913	>	CXXFLAGS="-O3"
12914	>	fi
12915
9136	–	if test -n "$PERLINTERP"; then
9137	–	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9138	–	echo "${ECHO_T}$PERLINTERP" >&6
9139	–	else
9140	–	echo "$as_me:$LINENO: result: no" >&5
9141	–	echo "${ECHO_T}no" >&6
9142	–	fi
12916
9144	–	ac_cv_path_perlinterp="$PERLINTERP"
9145	–	_sHpB='#!'
12917
12918	<
12919	<	# Check whether --with-perl-shebang or --without-perl-shebang was given.
12920	<	if test "${with_perl_shebang+set}" = set; then
9150	<	withval="$with_perl_shebang"
9151	<	opt_perl_shebang="$withval"
9152	<	else
9153	<	opt_perl_shebang="not_set"
9154	<	fi;
9155	<	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9156	<	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9157	<	if test "${ax_cv_opt_perl_shebang+set}" = set; then
12918	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12919	>	echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12920	>	if test "${ac_guessed_cxxflags+set}" = set; then
12921		echo $ECHO_N "(cached) $ECHO_C" >&6
12922		else
12923	<	case "$opt_perl_shebang" in
12924	<	not_set  ) ax_cv_opt_perl_shebang=''
12925	<	;;
12926	<	*     )
12927	<	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9165	<	esac
9166	<
12923	>	echo 'void f(){}' > conftest.cpp
12924	>	if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12925	>	ac_guessed_cxxflags=yes
12926	>	else
12927	>	ac_guessed_cxxflags=no
12928		fi
12929	<	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9169	<	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9170	<	if test "A$ax_cv_opt_perl_shebang" != "A"
9171	<	then
9172	<	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9173	<	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9174	<	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9175	<	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
12929	>	rm -f conftest*
12930
9177	–	# Automatic detection of sharpbang formula starts here
9178	–	else
9179	–	_somian_shbangperl=`$PERLINTERP -V:startperl`
9180	–	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9181	–	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9182	–	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9183	–	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9184	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9185	–	else
9186	–	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9187	–	if test "x$_somian_kspb_perl" == x
9188	–	then _somian_ksbp_warn_empty='durnit'
9189	–	else
9190	–	case "A$_somian_kspb_perl" in
9191	–	A#!*perl* )
9192	–	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9193	–	;;
9194	–	A*    )  _somian_ksbp_warn_defau='trouble'
9195	–	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9196	–	esac
9197	–	fi
9198	–
12931		fi
12932	<	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
12933	<	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
12934	<	# The above prints Checking ... result message to user.
12935	<	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12932	>	echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12933	>	echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12934	>	if test "$ac_guessed_cxxflags" = yes; then
12935	>	:
12936
12937	<	if test A${_somian_ksbp_warn_empty+set} == Aset
12938	<	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9207	<	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9208	<	fi
9209	<	# Inform user after printing result value
9210	<	if test A${_somian_ksbp_warn_defau+set} == Aset
9211	<	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9212	<	echo "$as_me: Maybe Not good -" >&6;}
9213	<	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9214	<	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9215	<	else { echo "$as_me:$LINENO: OK Good result - " >&5
9216	<	echo "$as_me: OK Good result - " >&6;}
9217	<	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9218	<	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9219	<	fi
9220	<	fi
12937	>	else
12938	>	:
12939
12940	<	# Extract the first word of "ar", so it can be a program name with args.
12941	<	set dummy ar; ac_word=$2
12942	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
12943	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12944	<	if test "${ac_cv_prog_AR+set}" = set; then
12945	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12946	<	else
12947	<	if test -n "$AR"; then
9230	<	ac_cv_prog_AR="$AR" # Let the user override the test.
9231	<	else
9232	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9233	<	for as_dir in $PATH
9234	<	do
9235	<	IFS=$as_save_IFS
9236	<	test -z "$as_dir" && as_dir=.
9237	<	for ac_exec_ext in '' $ac_executable_extensions; do
9238	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9239	<	ac_cv_prog_AR="ar"
9240	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9241	<	break 2
9242	<	fi
9243	<	done
9244	<	done
12940	>	echo ""
12941	>	echo "**********************************************************"
12942	>	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12943	>	echo "* your compiler.                                         *"
12944	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12945	>	echo "**********************************************************"
12946	>	echo ""
12947	>	CXXFLAGS=""
12948
9246	–	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12949		fi
9248	–	fi
9249	–	AR=$ac_cv_prog_AR
9250	–	if test -n "$AR"; then
9251	–	echo "$as_me:$LINENO: result: $AR" >&5
9252	–	echo "${ECHO_T}$AR" >&6
9253	–	else
9254	–	echo "$as_me:$LINENO: result: no" >&5
9255	–	echo "${ECHO_T}no" >&6
9256	–	fi
12950
9258	–	if test "$AR" = "NONE"; then
9259	–	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9260	–	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9261	–	{ (exit 1); exit 1; }; }
9262	–	cat >confcache <<\_ACEOF
9263	–	# This file is a shell script that caches the results of configure
9264	–	# tests run on this system so they can be shared between configure
9265	–	# scripts and configure runs, see configure's option --config-cache.
9266	–	# It is not useful on other systems.  If it contains results you don't
9267	–	# want to keep, you may remove or edit it.
9268	–	#
9269	–	# config.status only pays attention to the cache file if you give it
9270	–	# the --recheck option to rerun configure.
9271	–	#
9272	–	# `ac_cv_env_foo' variables (set or unset) will be overridden when
9273	–	# loading this file, other *unset* `ac_cv_foo' will be assigned the
9274	–	# following values.
12951
9276	–	_ACEOF
9277	–
9278	–	# The following way of writing the cache mishandles newlines in values,
9279	–	# but we know of no workaround that is simple, portable, and efficient.
9280	–	# So, don't put newlines in cache variables' values.
9281	–	# Ultrix sh set writes to stderr and can't be redirected directly,
9282	–	# and sets the high bit in the cache file unless we assign to the vars.
9283	–	{
9284	–	(set) 2>&1 |
9285	–	case `(ac_space=' '; set | grep ac_space) 2>&1` in
9286	–	*ac_space=\ *)
9287	–	# `set' does not quote correctly, so add quotes (double-quote
9288	–	# substitution turns \\\\ into \\, and sed turns \\ into \).
9289	–	sed -n \
9290	–	"s/'/'\\\\''/g;
9291	–	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9292	–	;;
9293	–	*)
9294	–	# `set' quotes correctly as required by POSIX, so do not add quotes.
9295	–	sed -n \
9296	–	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9297	–	;;
9298	–	esac;
9299	–	} |
9300	–	sed '
9301	–	t clear
9302	–	: clear
9303	–	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9304	–	t end
9305	–	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9306	–	: end' >>confcache
9307	–	if diff $cache_file confcache >/dev/null 2>&1; then :; else
9308	–	if test -w $cache_file; then
9309	–	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9310	–	cat confcache >$cache_file
9311	–	else
9312	–	echo "not updating unwritable cache $cache_file"
9313	–	fi
12952		fi
9315	–	rm -f confcache
9316	–	exit 1
9317	–	fi
12953
12954	<	# Extract the first word of "ps", so it can be a program name with args.
9320	<	set dummy ps; ac_word=$2
9321	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
9322	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9323	<	if test "${ac_cv_path_PS+set}" = set; then
9324	<	echo $ECHO_N "(cached) $ECHO_C" >&6
9325	<	else
9326	<	case $PS in
9327	<	[\\/]* | ?:[\\/]*)
9328	<	ac_cv_path_PS="$PS" # Let the user override the test with a path.
9329	<	;;
9330	<	*)
9331	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9332	<	for as_dir in $PATH
9333	<	do
9334	<	IFS=$as_save_IFS
9335	<	test -z "$as_dir" && as_dir=.
9336	<	for ac_exec_ext in '' $ac_executable_extensions; do
9337	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9338	<	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9339	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9340	<	break 2
9341	<	fi
9342	<	done
9343	<	done
9344	<
9345	<	;;
12954	>	;;
12955		esac
9347	–	fi
9348	–	PS=$ac_cv_path_PS
12956
9350	–	if test -n "$PS"; then
9351	–	echo "$as_me:$LINENO: result: $PS" >&5
9352	–	echo "${ECHO_T}$PS" >&6
9353	–	else
9354	–	echo "$as_me:$LINENO: result: no" >&5
9355	–	echo "${ECHO_T}no" >&6
9356	–	fi
12957
9358	–	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9359	–	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9360	–	if test "${ac_cv_prog_ps_syntax+set}" = set; then
9361	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9362	–	else
9363	–
9364	–	if $PS ax -o rss > /dev/null 2>&1; then
9365	–	ac_cv_prog_ps_ax=yes
9366	–	else
9367	–	ac_cv_prog_ps_ax=no
9368	–	fi
9369	–	if $PS -ef -o rss > /dev/null 2>&1; then
9370	–	ac_cv_prog_ps_ef=yes
9371	–	else
9372	–	ac_cv_prog_ps_ef=no
9373	–	fi
9374	–	if test "$ac_cv_prog_ps_ax" = yes; then
9375	–	ac_cv_prog_ps_syntax=BSD
9376	–	else
9377	–	if test "$ac_cv_prog_ps_ef" = yes; then
9378	–	ac_cv_prog_ps_syntax=POSIX
9379	–	else
9380	–	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9381	–	echo "$as_me: error: Could not determine ps syntax" >&2;}
9382	–	{ (exit 1); exit 1; }; }
9383	–	fi
9384	–	fi
9385	–
9386	–	fi
9387	–	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9388	–	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9389	–
9390	–
9391	–	cat >>confdefs.h <<_ACEOF
9392	–	#define PSCOMMAND $PS
9393	–	_ACEOF
9394	–
9395	–
12958		cat >>confdefs.h <<\_ACEOF
12959		#define OBAPI
12960		_ACEOF
12961
12962
12963
9402	–	if test "$ac_cv_prog_ps_syntax" = BSD; then
9403	–	cat >>confdefs.h <<\_ACEOF
9404	–	#define PSTYPE_IS_BSD 1
9405	–	_ACEOF
12964
9407	–	else
9408	–	if test "$ac_cv_prog_ps_syntax" = POSIX; then
9409	–	cat >>confdefs.h <<\_ACEOF
9410	–	#define PSTYPE_IS_POSIX 1
9411	–	_ACEOF
9412	–
9413	–	else
9414	–	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9415	–	echo "$as_me: error: Unknown ps syntax type!" >&2;}
9416	–	{ (exit 1); exit 1; }; }
9417	–	fi
9418	–	fi
9419	–
9420	–
12965		# Check whether --with-mpi or --without-mpi was given.
12966		if test "${with_mpi+set}" = set; then
12967		withval="$with_mpi"
#	Line 9443 | Line 12987 | MPI_INC_DIR="$MPI/include"
12987
12988
12989
12990	+	ac_ext=c
12991	+	ac_cpp='$CPP $CPPFLAGS'
12992	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12993	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12994	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
12995	+
12996		echo "$as_me:$LINENO: checking for mpi.h" >&5
12997		echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12998		have_mpi_h=0
12999		rm -f conftest*
13000	<	echo '#include <mpi.h>' > conftest.cc
13001	<	if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13000	>	echo '#include <mpi.h>' > conftest.c
13001	>	if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13002		echo "$as_me:$LINENO: result: yes" >&5
13003		echo "${ECHO_T}yes" >&6
13004		have_mpi_h=1
#	Line 9471 | Line 13021 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13021
13022		echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13023		echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13024	+
13025	+
13026	+	ac_ext=${FC_SRCEXT-f}
13027	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13028	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13029	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13030	+
13031	+	ac_save_ext=$ac_ext
13032	+	ac_ext=F90
13033	+	ac_save_FCFLAGS=$FCFLAGS
13034		have_mpif_h=0
13035		rm -f conftest*
13036	<	cat >conftest.f90 <<EOF
13036	>	cat >conftest.$ac_ext <<EOF
13037		program main
13038		include 'mpif.h'
13039		end
13040		EOF
13041	<	if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13041	>	if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13042		echo "$as_me:$LINENO: result: yes" >&5
13043		echo "${ECHO_T}yes" >&6
13044		MPI_F90_INC="$MPI_INC_DIR"
#	Line 9500 | Line 13060 | fi
13060		_ACEOF
13061
13062		fi
13063	+	FCFLAGS=$ac_save_FCFLAGS
13064	+	ac_ext=$ac_save_ext
13065	+	ac_ext=c
13066	+	ac_cpp='$CPP $CPPFLAGS'
13067	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13068	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13069	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
13070
13071	+
13072		ac_ext=c
13073		ac_cpp='$CPP $CPPFLAGS'
13074		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 9508 | Line 13076 | ac_save_LDFLAGS=$LDFLAGS
13076		ac_compiler_gnu=$ac_cv_c_compiler_gnu
13077
13078		ac_save_LDFLAGS=$LDFLAGS
13079	<	LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13079	>	LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13080
13081		if test x = x"$MPI_LIB"; then
13082		echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
#	Line 9532 | Line 13100 | char MPI_Init ();
13100		/* We use char because int might match the return type of a gcc2
13101		builtin and then its argument prototype would still apply.  */
13102		char MPI_Init ();
13103	+	#ifdef FC_DUMMY_MAIN
13104	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13105	+	#  ifdef __cplusplus
13106	+	extern "C"
13107	+	#  endif
13108	+	int FC_DUMMY_MAIN() { return 1; }
13109	+	#endif
13110	+	#endif
13111		int
13112		main ()
13113		{
#	Line 9549 | Line 13125 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13125		cat conftest.err >&5
13126		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13127		(exit $ac_status); } &&
13128	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13128	>	{ ac_try='test -z "$ac_c_werror_flag"
13129	>	|| test ! -s conftest.err'
13130		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13131		(eval $ac_try) 2>&5
13132		ac_status=$?
#	Line 9579 | Line 13156 | fi
13156		fi
13157
13158		fi
13159	+	$as_unset ac_cv_lib_mpich_MPI_Init
13160		if test x = x"$MPI_LIB"; then
13161	<	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13162	<	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13163	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13161	>	echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13162	>	echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13163	>	if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13164		echo $ECHO_N "(cached) $ECHO_C" >&6
13165		else
13166		ac_check_lib_save_LIBS=$LIBS
13167	<	LIBS="-lmpi  $LIBS"
13167	>	LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13168		cat >conftest.$ac_ext <<_ACEOF
13169		/* confdefs.h.  */
13170		_ACEOF
#	Line 9601 | Line 13179 | char MPI_Init ();
13179		/* We use char because int might match the return type of a gcc2
13180		builtin and then its argument prototype would still apply.  */
13181		char MPI_Init ();
13182	+	#ifdef FC_DUMMY_MAIN
13183	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13184	+	#  ifdef __cplusplus
13185	+	extern "C"
13186	+	#  endif
13187	+	int FC_DUMMY_MAIN() { return 1; }
13188	+	#endif
13189	+	#endif
13190		int
13191		main ()
13192		{
#	Line 9618 | Line 13204 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13204		cat conftest.err >&5
13205		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13206		(exit $ac_status); } &&
13207	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13207	>	{ ac_try='test -z "$ac_c_werror_flag"
13208	>	|| test ! -s conftest.err'
13209		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13210		(eval $ac_try) 2>&5
13211		ac_status=$?
#	Line 9630 | Line 13217 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13217		ac_status=$?
13218		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13219		(exit $ac_status); }; }; then
13220	<	ac_cv_lib_mpi_MPI_Init=yes
13220	>	ac_cv_lib_pmpich_MPI_Init=yes
13221		else
13222		echo "$as_me: failed program was:" >&5
13223		sed 's/^/| /' conftest.$ac_ext >&5
13224
13225	<	ac_cv_lib_mpi_MPI_Init=no
13225	>	ac_cv_lib_pmpich_MPI_Init=no
13226		fi
13227		rm -f conftest.err conftest.$ac_objext \
13228		conftest$ac_exeext conftest.$ac_ext
13229		LIBS=$ac_check_lib_save_LIBS
13230		fi
13231	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13232	<	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13233	<	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13234	<	MPI_LIB="-lmpi"
13231	>	echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13232	>	echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13233	>	if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13234	>	MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13235		fi
13236
13237		fi
9651	–	$as_unset ac_cv_lib_mpi_MPI_Init
13238		if test x = x"$MPI_LIB"; then
13239		echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13240		echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
#	Line 9656 | Line 13242 | else
13242		echo $ECHO_N "(cached) $ECHO_C" >&6
13243		else
13244		ac_check_lib_save_LIBS=$LIBS
13245	<	LIBS="-lmpi "-llam" $LIBS"
13245	>	LIBS="-lmpi  $LIBS"
13246		cat >conftest.$ac_ext <<_ACEOF
13247		/* confdefs.h.  */
13248		_ACEOF
#	Line 9671 | Line 13257 | char MPI_Init ();
13257		/* We use char because int might match the return type of a gcc2
13258		builtin and then its argument prototype would still apply.  */
13259		char MPI_Init ();
13260	+	#ifdef FC_DUMMY_MAIN
13261	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13262	+	#  ifdef __cplusplus
13263	+	extern "C"
13264	+	#  endif
13265	+	int FC_DUMMY_MAIN() { return 1; }
13266	+	#endif
13267	+	#endif
13268		int
13269		main ()
13270		{
#	Line 9688 | Line 13282 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13282		cat conftest.err >&5
13283		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13284		(exit $ac_status); } &&
13285	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13285	>	{ ac_try='test -z "$ac_c_werror_flag"
13286	>	|| test ! -s conftest.err'
13287		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13288		(eval $ac_try) 2>&5
13289		ac_status=$?
#	Line 9714 | Line 13309 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13309		echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13310		echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13311		if test $ac_cv_lib_mpi_MPI_Init = yes; then
13312	<	MPI_LIB="-lmpi -llam"
13312	>	MPI_LIB="-lmpi"
13313		fi
13314
13315		fi
13316	<	$as_unset ac_cv_lib_mpich_MPI_Init
13316	>	$as_unset ac_cv_lib_mpi_MPI_Init
13317		if test x = x"$MPI_LIB"; then
13318	<	echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13319	<	echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13320	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13318	>	echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13319	>	echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13320	>	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13321		echo $ECHO_N "(cached) $ECHO_C" >&6
13322		else
13323		ac_check_lib_save_LIBS=$LIBS
13324	<	LIBS="-lmpich "-lpmpich" $LIBS"
13324	>	LIBS="-lmpi -llam $LIBS"
13325		cat >conftest.$ac_ext <<_ACEOF
13326		/* confdefs.h.  */
13327		_ACEOF
#	Line 9741 | Line 13336 | char MPI_Init ();
13336		/* We use char because int might match the return type of a gcc2
13337		builtin and then its argument prototype would still apply.  */
13338		char MPI_Init ();
13339	+	#ifdef FC_DUMMY_MAIN
13340	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13341	+	#  ifdef __cplusplus
13342	+	extern "C"
13343	+	#  endif
13344	+	int FC_DUMMY_MAIN() { return 1; }
13345	+	#endif
13346	+	#endif
13347		int
13348		main ()
13349		{
#	Line 9758 | Line 13361 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13361		cat conftest.err >&5
13362		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13363		(exit $ac_status); } &&
13364	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13364	>	{ ac_try='test -z "$ac_c_werror_flag"
13365	>	|| test ! -s conftest.err'
13366		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13367		(eval $ac_try) 2>&5
13368		ac_status=$?
#	Line 9770 | Line 13374 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13374		ac_status=$?
13375		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13376		(exit $ac_status); }; }; then
13377	<	ac_cv_lib_mpich_MPI_Init=yes
13377	>	ac_cv_lib_mpi_MPI_Init=yes
13378		else
13379		echo "$as_me: failed program was:" >&5
13380		sed 's/^/| /' conftest.$ac_ext >&5
13381
13382	<	ac_cv_lib_mpich_MPI_Init=no
13382	>	ac_cv_lib_mpi_MPI_Init=no
13383		fi
13384		rm -f conftest.err conftest.$ac_objext \
13385		conftest$ac_exeext conftest.$ac_ext
13386		LIBS=$ac_check_lib_save_LIBS
13387		fi
13388	<	echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13389	<	echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13390	<	if test $ac_cv_lib_mpich_MPI_Init = yes; then
13391	<	MPI_LIB="-lmpich -lpmpich"
13388	>	echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13389	>	echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13390	>	if test $ac_cv_lib_mpi_MPI_Init = yes; then
13391	>	MPI_LIB="-lmpi -llam"
13392		fi
13393
13394		fi
9791	–
13395		$as_unset ac_cv_lib_mpi_MPI_Init
13396		if test x = x"$MPI_LIB"; then
13397		echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
#	Line 9812 | Line 13415 | char MPI_Init ();
13415		/* We use char because int might match the return type of a gcc2
13416		builtin and then its argument prototype would still apply.  */
13417		char MPI_Init ();
13418	+	#ifdef FC_DUMMY_MAIN
13419	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13420	+	#  ifdef __cplusplus
13421	+	extern "C"
13422	+	#  endif
13423	+	int FC_DUMMY_MAIN() { return 1; }
13424	+	#endif
13425	+	#endif
13426		int
13427		main ()
13428		{
#	Line 9829 | Line 13440 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13440		cat conftest.err >&5
13441		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13442		(exit $ac_status); } &&
13443	<	{ ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13443	>	{ ac_try='test -z "$ac_c_werror_flag"
13444	>	|| test ! -s conftest.err'
13445		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13446		(eval $ac_try) 2>&5
13447		ac_status=$?
#	Line 9887 | Line 13499 | fi
13499
13500
13501
9890	–
13502		USE_CGAL=no
13503		cgal_makefile=auto
13504
#	Line 10023 | Line 13634 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13634		cat conftest.err >&5
13635		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13636		(exit $ac_status); } &&
13637	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
13637	>	{ ac_try='test -z "$ac_cxx_werror_flag"
13638	>	|| test ! -s conftest.err'
13639		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13640		(eval $ac_try) 2>&5
13641		ac_status=$?
#	Line 10228 | Line 13840 | cat >>conftest.$ac_ext <<_ACEOF
13840		cat >>conftest.$ac_ext <<_ACEOF
13841		/* end confdefs.h.  */
13842		#include <CGAL/Cartesian.h>
13843	+	#ifdef FC_DUMMY_MAIN
13844	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13845	+	#  ifdef __cplusplus
13846	+	extern "C"
13847	+	#  endif
13848	+	int FC_DUMMY_MAIN() { return 1; }
13849	+	#endif
13850	+	#endif
13851		int
13852		main ()
13853		{
#	Line 10245 | Line 13865 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13865		cat conftest.err >&5
13866		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13867		(exit $ac_status); } &&
13868	<	{ ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
13868	>	{ ac_try='test -z "$ac_cxx_werror_flag"
13869	>	|| test ! -s conftest.err'
13870		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13871		(eval $ac_try) 2>&5
13872		ac_status=$?
#	Line 10332 | Line 13953 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13953
13954
13955
10335	–
13956		# Check whether --enable-doxygen or --disable-doxygen was given.
13957		if test "${enable_doxygen+set}" = set; then
13958		enableval="$enable_doxygen"
#	Line 10466 | Line 14086 | else
14086		enable_dot=no
14087		else
14088		enable_dot=yes
10469	–	fi
10470	–
10471	–
10472	–
10473	–
10474	–
10475	–
10476	–
10477	–	OBJEXT=".$OBJEXT"
10478	–
10479	–	OOPSE=oopse
10480	–
10481	–	if test "x${prefix}" = "xNONE"
10482	–	then
10483	–	OOPSE_HOME=${ac_default_prefix}/oopse
10484	–	else
10485	–	OOPSE_HOME=${prefix}/oopse
14089		fi
10487	–	# Check whether --enable-oopse-home or --disable-oopse-home was given.
10488	–	if test "${enable_oopse_home+set}" = set; then
10489	–	enableval="$enable_oopse_home"
10490	–	OOPSE_HOME="${enableval}"
10491	–	fi;
14090
10493	–	case "x$INSTALL" in
10494	–	x/*) ;;
10495	–	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10496	–	esac
14091
10498	–	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14092
10500	–	CFLAGS=${CFLAGS-""}
10501	–	CXXFLAGS=${CXXFLAGS-""}
10502	–	CPPFLAGS=${CPPFLAGS-""}
10503	–	FFLAGS=${FFLAGS-""}
10504	–	F90FLAGS=${F90FLAGS-""}
10505	–	LDFLAGS=${LDFLAGS-""}
10506	–	DEBUG=${DEBUG-"-g"}
14093
10508	–	case $debug in
10509	–	1)
10510	–	FFLAGS="$DEBUG $FFLAGS"
10511	–	F90FLAGS="$DEBUG $F90FLAGS"
10512	–	;;
10513	–	*)
10514	–	;;
10515	–	esac
14094
14095
14096
#	Line 10527 | Line 14105 | esac
14105
14106
14107
10530	–
10531	–
10532	–
10533	–
10534	–	ac_config_headers="$ac_config_headers src/config.h"
14108
14109	<	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14109	>	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile src/applications/utilities/affineScale src/applications/utilities/waterBoxer scripts/filepp"
14110
14111
14112		cat >confcache <<\_ACEOF
#	Line 10898 | Line 14471 | cat >&5 <<_CSEOF
14471		} >&5
14472		cat >&5 <<_CSEOF
14473
14474	<	This file was extended by OOPSE $as_me 2.0, which was
14474	>	This file was extended by OOPSE $as_me 3.0, which was
14475		generated by GNU Autoconf 2.59.  Invocation command line was
14476
14477		CONFIG_FILES    = $CONFIG_FILES
#	Line 10961 | Line 14534 | ac_cs_version="\\
14534
14535		cat >>$CONFIG_STATUS <<_ACEOF
14536		ac_cs_version="\\
14537	<	OOPSE config.status 2.0
14537	>	OOPSE config.status 3.0
14538		configured by $0, generated by GNU Autoconf 2.59,
14539		with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14540
#	Line 11067 | Line 14640 | do
14640		"make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14641		"src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14642		"src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14643	+	"src/applications/utilities/affineScale" ) CONFIG_FILES="$CONFIG_FILES src/applications/utilities/affineScale" ;;
14644	+	"src/applications/utilities/waterBoxer" ) CONFIG_FILES="$CONFIG_FILES src/applications/utilities/waterBoxer" ;;
14645		"scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14646		"src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14647		"src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
#	Line 11155 | Line 14730 | s,@LIBS@,$LIBS,;t t
14730		s,@ECHO_N@,$ECHO_N,;t t
14731		s,@ECHO_T@,$ECHO_T,;t t
14732		s,@LIBS@,$LIBS,;t t
11158	–	s,@PROGNAME@,$PROGNAME,;t t
11159	–	s,@debug@,$debug,;t t
14733		s,@build@,$build,;t t
14734		s,@build_cpu@,$build_cpu,;t t
14735		s,@build_vendor@,$build_vendor,;t t
#	Line 11165 | Line 14738 | s,@host_os@,$host_os,;t t
14738		s,@host_cpu@,$host_cpu,;t t
14739		s,@host_vendor@,$host_vendor,;t t
14740		s,@host_os@,$host_os,;t t
14741	<	s,@CC@,$CC,;t t
14742	<	s,@CFLAGS@,$CFLAGS,;t t
14741	>	s,@PROGNAME@,$PROGNAME,;t t
14742	>	s,@debug@,$debug,;t t
14743	>	s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
14744	>	s,@CXX@,$CXX,;t t
14745	>	s,@CXXFLAGS@,$CXXFLAGS,;t t
14746		s,@LDFLAGS@,$LDFLAGS,;t t
14747		s,@CPPFLAGS@,$CPPFLAGS,;t t
14748	<	s,@ac_ct_CC@,$ac_ct_CC,;t t
14748	>	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14749		s,@EXEEXT@,$EXEEXT,;t t
14750		s,@OBJEXT@,$OBJEXT,;t t
14751	<	s,@CXX@,$CXX,;t t
14752	<	s,@CXXFLAGS@,$CXXFLAGS,;t t
14753	<	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14754	<	s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14755	<	s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14756	<	s,@F90@,$F90,;t t
11181	<	s,@F90FLAGS@,$F90FLAGS,;t t
11182	<	s,@ac_ct_F90@,$ac_ct_F90,;t t
11183	<	s,@PREPFLAG@,$PREPFLAG,;t t
11184	<	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11185	<	s,@F90LIBS@,$F90LIBS,;t t
11186	<	s,@F90_FUNC@,$F90_FUNC,;t t
11187	<	s,@F90_FUNC_@,$F90_FUNC_,;t t
11188	<	s,@MOD@,$MOD,;t t
11189	<	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11190	<	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11191	<	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11192	<	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14751	>	s,@CC@,$CC,;t t
14752	>	s,@CFLAGS@,$CFLAGS,;t t
14753	>	s,@ac_ct_CC@,$ac_ct_CC,;t t
14754	>	s,@FC@,$FC,;t t
14755	>	s,@FCFLAGS@,$FCFLAGS,;t t
14756	>	s,@ac_ct_FC@,$ac_ct_FC,;t t
14757		s,@CPP@,$CPP,;t t
14758		s,@EGREP@,$EGREP,;t t
11195	–	s,@CXXCPP@,$CXXCPP,;t t
11196	–	s,@LIBOBJS@,$LIBOBJS,;t t
11197	–	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11198	–	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11199	–	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14759		s,@LN_S@,$LN_S,;t t
14760		s,@SET_MAKE@,$SET_MAKE,;t t
14761		s,@RANLIB@,$RANLIB,;t t
14762		s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11204	–	s,@YACC@,$YACC,;t t
11205	–	s,@LEX@,$LEX,;t t
11206	–	s,@LEXLIB@,$LEXLIB,;t t
11207	–	s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14763		s,@PERLINTERP@,$PERLINTERP,;t t
14764		s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14765	+	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14766	+	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14767	+	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14768		s,@AR@,$AR,;t t
14769		s,@PS@,$PS,;t t
14770	+	s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14771	+	s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14772	+	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14773	+	s,@FCLIBS@,$FCLIBS,;t t
14774	+	s,@FC_FUNC@,$FC_FUNC,;t t
14775	+	s,@FC_FUNC_@,$FC_FUNC_,;t t
14776	+	s,@MOD@,$MOD,;t t
14777	+	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14778	+	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14779	+	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14780	+	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14781	+	s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14782	+	s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14783	+	s,@ZLIB@,$ZLIB,;t t
14784	+	s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14785	+	s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14786	+	s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14787	+	s,@LIBOBJS@,$LIBOBJS,;t t
14788	+	s,@POW_LIB@,$POW_LIB,;t t
14789	+	s,@CXXCPP@,$CXXCPP,;t t
14790	+	s,@__func__@,$__func__,;t t
14791		s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14792		s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14793		s,@MPI_F90_INC@,$MPI_F90_INC,;t t
#	Line 11233 | Line 14812 | s,@SUBDIRS@,$SUBDIRS,;t t
14812		s,@OOPSE@,$OOPSE,;t t
14813		s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14814		s,@SUBDIRS@,$SUBDIRS,;t t
11236	–	s,@FFLAGS@,$FFLAGS,;t t
14815		s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14816		CEOF
14817
#	Line 11401 | Line 14979 | esac
14979		*) ac_INSTALL=$ac_top_builddir$INSTALL ;;
14980		esac
14981
14982	+	if test x"$ac_file" != x-; then
14983	+	{ echo "$as_me:$LINENO: creating $ac_file" >&5
14984	+	echo "$as_me: creating $ac_file" >&6;}
14985	+	rm -f "$ac_file"
14986	+	fi
14987		# Let's still pretend it is `configure' which instantiates (i.e., don't
14988		# use $as_me), people would be surprised to read:
14989		#    /* config.h.  Generated by config.status.  */
#	Line 11439 | Line 15022 | echo "$as_me: error: cannot find input file: $f" >&2;}
15022		fi;;
15023		esac
15024		done` || { (exit 1); exit 1; }
11442	–
11443	–	if test x"$ac_file" != x-; then
11444	–	{ echo "$as_me:$LINENO: creating $ac_file" >&5
11445	–	echo "$as_me: creating $ac_file" >&6;}
11446	–	rm -f "$ac_file"
11447	–	fi
15025		_ACEOF
15026		cat >>$CONFIG_STATUS <<_ACEOF
15027		sed "$ac_vpsub
#	Line 11477 | Line 15054 | s,@INSTALL@,$ac_INSTALL,;t t
15054		make/Makefile ) chmod 0755 scripts/* ;;
15055		src/utils/Makefile ) chmod 0755 scripts/* ;;
15056		src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15057	+	src/applications/utilities/affineScale ) chmod 0755 scripts/* ;;
15058	+	src/applications/utilities/waterBoxer ) chmod 0755 scripts/* ;;
15059		scripts/filepp ) chmod 0755 scripts/* ;;
15060		esac
15061		done

Diff Legend

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