ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 774 by gezelter, Fri Dec 2 20:09:55 2005 UTC vs.
Revision 956 by gezelter, Tue May 16 02:06:37 2006 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.59 for OOPSE 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 CPP EGREP 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 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 CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316		ac_subst_files=''
317
318		# Initialize some variables set by options.
#	Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753		ac_env_target_alias_value=$target_alias
754		ac_cv_env_target_alias_set=${target_alias+set}
755		ac_cv_env_target_alias_value=$target_alias
756	<	ac_env_CC_set=${CC+set}
757	<	ac_env_CC_value=$CC
758	<	ac_cv_env_CC_set=${CC+set}
759	<	ac_cv_env_CC_value=$CC
760	<	ac_env_CFLAGS_set=${CFLAGS+set}
761	<	ac_env_CFLAGS_value=$CFLAGS
762	<	ac_cv_env_CFLAGS_set=${CFLAGS+set}
763	<	ac_cv_env_CFLAGS_value=$CFLAGS
756	>	ac_env_CXX_set=${CXX+set}
757	>	ac_env_CXX_value=$CXX
758	>	ac_cv_env_CXX_set=${CXX+set}
759	>	ac_cv_env_CXX_value=$CXX
760	>	ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761	>	ac_env_CXXFLAGS_value=$CXXFLAGS
762	>	ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763	>	ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764		ac_env_LDFLAGS_set=${LDFLAGS+set}
765		ac_env_LDFLAGS_value=$LDFLAGS
766		ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
#	Line 769 | Line 769 | ac_cv_env_CPPFLAGS_value=$CPPFLAGS
769		ac_env_CPPFLAGS_value=$CPPFLAGS
770		ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771		ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772	<	ac_env_CXX_set=${CXX+set}
773	<	ac_env_CXX_value=$CXX
774	<	ac_cv_env_CXX_set=${CXX+set}
775	<	ac_cv_env_CXX_value=$CXX
776	<	ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777	<	ac_env_CXXFLAGS_value=$CXXFLAGS
778	<	ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779	<	ac_cv_env_CXXFLAGS_value=$CXXFLAGS
772	>	ac_env_CC_set=${CC+set}
773	>	ac_env_CC_value=$CC
774	>	ac_cv_env_CC_set=${CC+set}
775	>	ac_cv_env_CC_value=$CC
776	>	ac_env_CFLAGS_set=${CFLAGS+set}
777	>	ac_env_CFLAGS_value=$CFLAGS
778	>	ac_cv_env_CFLAGS_set=${CFLAGS+set}
779	>	ac_cv_env_CFLAGS_value=$CFLAGS
780	>	ac_env_FC_set=${FC+set}
781	>	ac_env_FC_value=$FC
782	>	ac_cv_env_FC_set=${FC+set}
783	>	ac_cv_env_FC_value=$FC
784	>	ac_env_FCFLAGS_set=${FCFLAGS+set}
785	>	ac_env_FCFLAGS_value=$FCFLAGS
786	>	ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787	>	ac_cv_env_FCFLAGS_value=$FCFLAGS
788		ac_env_CPP_set=${CPP+set}
789		ac_env_CPP_value=$CPP
790		ac_cv_env_CPP_set=${CPP+set}
791		ac_cv_env_CPP_value=$CPP
784	–	ac_env_F90_set=${F90+set}
785	–	ac_env_F90_value=$F90
786	–	ac_cv_env_F90_set=${F90+set}
787	–	ac_cv_env_F90_value=$F90
788	–	ac_env_F90FLAGS_set=${F90FLAGS+set}
789	–	ac_env_F90FLAGS_value=$F90FLAGS
790	–	ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791	–	ac_cv_env_F90FLAGS_value=$F90FLAGS
792		ac_env_CXXCPP_set=${CXXCPP+set}
793		ac_env_CXXCPP_value=$CXXCPP
794		ac_cv_env_CXXCPP_set=${CXXCPP+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-doxygen        enable documentation generation with doxygen (auto)
875		--enable-dot            use 'dot' to generate graphs in doxygen (auto)
876		--enable-html-docs      enable HTML generation with doxygen (yes)
877		--enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877	–	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878
879		Optional Packages:
880		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882	+	--with-perl-shebang     override what perl thinks is the way for the kernel
883	+	to start it (seldom needed)
884		--with-zlib=DIR root directory path of zlib installation defaults to
885		/usr/local or /usr if not found in /usr/local
886		--without-zlib to disable zlib usage completely
887	<	--with-perl-shebang     override what perl thinks is the way for the kernel
886	<	to start it (seldom needed)
887	>	--without-fftw          if you turn this off you cannot compute undulation spectra
888		--with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889		--with-cgal-makefile=FILE  CGAL makefile that should be used
890
891		Some influential environment variables:
892	<	CC          C compiler command
893	<	CFLAGS      C compiler flags
892	>	CXX         C++ compiler command
893	>	CXXFLAGS    C++ compiler flags
894		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895		nonstandard directory <lib dir>
896		CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897		headers in a nonstandard directory <include dir>
898	<	CXX         C++ compiler command
899	<	CXXFLAGS    C++ compiler flags
898	>	CC          C compiler command
899	>	CFLAGS      C compiler flags
900	>	FC          Fortran compiler command
901	>	FCFLAGS     Fortran compiler flags
902		CPP         C preprocessor
900	–	F90         Fortran 90 compiler command
901	–	F90FLAGS    Fortran 90 compiler flags
903		CXXCPP      C++ preprocessor
904
905		Use these variables to override the choices made by `configure' or to help
#	Line 1000 | Line 1001 | if $ac_init_version; then
1001		test -n "$ac_init_help" && exit 0
1002		if $ac_init_version; then
1003		cat <<\_ACEOF
1004	<	OOPSE configure 2.0
1004	>	OOPSE configure 3.0
1005		generated by GNU Autoconf 2.59
1006
1007		Copyright (C) 2003 Free Software Foundation, Inc.
#	Line 1014 | Line 1015 | running configure, to aid debugging if configure makes
1015		This file contains any messages produced by compilers while
1016		running configure, to aid debugging if configure makes a mistake.
1017
1018	<	It was created by OOPSE $as_me 2.0, which was
1018	>	It was created by OOPSE $as_me 3.0, which was
1019		generated by GNU Autoconf 2.59.  Invocation command line was
1020
1021		$ $0 $@
#	Line 1376 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377		ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1378
1379
1380	<	# This file is part of Autoconf.                       -*- Autoconf -*-
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).
1428	<
1429	<
1430	<	# 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
1453	<
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
1464	<
1465	<
1466	<
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
1496	<
1497	<
1498	<
1499	<	## ----------------------- ##
1500	<	## 1. Language selection.  ##
1501	<	## ----------------------- ##
1502	<
1503	<	# ----------------------------- #
1504	<	# 1b. The Fortran 90 language.  #
1505	<	# ----------------------------- #
1506	<
1507	<	# AC_LANG(Fortran 90)
1508	<	# -------------------
1509	<
1510	<
1511	<
1512	<	# _AC_LANG_ABBREV(Fortran 90)
1513	<	# ---------------------------
1514	<
1515	<
1516	<
1517	<	# ----------------------------- #
1518	<	# 1c. The Fortran 95 language.  #
1519	<	# ----------------------------- #
1520	<
1521	<	# AC_LANG(Fortran 95)
1522	<	# -------------------
1523	<
1524	<
1525	<
1526	<	# _AC_LANG_ABBREV(Fortran 95)
1527	<	# ---------------------------
1528	<
1529	<
1530	<
1531	<	## ---------------------- ##
1532	<	## 2.Producing programs.  ##
1533	<	## ---------------------- ##
1534	<
1535	<	# ------------------------ #
1536	<	# 2b. Fortran 90 sources.  #
1537	<	# ------------------------ #
1538	<
1539	<	# AC_LANG_SOURCE(Fortran 90)(BODY)
1540	<	# --------------------------------
1541	<
1542	<
1543	<
1544	<	# AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545	<	# -----------------------------------------------
1546	<
1547	<
1548	<	# AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549	<	# --------------------------------------------
1550	<
1551	<
1552	<
1553	<	# ------------------------ #
1554	<	# 2c. Fortran 95 sources.  #
1555	<	# ------------------------ #
1556	<
1557	<	# AC_LANG_SOURCE(Fortran 95)(BODY)
1558	<	# --------------------------------
1559	<
1380	>	ac_config_headers="$ac_config_headers src/config.h"
1381
1561	–	# AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562	–	# -----------------------------------------------
1382
1383
1565	–	# AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566	–	# --------------------------------------------
1384
1385
1386
1570	–	## -------------------------------------------- ##
1571	–	## 3. Looking for Compilers and Preprocessors.  ##
1572	–	## -------------------------------------------- ##
1387
1574	–	# ----------------------------- #
1575	–	# 3b. The Fortran 90 compiler.  #
1576	–	# ----------------------------- #
1388
1389
1579	–	# AC_LANG_PREPROC(Fortran 90)
1580	–	# ---------------------------
1581	–	# Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1390
1391
1392
1585	–	# AC_LANG_COMPILER(Fortran 90)
1586	–	# ----------------------------
1587	–	# Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588	–	# AC_REQUIRE'able.
1393
1394
1395
1592	–	# AC_PROG_F90([COMPILERS...])
1593	–	# ---------------------------
1594	–	# COMPILERS is a space separated list of Fortran 90 compilers to search
1595	–	# for.
1596	–	#
1597	–	# Compilers are ordered by
1598	–	#  1. F90, F95
1599	–	#  2. Good/tested native compilers, bad/untested native compilers
1600	–	#
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
1396
1397
1609	–	# ----------------------------- #
1610	–	# 3c. The Fortran 95 compiler.  #
1611	–	# ----------------------------- #
1398
1399
1614	–	# AC_LANG_PREPROC(Fortran 95)
1615	–	# ---------------------------
1616	–	# Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1400
1401
1402
1620	–	# AC_LANG_COMPILER(Fortran 95)
1621	–	# ----------------------------
1622	–	# Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623	–	# AC_REQUIRE'able.
1403
1404
1405
1627	–	# AC_PROG_F95([COMPILERS...])
1628	–	# ---------------------------
1629	–	# COMPILERS is a space separated list of Fortran 95 compilers to search
1630	–	# for.
1631	–	#
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
1406
1407
1641	–	## ------------------------------- ##
1642	–	## 4. Compilers' characteristics.  ##
1643	–	## ------------------------------- ##
1408
1409
1646	–	# ---------------------------------------- #
1647	–	# 4b. Fortan 90 compiler characteristics.  #
1648	–	# ---------------------------------------- #
1410
1411
1651	–	# _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1652	–	# -------------------------------------------------
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
1412
1413
1662	–	# _AC_PROG_F90_V
1663	–	# --------------
1664	–	#
1665	–	# 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
1414
1415
1672	–	# AC_F90_LIBRARY_LDFLAGS
1673	–	# ----------------------
1674	–	#
1675	–	# 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
1416
1417	+	# ACX_CHECK_FFTW()
1418	+	# ----------------
1419	+	# This macro checks for fftw header files and libraries,
1420	+	# including the possible prefixing with s or d to determine precision.
1421	+	# Arg 1 is the fftw header/library name to check for, without
1422	+	# prefix or anything else (e.g. rfftw_mpi for real MPI transforms)
1423	+	# Arg 2 is the size of the real variable used.
1424
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
1425
1717	–	# The replacement is empty.
1426
1427
1428
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
1429
1430
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
1431
1432
1738	–	# ---------------------------------------- #
1739	–	# 4c. Fortan 95 compiler characteristics.  #
1740	–	# ---------------------------------------- #
1433
1434
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
1435
1753	–
1754	–	# _AC_PROG_F95_V
1755	–	# --------------
1436		#
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
1762	–
1763	–
1764	–	# AC_F95_LIBRARY_LDFLAGS
1765	–	# ----------------------
1437		#
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.
1438		#
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
1439
1440
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
1808	–
1809	–	# The replacement is empty.
1810	–
1811	–
1812	–
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
1820	–
1821	–
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
1828	–
1441		# AC_F90_MODULE_NAMES
1442		# -------------------
1443		#
#	Line 1868 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480
1481
1482
1871	–
1872	–
1873	–
1874	–
1875	–
1876	–
1877	–
1878	–
1879	–
1880	–
1881	–
1882	–
1883	–
1884	–
1885	–
1886	–
1887	–
1888	–	#
1889	–	#
1890	–	#
1891	–
1892	–
1893	–
1894	–
1895	–
1896	–
1897	–
1898	–
1899	–	# set program name
1900	–	PROGNAME="oopse"
1901	–
1902	–
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	–
1483		# who am i
1484		# Make sure we can run config.sub.
1485		$ac_config_sub sun4 >/dev/null 2>&1 ||
#	Line 1977 | Line 1538 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1538
1539
1540
1541	<	ac_ext=c
1542	<	ac_cpp='$CPP $CPPFLAGS'
1543	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1544	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1545	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
1541	>	# set program name
1542	>	PROGNAME="oopse"
1543	>
1544	>
1545	>
1546	>
1547	>	OBJEXT=".$OBJEXT"
1548	>
1549	>	OOPSE=oopse
1550	>
1551	>	if test "x${prefix}" = "xNONE"
1552	>	then
1553	>	OOPSE_HOME=${ac_default_prefix}/oopse
1554	>	else
1555	>	OOPSE_HOME=${prefix}/oopse
1556	>	fi
1557	>	# Check whether --enable-oopse-home or --disable-oopse-home was given.
1558	>	if test "${enable_oopse_home+set}" = set; then
1559	>	enableval="$enable_oopse_home"
1560	>	OOPSE_HOME="${enableval}"
1561	>	fi;
1562	>
1563	>	# there are two ways to do debugging.  One with the --enable-debug flag
1564	>	# and one using the DEBUG environment variable
1565	>
1566	>	debug=0
1567	>	# Check whether --enable-debug or --disable-debug was given.
1568	>	if test "${enable_debug+set}" = set; then
1569	>	enableval="$enable_debug"
1570	>	debug=1
1571	>	fi;
1572	>	if test "${DEBUG}"; then
1573	>
1574	>	cat >>confdefs.h <<\_ACEOF
1575	>	#define debug 1
1576	>	_ACEOF
1577	>
1578	>	msg="$msg, debug mode"
1579	>	fi
1580	>
1581	>
1582	>	# Checks for programs.
1583	>	ac_ext=cc
1584	>	ac_cpp='$CXXCPP $CPPFLAGS'
1585	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588		if test -n "$ac_tool_prefix"; then
1589	<	for ac_prog in icc xlc gcc cc
1589	>	for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1590		do
1591		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1592		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1593		echo "$as_me:$LINENO: checking for $ac_word" >&5
1594		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1595	<	if test "${ac_cv_prog_CC+set}" = set; then
1595	>	if test "${ac_cv_prog_CXX+set}" = set; then
1596		echo $ECHO_N "(cached) $ECHO_C" >&6
1597		else
1598	<	if test -n "$CC"; then
1599	<	ac_cv_prog_CC="$CC" # Let the user override the test.
1598	>	if test -n "$CXX"; then
1599	>	ac_cv_prog_CXX="$CXX" # Let the user override the test.
1600		else
1601		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1602		for as_dir in $PATH
#	Line 2002 | Line 1605 | do
1605		test -z "$as_dir" && as_dir=.
1606		for ac_exec_ext in '' $ac_executable_extensions; do
1607		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1608	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1608	>	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1609		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1610		break 2
1611		fi
#	Line 2011 | Line 1614 | fi
1614
1615		fi
1616		fi
1617	<	CC=$ac_cv_prog_CC
1618	<	if test -n "$CC"; then
1619	<	echo "$as_me:$LINENO: result: $CC" >&5
1620	<	echo "${ECHO_T}$CC" >&6
1617	>	CXX=$ac_cv_prog_CXX
1618	>	if test -n "$CXX"; then
1619	>	echo "$as_me:$LINENO: result: $CXX" >&5
1620	>	echo "${ECHO_T}$CXX" >&6
1621		else
1622		echo "$as_me:$LINENO: result: no" >&5
1623		echo "${ECHO_T}no" >&6
1624		fi
1625
1626	<	test -n "$CC" && break
1626	>	test -n "$CXX" && break
1627		done
1628		fi
1629	<	if test -z "$CC"; then
1630	<	ac_ct_CC=$CC
1631	<	for ac_prog in icc xlc gcc cc
1629	>	if test -z "$CXX"; then
1630	>	ac_ct_CXX=$CXX
1631	>	for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1632		do
1633		# Extract the first word of "$ac_prog", so it can be a program name with args.
1634		set dummy $ac_prog; ac_word=$2
1635		echo "$as_me:$LINENO: checking for $ac_word" >&5
1636		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1637	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1637	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1638		echo $ECHO_N "(cached) $ECHO_C" >&6
1639		else
1640	<	if test -n "$ac_ct_CC"; then
1641	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1640	>	if test -n "$ac_ct_CXX"; then
1641	>	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1642		else
1643		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644		for as_dir in $PATH
#	Line 2044 | Line 1647 | do
1647		test -z "$as_dir" && as_dir=.
1648		for ac_exec_ext in '' $ac_executable_extensions; do
1649		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1650	<	ac_cv_prog_ac_ct_CC="$ac_prog"
1650	>	ac_cv_prog_ac_ct_CXX="$ac_prog"
1651		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1652		break 2
1653		fi
#	Line 2053 | Line 1656 | fi
1656
1657		fi
1658		fi
1659	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660	<	if test -n "$ac_ct_CC"; then
1661	<	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662	<	echo "${ECHO_T}$ac_ct_CC" >&6
1659	>	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660	>	if test -n "$ac_ct_CXX"; then
1661	>	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662	>	echo "${ECHO_T}$ac_ct_CXX" >&6
1663		else
1664		echo "$as_me:$LINENO: result: no" >&5
1665		echo "${ECHO_T}no" >&6
1666		fi
1667
1668	<	test -n "$ac_ct_CC" && break
1668	>	test -n "$ac_ct_CXX" && break
1669		done
1670	+	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671
1672	<	CC=$ac_ct_CC
1672	>	CXX=$ac_ct_CXX
1673		fi
1674
1675
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	–
1676		# Provide some information about the compiler.
1677		echo "$as_me:$LINENO:" \
1678	<	"checking for C compiler version" >&5
1678	>	"checking for C++ compiler version" >&5
1679		ac_compiler=`set X $ac_compile; echo $2`
1680		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1681		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2115 | Line 1713 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1713		# Try to create an executable without -o first, disregard a.out.
1714		# It will help us diagnose broken compilers, and finding out an intuition
1715		# of exeext.
1716	<	echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1717	<	echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1716	>	echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717	>	echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718		ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719		if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720		(eval $ac_link_default) 2>&5
#	Line 2159 | Line 1757 | sed 's/^/| /' conftest.$ac_ext >&5
1757		echo "$as_me: failed program was:" >&5
1758		sed 's/^/| /' conftest.$ac_ext >&5
1759
1760	<	{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
1760	>	{ { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1761		See \`config.log' for more details." >&5
1762	<	echo "$as_me: error: C compiler cannot create executables
1762	>	echo "$as_me: error: C++ compiler cannot create executables
1763		See \`config.log' for more details." >&2;}
1764		{ (exit 77); exit 77; }; }
1765		fi
#	Line 2172 | Line 1770 | echo "${ECHO_T}$ac_file" >&6
1770
1771		# Check the compiler produces executables we can run.  If not, either
1772		# the compiler is broken, or we cross compile.
1773	<	echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774	<	echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773	>	echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774	>	echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775		# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776		# If not cross compiling, check that we can run a simple program.
1777		if test "$cross_compiling" != yes; then
#	Line 2188 | Line 1786 | if test "$cross_compiling" != yes; then
1786		if test "$cross_compiling" = maybe; then
1787		cross_compiling=yes
1788		else
1789	<	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1789	>	{ { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1790		If you meant to cross compile, use \`--host'.
1791		See \`config.log' for more details." >&5
1792	<	echo "$as_me: error: cannot run C compiled programs.
1792	>	echo "$as_me: error: cannot run C++ compiled programs.
1793		If you meant to cross compile, use \`--host'.
1794		See \`config.log' for more details." >&2;}
1795		{ (exit 1); exit 1; }; }
#	Line 2296 | Line 1894 | ac_objext=$OBJEXT
1894		echo "${ECHO_T}$ac_cv_objext" >&6
1895		OBJEXT=$ac_cv_objext
1896		ac_objext=$OBJEXT
1897	<	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898	<	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897	>	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898	>	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900		echo $ECHO_N "(cached) $ECHO_C" >&6
1901		else
1902		cat >conftest.$ac_ext <<_ACEOF
#	Line 2328 | Line 1926 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1926		cat conftest.err >&5
1927		echo "$as_me:$LINENO: \$? = $ac_status" >&5
1928		(exit $ac_status); } &&
1929	<	{ ac_try='test -z "$ac_c_werror_flag"
1929	>	{ ac_try='test -z "$ac_cxx_werror_flag"
1930		|| test ! -s conftest.err'
1931		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1932		(eval $ac_try) 2>&5
#	Line 2349 | Line 1947 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
1947		ac_compiler_gnu=no
1948		fi
1949		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
1950	>	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951
1952		fi
1953	<	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954	<	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955	<	GCC=`test $ac_compiler_gnu = yes && echo yes`
1956	<	ac_test_CFLAGS=${CFLAGS+set}
1957	<	ac_save_CFLAGS=$CFLAGS
1958	<	CFLAGS="-g"
1959	<	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960	<	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961	<	if test "${ac_cv_prog_cc_g+set}" = set; then
1953	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954	>	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955	>	GXX=`test $ac_compiler_gnu = yes && echo yes`
1956	>	ac_test_CXXFLAGS=${CXXFLAGS+set}
1957	>	ac_save_CXXFLAGS=$CXXFLAGS
1958	>	CXXFLAGS="-g"
1959	>	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960	>	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961	>	if test "${ac_cv_prog_cxx_g+set}" = set; then
1962		echo $ECHO_N "(cached) $ECHO_C" >&6
1963		else
1964		cat >conftest.$ac_ext <<_ACEOF
#	Line 2387 | Line 1985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1985		cat conftest.err >&5
1986		echo "$as_me:$LINENO: \$? = $ac_status" >&5
1987		(exit $ac_status); } &&
1988	<	{ ac_try='test -z "$ac_c_werror_flag"
1988	>	{ ac_try='test -z "$ac_cxx_werror_flag"
1989		|| test ! -s conftest.err'
1990		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1991		(eval $ac_try) 2>&5
#	Line 2400 | Line 1998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1998		ac_status=$?
1999		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2000		(exit $ac_status); }; }; then
2001	<	ac_cv_prog_cc_g=yes
2001	>	ac_cv_prog_cxx_g=yes
2002		else
2003		echo "$as_me: failed program was:" >&5
2004		sed 's/^/| /' conftest.$ac_ext >&5
2005
2006	<	ac_cv_prog_cc_g=no
2006	>	ac_cv_prog_cxx_g=no
2007		fi
2008		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2009		fi
2010	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2011	<	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2012	<	if test "$ac_test_CFLAGS" = set; then
2013	<	CFLAGS=$ac_save_CFLAGS
2014	<	elif test $ac_cv_prog_cc_g = yes; then
2015	<	if test "$GCC" = yes; then
2016	<	CFLAGS="-g -O2"
2010	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2011	>	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2012	>	if test "$ac_test_CXXFLAGS" = set; then
2013	>	CXXFLAGS=$ac_save_CXXFLAGS
2014	>	elif test $ac_cv_prog_cxx_g = yes; then
2015	>	if test "$GXX" = yes; then
2016	>	CXXFLAGS="-g -O2"
2017		else
2018	<	CFLAGS="-g"
2018	>	CXXFLAGS="-g"
2019		fi
2020		else
2021	<	if test "$GCC" = yes; then
2022	<	CFLAGS="-O2"
2021	>	if test "$GXX" = yes; then
2022	>	CXXFLAGS="-O2"
2023		else
2024	<	CFLAGS=
2024	>	CXXFLAGS=
2025		fi
2026		fi
2027	<	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2430	<	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2431	<	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2432	<	echo $ECHO_N "(cached) $ECHO_C" >&6
2433	<	else
2434	<	ac_cv_prog_cc_stdc=no
2435	<	ac_save_CC=$CC
2436	<	cat >conftest.$ac_ext <<_ACEOF
2437	<	/* confdefs.h.  */
2438	<	_ACEOF
2439	<	cat confdefs.h >>conftest.$ac_ext
2440	<	cat >>conftest.$ac_ext <<_ACEOF
2441	<	/* end confdefs.h.  */
2442	<	#include <stdarg.h>
2443	<	#include <stdio.h>
2444	<	#include <sys/types.h>
2445	<	#include <sys/stat.h>
2446	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2447	<	struct buf { int x; };
2448	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2449	<	static char *e (p, i)
2450	<	char **p;
2451	<	int i;
2452	<	{
2453	<	return p[i];
2454	<	}
2455	<	static char *f (char * (*g) (char **, int), char **p, ...)
2456	<	{
2457	<	char *s;
2458	<	va_list v;
2459	<	va_start (v,p);
2460	<	s = g (p, va_arg (v,int));
2461	<	va_end (v);
2462	<	return s;
2463	<	}
2464	<
2465	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2466	<	function prototypes and stuff, but not '\xHH' hex character constants.
2467	<	These don't provoke an error unfortunately, instead are silently treated
2468	<	as 'x'.  The following induces an error, until -std1 is added to get
2469	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2470	<	array size at least.  It's necessary to write '\x00'==0 to get something
2471	<	that's true only with -std1.  */
2472	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2473	<
2474	<	int test (int i, double x);
2475	<	struct s1 {int (*f) (int a);};
2476	<	struct s2 {int (*f) (double a);};
2477	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2478	<	int argc;
2479	<	char **argv;
2480	<	int
2481	<	main ()
2482	<	{
2483	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2484	<	;
2485	<	return 0;
2486	<	}
2487	<	_ACEOF
2488	<	# Don't try gcc -ansi; that turns off useful extensions and
2489	<	# breaks some systems' header files.
2490	<	# AIX                   -qlanglvl=ansi
2491	<	# Ultrix and OSF/1      -std1
2492	<	# HP-UX 10.20 and later -Ae
2493	<	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2494	<	# SVR4                  -Xc -D__EXTENSIONS__
2495	<	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2496	<	do
2497	<	CC="$ac_save_CC $ac_arg"
2498	<	rm -f conftest.$ac_objext
2499	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2500	<	(eval $ac_compile) 2>conftest.er1
2501	<	ac_status=$?
2502	<	grep -v '^ *+' conftest.er1 >conftest.err
2503	<	rm -f conftest.er1
2504	<	cat conftest.err >&5
2505	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2506	<	(exit $ac_status); } &&
2507	<	{ ac_try='test -z "$ac_c_werror_flag"
2508	<	|| test ! -s conftest.err'
2509	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2510	<	(eval $ac_try) 2>&5
2511	<	ac_status=$?
2512	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2513	<	(exit $ac_status); }; } &&
2514	<	{ ac_try='test -s conftest.$ac_objext'
2515	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2516	<	(eval $ac_try) 2>&5
2517	<	ac_status=$?
2518	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519	<	(exit $ac_status); }; }; then
2520	<	ac_cv_prog_cc_stdc=$ac_arg
2521	<	break
2522	<	else
2523	<	echo "$as_me: failed program was:" >&5
2524	<	sed 's/^/| /' conftest.$ac_ext >&5
2525	<
2526	<	fi
2527	<	rm -f conftest.err conftest.$ac_objext
2528	<	done
2529	<	rm -f conftest.$ac_ext conftest.$ac_objext
2530	<	CC=$ac_save_CC
2531	<
2532	<	fi
2533	<
2534	<	case "x$ac_cv_prog_cc_stdc" in
2535	<	x|xno)
2536	<	echo "$as_me:$LINENO: result: none needed" >&5
2537	<	echo "${ECHO_T}none needed" >&6 ;;
2538	<	*)
2539	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2540	<	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2541	<	CC="$CC $ac_cv_prog_cc_stdc" ;;
2542	<	esac
2543	<
2544	<	# Some people use a C++ compiler to compile C.  Since we use `exit',
2545	<	# in C++ we need to declare it.  In case someone uses the same compiler
2546	<	# for both compiling C and C++ we need to have the C++ compiler decide
2547	<	# the declaration of exit, since it's the most demanding environment.
2548	<	cat >conftest.$ac_ext <<_ACEOF
2549	<	#ifndef __cplusplus
2550	<	choke me
2551	<	#endif
2552	<	_ACEOF
2553	<	rm -f conftest.$ac_objext
2554	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2555	<	(eval $ac_compile) 2>conftest.er1
2556	<	ac_status=$?
2557	<	grep -v '^ *+' conftest.er1 >conftest.err
2558	<	rm -f conftest.er1
2559	<	cat conftest.err >&5
2560	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2561	<	(exit $ac_status); } &&
2562	<	{ ac_try='test -z "$ac_c_werror_flag"
2563	<	|| test ! -s conftest.err'
2564	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2565	<	(eval $ac_try) 2>&5
2566	<	ac_status=$?
2567	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2568	<	(exit $ac_status); }; } &&
2569	<	{ ac_try='test -s conftest.$ac_objext'
2570	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2571	<	(eval $ac_try) 2>&5
2572	<	ac_status=$?
2573	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2574	<	(exit $ac_status); }; }; then
2575	<	for ac_declaration in \
2027	>	for ac_declaration in \
2028		'' \
2029		'extern "C" void std::exit (int) throw (); using std::exit;' \
2030		'extern "C" void std::exit (int); using std::exit;' \
#	Line 2605 | Line 2057 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2057		cat conftest.err >&5
2058		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2059		(exit $ac_status); } &&
2060	<	{ ac_try='test -z "$ac_c_werror_flag"
2060	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2061		|| test ! -s conftest.err'
2062		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2063		(eval $ac_try) 2>&5
#	Line 2650 | Line 2102 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2102		cat conftest.err >&5
2103		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104		(exit $ac_status); } &&
2105	<	{ ac_try='test -z "$ac_c_werror_flag"
2105	>	{ ac_try='test -z "$ac_cxx_werror_flag"
2106		|| test ! -s conftest.err'
2107		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108		(eval $ac_try) 2>&5
#	Line 2678 | Line 2130 | fi
2130		echo '#endif'             >>confdefs.h
2131		fi
2132
2681	–	else
2682	–	echo "$as_me: failed program was:" >&5
2683	–	sed 's/^/| /' conftest.$ac_ext >&5
2684	–
2685	–	fi
2686	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2133		ac_ext=c
2134		ac_cpp='$CPP $CPPFLAGS'
2135		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2136		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2137		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2138
2139	<
2140	<	ac_ext=cc
2141	<	ac_cpp='$CXXCPP $CPPFLAGS'
2142	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2143	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2139	>	ac_ext=c
2140	>	ac_cpp='$CPP $CPPFLAGS'
2141	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2142	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2143	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2144		if test -n "$ac_tool_prefix"; then
2145	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2145	>	for ac_prog in icc pgcc pathcc cc xlc gcc
2146		do
2147		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2148		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2149		echo "$as_me:$LINENO: checking for $ac_word" >&5
2150		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2151	<	if test "${ac_cv_prog_CXX+set}" = set; then
2151	>	if test "${ac_cv_prog_CC+set}" = set; then
2152		echo $ECHO_N "(cached) $ECHO_C" >&6
2153		else
2154	<	if test -n "$CXX"; then
2155	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
2154	>	if test -n "$CC"; then
2155	>	ac_cv_prog_CC="$CC" # Let the user override the test.
2156		else
2157		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2158		for as_dir in $PATH
#	Line 2716 | Line 2161 | do
2161		test -z "$as_dir" && as_dir=.
2162		for ac_exec_ext in '' $ac_executable_extensions; do
2163		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2164	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2164	>	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2165		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2166		break 2
2167		fi
#	Line 2725 | Line 2170 | fi
2170
2171		fi
2172		fi
2173	<	CXX=$ac_cv_prog_CXX
2174	<	if test -n "$CXX"; then
2175	<	echo "$as_me:$LINENO: result: $CXX" >&5
2176	<	echo "${ECHO_T}$CXX" >&6
2173	>	CC=$ac_cv_prog_CC
2174	>	if test -n "$CC"; then
2175	>	echo "$as_me:$LINENO: result: $CC" >&5
2176	>	echo "${ECHO_T}$CC" >&6
2177		else
2178		echo "$as_me:$LINENO: result: no" >&5
2179		echo "${ECHO_T}no" >&6
2180		fi
2181
2182	<	test -n "$CXX" && break
2182	>	test -n "$CC" && break
2183		done
2184		fi
2185	<	if test -z "$CXX"; then
2186	<	ac_ct_CXX=$CXX
2187	<	for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2185	>	if test -z "$CC"; then
2186	>	ac_ct_CC=$CC
2187	>	for ac_prog in icc pgcc pathcc cc xlc gcc
2188		do
2189		# Extract the first word of "$ac_prog", so it can be a program name with args.
2190		set dummy $ac_prog; ac_word=$2
2191		echo "$as_me:$LINENO: checking for $ac_word" >&5
2192		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2193	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2193	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2194		echo $ECHO_N "(cached) $ECHO_C" >&6
2195		else
2196	<	if test -n "$ac_ct_CXX"; then
2197	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2196	>	if test -n "$ac_ct_CC"; then
2197	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2198		else
2199		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2200		for as_dir in $PATH
#	Line 2758 | Line 2203 | do
2203		test -z "$as_dir" && as_dir=.
2204		for ac_exec_ext in '' $ac_executable_extensions; do
2205		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2206	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
2206	>	ac_cv_prog_ac_ct_CC="$ac_prog"
2207		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2208		break 2
2209		fi
#	Line 2767 | Line 2212 | fi
2212
2213		fi
2214		fi
2215	<	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216	<	if test -n "$ac_ct_CXX"; then
2217	<	echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218	<	echo "${ECHO_T}$ac_ct_CXX" >&6
2215	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216	>	if test -n "$ac_ct_CC"; then
2217	>	echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218	>	echo "${ECHO_T}$ac_ct_CC" >&6
2219		else
2220		echo "$as_me:$LINENO: result: no" >&5
2221		echo "${ECHO_T}no" >&6
2222		fi
2223
2224	<	test -n "$ac_ct_CXX" && break
2224	>	test -n "$ac_ct_CC" && break
2225		done
2781	–	test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2226
2227	<	CXX=$ac_ct_CXX
2227	>	CC=$ac_ct_CC
2228		fi
2229
2230
2231	+	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2232	+	See \`config.log' for more details." >&5
2233	+	echo "$as_me: error: no acceptable C compiler found in \$PATH
2234	+	See \`config.log' for more details." >&2;}
2235	+	{ (exit 1); exit 1; }; }
2236	+
2237		# Provide some information about the compiler.
2238		echo "$as_me:$LINENO:" \
2239	<	"checking for C++ compiler version" >&5
2239	>	"checking for C compiler version" >&5
2240		ac_compiler=`set X $ac_compile; echo $2`
2241		{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2242		(eval $ac_compiler --version </dev/null >&5) 2>&5
#	Line 2804 | Line 2254 | ac_compiler=`set X $ac_compile; echo $2`
2254		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255		(exit $ac_status); }
2256
2257	<	echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258	<	echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257	>	echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258	>	echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260		echo $ECHO_N "(cached) $ECHO_C" >&6
2261		else
2262		cat >conftest.$ac_ext <<_ACEOF
#	Line 2836 | Line 2286 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2286		cat conftest.err >&5
2287		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2288		(exit $ac_status); } &&
2289	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2289	>	{ ac_try='test -z "$ac_c_werror_flag"
2290		|| test ! -s conftest.err'
2291		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2292		(eval $ac_try) 2>&5
#	Line 2857 | Line 2307 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2307		ac_compiler_gnu=no
2308		fi
2309		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2310	>	ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311
2312		fi
2313	<	echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314	<	echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315	<	GXX=`test $ac_compiler_gnu = yes && echo yes`
2316	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
2317	<	ac_save_CXXFLAGS=$CXXFLAGS
2318	<	CXXFLAGS="-g"
2319	<	echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320	<	echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321	<	if test "${ac_cv_prog_cxx_g+set}" = set; then
2313	>	echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314	>	echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315	>	GCC=`test $ac_compiler_gnu = yes && echo yes`
2316	>	ac_test_CFLAGS=${CFLAGS+set}
2317	>	ac_save_CFLAGS=$CFLAGS
2318	>	CFLAGS="-g"
2319	>	echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320	>	echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321	>	if test "${ac_cv_prog_cc_g+set}" = set; then
2322		echo $ECHO_N "(cached) $ECHO_C" >&6
2323		else
2324		cat >conftest.$ac_ext <<_ACEOF
#	Line 2895 | Line 2345 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2345		cat conftest.err >&5
2346		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2347		(exit $ac_status); } &&
2348	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2348	>	{ ac_try='test -z "$ac_c_werror_flag"
2349		|| test ! -s conftest.err'
2350		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2351		(eval $ac_try) 2>&5
#	Line 2908 | Line 2358 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2358		ac_status=$?
2359		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2360		(exit $ac_status); }; }; then
2361	<	ac_cv_prog_cxx_g=yes
2361	>	ac_cv_prog_cc_g=yes
2362		else
2363		echo "$as_me: failed program was:" >&5
2364		sed 's/^/| /' conftest.$ac_ext >&5
2365
2366	<	ac_cv_prog_cxx_g=no
2366	>	ac_cv_prog_cc_g=no
2367		fi
2368		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2369		fi
2370	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2371	<	echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2372	<	if test "$ac_test_CXXFLAGS" = set; then
2373	<	CXXFLAGS=$ac_save_CXXFLAGS
2374	<	elif test $ac_cv_prog_cxx_g = yes; then
2375	<	if test "$GXX" = yes; then
2376	<	CXXFLAGS="-g -O2"
2370	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2371	>	echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2372	>	if test "$ac_test_CFLAGS" = set; then
2373	>	CFLAGS=$ac_save_CFLAGS
2374	>	elif test $ac_cv_prog_cc_g = yes; then
2375	>	if test "$GCC" = yes; then
2376	>	CFLAGS="-g -O2"
2377		else
2378	<	CXXFLAGS="-g"
2378	>	CFLAGS="-g"
2379		fi
2380		else
2381	<	if test "$GXX" = yes; then
2382	<	CXXFLAGS="-O2"
2381	>	if test "$GCC" = yes; then
2382	>	CFLAGS="-O2"
2383		else
2384	<	CXXFLAGS=
2384	>	CFLAGS=
2385		fi
2386		fi
2387	<	for ac_declaration in \
2388	<	'' \
2389	<	'extern "C" void std::exit (int) throw (); using std::exit;' \
2390	<	'extern "C" void std::exit (int); using std::exit;' \
2391	<	'extern "C" void exit (int) throw ();' \
2392	<	'extern "C" void exit (int);' \
2393	<	'void exit (int);'
2394	<	do
2945	<	cat >conftest.$ac_ext <<_ACEOF
2387	>	echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2388	>	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2389	>	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2390	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2391	>	else
2392	>	ac_cv_prog_cc_stdc=no
2393	>	ac_save_CC=$CC
2394	>	cat >conftest.$ac_ext <<_ACEOF
2395		/* confdefs.h.  */
2396		_ACEOF
2397		cat confdefs.h >>conftest.$ac_ext
2398		cat >>conftest.$ac_ext <<_ACEOF
2399		/* end confdefs.h.  */
2400	<	$ac_declaration
2401	<	#include <stdlib.h>
2402	<	int
2403	<	main ()
2404	<	{
2405	<	exit (42);
2406	<	;
2407	<	return 0;
2408	<	}
2409	<	_ACEOF
2400	>	#include <stdarg.h>
2401	>	#include <stdio.h>
2402	>	#include <sys/types.h>
2403	>	#include <sys/stat.h>
2404	>	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405	>	struct buf { int x; };
2406	>	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407	>	static char *e (p, i)
2408	>	char **p;
2409	>	int i;
2410	>	{
2411	>	return p[i];
2412	>	}
2413	>	static char *f (char * (*g) (char **, int), char **p, ...)
2414	>	{
2415	>	char *s;
2416	>	va_list v;
2417	>	va_start (v,p);
2418	>	s = g (p, va_arg (v,int));
2419	>	va_end (v);
2420	>	return s;
2421	>	}
2422	>
2423	>	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424	>	function prototypes and stuff, but not '\xHH' hex character constants.
2425	>	These don't provoke an error unfortunately, instead are silently treated
2426	>	as 'x'.  The following induces an error, until -std1 is added to get
2427	>	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428	>	array size at least.  It's necessary to write '\x00'==0 to get something
2429	>	that's true only with -std1.  */
2430	>	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431	>
2432	>	int test (int i, double x);
2433	>	struct s1 {int (*f) (int a);};
2434	>	struct s2 {int (*f) (double a);};
2435	>	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436	>	int argc;
2437	>	char **argv;
2438	>	int
2439	>	main ()
2440	>	{
2441	>	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442	>	;
2443	>	return 0;
2444	>	}
2445	>	_ACEOF
2446	>	# Don't try gcc -ansi; that turns off useful extensions and
2447	>	# breaks some systems' header files.
2448	>	# AIX                   -qlanglvl=ansi
2449	>	# Ultrix and OSF/1      -std1
2450	>	# HP-UX 10.20 and later -Ae
2451	>	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2452	>	# SVR4                  -Xc -D__EXTENSIONS__
2453	>	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454	>	do
2455	>	CC="$ac_save_CC $ac_arg"
2456	>	rm -f conftest.$ac_objext
2457	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458	>	(eval $ac_compile) 2>conftest.er1
2459	>	ac_status=$?
2460	>	grep -v '^ *+' conftest.er1 >conftest.err
2461	>	rm -f conftest.er1
2462	>	cat conftest.err >&5
2463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464	>	(exit $ac_status); } &&
2465	>	{ ac_try='test -z "$ac_c_werror_flag"
2466	>	|| test ! -s conftest.err'
2467	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468	>	(eval $ac_try) 2>&5
2469	>	ac_status=$?
2470	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471	>	(exit $ac_status); }; } &&
2472	>	{ ac_try='test -s conftest.$ac_objext'
2473	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474	>	(eval $ac_try) 2>&5
2475	>	ac_status=$?
2476	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477	>	(exit $ac_status); }; }; then
2478	>	ac_cv_prog_cc_stdc=$ac_arg
2479	>	break
2480	>	else
2481	>	echo "$as_me: failed program was:" >&5
2482	>	sed 's/^/| /' conftest.$ac_ext >&5
2483	>
2484	>	fi
2485	>	rm -f conftest.err conftest.$ac_objext
2486	>	done
2487	>	rm -f conftest.$ac_ext conftest.$ac_objext
2488	>	CC=$ac_save_CC
2489	>
2490	>	fi
2491	>
2492	>	case "x$ac_cv_prog_cc_stdc" in
2493	>	x|xno)
2494	>	echo "$as_me:$LINENO: result: none needed" >&5
2495	>	echo "${ECHO_T}none needed" >&6 ;;
2496	>	*)
2497	>	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498	>	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499	>	CC="$CC $ac_cv_prog_cc_stdc" ;;
2500	>	esac
2501	>
2502	>	# Some people use a C++ compiler to compile C.  Since we use `exit',
2503	>	# in C++ we need to declare it.  In case someone uses the same compiler
2504	>	# for both compiling C and C++ we need to have the C++ compiler decide
2505	>	# the declaration of exit, since it's the most demanding environment.
2506	>	cat >conftest.$ac_ext <<_ACEOF
2507	>	#ifndef __cplusplus
2508	>	choke me
2509	>	#endif
2510	>	_ACEOF
2511		rm -f conftest.$ac_objext
2512		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513		(eval $ac_compile) 2>conftest.er1
#	Line 2967 | Line 2517 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2517		cat conftest.err >&5
2518		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519		(exit $ac_status); } &&
2520	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2520	>	{ ac_try='test -z "$ac_c_werror_flag"
2521		|| test ! -s conftest.err'
2522		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523		(eval $ac_try) 2>&5
#	Line 2980 | Line 2530 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2530		ac_status=$?
2531		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532		(exit $ac_status); }; }; then
2533	+	for ac_declaration in \
2534	+	'' \
2535	+	'extern "C" void std::exit (int) throw (); using std::exit;' \
2536	+	'extern "C" void std::exit (int); using std::exit;' \
2537	+	'extern "C" void exit (int) throw ();' \
2538	+	'extern "C" void exit (int);' \
2539	+	'void exit (int);'
2540	+	do
2541	+	cat >conftest.$ac_ext <<_ACEOF
2542	+	/* confdefs.h.  */
2543	+	_ACEOF
2544	+	cat confdefs.h >>conftest.$ac_ext
2545	+	cat >>conftest.$ac_ext <<_ACEOF
2546	+	/* end confdefs.h.  */
2547	+	$ac_declaration
2548	+	#include <stdlib.h>
2549	+	int
2550	+	main ()
2551	+	{
2552	+	exit (42);
2553	+	;
2554	+	return 0;
2555	+	}
2556	+	_ACEOF
2557	+	rm -f conftest.$ac_objext
2558	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2559	+	(eval $ac_compile) 2>conftest.er1
2560	+	ac_status=$?
2561	+	grep -v '^ *+' conftest.er1 >conftest.err
2562	+	rm -f conftest.er1
2563	+	cat conftest.err >&5
2564	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565	+	(exit $ac_status); } &&
2566	+	{ ac_try='test -z "$ac_c_werror_flag"
2567	+	|| test ! -s conftest.err'
2568	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2569	+	(eval $ac_try) 2>&5
2570	+	ac_status=$?
2571	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2572	+	(exit $ac_status); }; } &&
2573	+	{ ac_try='test -s conftest.$ac_objext'
2574	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2575	+	(eval $ac_try) 2>&5
2576	+	ac_status=$?
2577	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2578	+	(exit $ac_status); }; }; then
2579		:
2580		else
2581		echo "$as_me: failed program was:" >&5
#	Line 3012 | Line 2608 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2608		cat conftest.err >&5
2609		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610		(exit $ac_status); } &&
2611	<	{ ac_try='test -z "$ac_cxx_werror_flag"
2611	>	{ ac_try='test -z "$ac_c_werror_flag"
2612		|| test ! -s conftest.err'
2613		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2614		(eval $ac_try) 2>&5
#	Line 3040 | Line 2636 | fi
2636		echo '#endif'             >>confdefs.h
2637		fi
2638
2639	+	else
2640	+	echo "$as_me: failed program was:" >&5
2641	+	sed 's/^/| /' conftest.$ac_ext >&5
2642	+
2643	+	fi
2644	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645		ac_ext=c
2646		ac_cpp='$CPP $CPPFLAGS'
2647		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650
2651	+	ac_ext=${FC_SRCEXT-f}
2652	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655	+	if test -n "$ac_tool_prefix"; then
2656	+	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657	+	do
2658	+	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659	+	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
2661	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662	+	if test "${ac_cv_prog_FC+set}" = set; then
2663	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2664	+	else
2665	+	if test -n "$FC"; then
2666	+	ac_cv_prog_FC="$FC" # Let the user override the test.
2667	+	else
2668	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669	+	for as_dir in $PATH
2670	+	do
2671	+	IFS=$as_save_IFS
2672	+	test -z "$as_dir" && as_dir=.
2673	+	for ac_exec_ext in '' $ac_executable_extensions; do
2674	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675	+	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677	+	break 2
2678	+	fi
2679	+	done
2680	+	done
2681
2682	+	fi
2683	+	fi
2684	+	FC=$ac_cv_prog_FC
2685	+	if test -n "$FC"; then
2686	+	echo "$as_me:$LINENO: result: $FC" >&5
2687	+	echo "${ECHO_T}$FC" >&6
2688	+	else
2689	+	echo "$as_me:$LINENO: result: no" >&5
2690	+	echo "${ECHO_T}no" >&6
2691	+	fi
2692	+
2693	+	test -n "$FC" && break
2694	+	done
2695	+	fi
2696	+	if test -z "$FC"; then
2697	+	ac_ct_FC=$FC
2698	+	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699	+	do
2700	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
2701	+	set dummy $ac_prog; ac_word=$2
2702	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
2703	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704	+	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2706	+	else
2707	+	if test -n "$ac_ct_FC"; then
2708	+	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709	+	else
2710	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711	+	for as_dir in $PATH
2712	+	do
2713	+	IFS=$as_save_IFS
2714	+	test -z "$as_dir" && as_dir=.
2715	+	for ac_exec_ext in '' $ac_executable_extensions; do
2716	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717	+	ac_cv_prog_ac_ct_FC="$ac_prog"
2718	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719	+	break 2
2720	+	fi
2721	+	done
2722	+	done
2723	+
2724	+	fi
2725	+	fi
2726	+	ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727	+	if test -n "$ac_ct_FC"; then
2728	+	echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729	+	echo "${ECHO_T}$ac_ct_FC" >&6
2730	+	else
2731	+	echo "$as_me:$LINENO: result: no" >&5
2732	+	echo "${ECHO_T}no" >&6
2733	+	fi
2734	+
2735	+	test -n "$ac_ct_FC" && break
2736	+	done
2737	+
2738	+	FC=$ac_ct_FC
2739	+	fi
2740	+
2741	+
2742	+	# Provide some information about the compiler.
2743	+	echo "$as_me:2743:" \
2744	+	"checking for Fortran compiler version" >&5
2745	+	ac_compiler=`set X $ac_compile; echo $2`
2746	+	{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747	+	(eval $ac_compiler --version </dev/null >&5) 2>&5
2748	+	ac_status=$?
2749	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750	+	(exit $ac_status); }
2751	+	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752	+	(eval $ac_compiler -v </dev/null >&5) 2>&5
2753	+	ac_status=$?
2754	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755	+	(exit $ac_status); }
2756	+	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757	+	(eval $ac_compiler -V </dev/null >&5) 2>&5
2758	+	ac_status=$?
2759	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760	+	(exit $ac_status); }
2761	+	rm -f a.out
2762	+
2763	+	# If we don't use `.F' as extension, the preprocessor is not run on the
2764	+	# input file.  (Note that this only needs to work for GNU compilers.)
2765	+	ac_save_ext=$ac_ext
2766	+	ac_ext=F
2767	+	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768	+	echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769	+	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2771	+	else
2772	+	cat >conftest.$ac_ext <<_ACEOF
2773	+	program main
2774	+	#ifndef __GNUC__
2775	+	choke me
2776	+	#endif
2777	+
2778	+	end
2779	+	_ACEOF
2780	+	rm -f conftest.$ac_objext
2781	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2782	+	(eval $ac_compile) 2>conftest.er1
2783	+	ac_status=$?
2784	+	grep -v '^ *+' conftest.er1 >conftest.err
2785	+	rm -f conftest.er1
2786	+	cat conftest.err >&5
2787	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788	+	(exit $ac_status); } &&
2789	+	{ ac_try='test -z "$ac_fc_werror_flag"
2790	+	|| test ! -s conftest.err'
2791	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792	+	(eval $ac_try) 2>&5
2793	+	ac_status=$?
2794	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2795	+	(exit $ac_status); }; } &&
2796	+	{ ac_try='test -s conftest.$ac_objext'
2797	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2798	+	(eval $ac_try) 2>&5
2799	+	ac_status=$?
2800	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2801	+	(exit $ac_status); }; }; then
2802	+	ac_compiler_gnu=yes
2803	+	else
2804	+	echo "$as_me: failed program was:" >&5
2805	+	sed 's/^/| /' conftest.$ac_ext >&5
2806	+
2807	+	ac_compiler_gnu=no
2808	+	fi
2809	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810	+	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811	+
2812	+	fi
2813	+	echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814	+	echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815	+	ac_ext=$ac_save_ext
2816	+	ac_test_FFLAGS=${FCFLAGS+set}
2817	+	ac_save_FFLAGS=$FCFLAGS
2818	+	FCFLAGS=
2819	+	echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820	+	echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821	+	if test "${ac_cv_prog_fc_g+set}" = set; then
2822	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2823	+	else
2824	+	FCFLAGS=-g
2825	+	cat >conftest.$ac_ext <<_ACEOF
2826	+	program main
2827	+
2828	+	end
2829	+	_ACEOF
2830	+	rm -f conftest.$ac_objext
2831	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2832	+	(eval $ac_compile) 2>conftest.er1
2833	+	ac_status=$?
2834	+	grep -v '^ *+' conftest.er1 >conftest.err
2835	+	rm -f conftest.er1
2836	+	cat conftest.err >&5
2837	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838	+	(exit $ac_status); } &&
2839	+	{ ac_try='test -z "$ac_fc_werror_flag"
2840	+	|| test ! -s conftest.err'
2841	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842	+	(eval $ac_try) 2>&5
2843	+	ac_status=$?
2844	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2845	+	(exit $ac_status); }; } &&
2846	+	{ ac_try='test -s conftest.$ac_objext'
2847	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2848	+	(eval $ac_try) 2>&5
2849	+	ac_status=$?
2850	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851	+	(exit $ac_status); }; }; then
2852	+	ac_cv_prog_fc_g=yes
2853	+	else
2854	+	echo "$as_me: failed program was:" >&5
2855	+	sed 's/^/| /' conftest.$ac_ext >&5
2856	+
2857	+	ac_cv_prog_fc_g=no
2858	+	fi
2859	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860	+
2861	+	fi
2862	+	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863	+	echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864	+	if test "$ac_test_FFLAGS" = set; then
2865	+	FCFLAGS=$ac_save_FFLAGS
2866	+	elif test $ac_cv_prog_fc_g = yes; then
2867	+	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868	+	FCFLAGS="-g -O2"
2869	+	else
2870	+	FCFLAGS="-g"
2871	+	fi
2872	+	else
2873	+	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874	+	FCFLAGS="-O2"
2875	+	else
2876	+	FCFLAGS=
2877	+	fi
2878	+	fi
2879	+
2880		ac_ext=c
2881		ac_cpp='$CPP $CPPFLAGS'
2882		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885	+
2886	+	ac_ext=c
2887	+	ac_cpp='$CPP $CPPFLAGS'
2888	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891		echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892		echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893		# On Suns, sometimes $CPP names a directory.
#	Line 3281 | Line 3117 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3117		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119
3284	–
3120		echo "$as_me:$LINENO: checking for egrep" >&5
3121		echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122		if test "${ac_cv_prog_egrep+set}" = set; then
#	Line 3297 | Line 3132 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132		EGREP=$ac_cv_prog_egrep
3133
3134
3135	<
3136	<	OOPSE_TEMPLATE_FLAGS=""
3137	<	if test $ac_cv_cxx_compiler_gnu = no; then
3138	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3139	<	echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3305	<	echo 'void f(){}' > conftest.cc
3306	<	if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3307	<	echo "$as_me:$LINENO: result: yes" >&5
3135	>	echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136	>	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137	>	LN_S=$as_ln_s
3138	>	if test "$LN_S" = "ln -s"; then
3139	>	echo "$as_me:$LINENO: result: yes" >&5
3140		echo "${ECHO_T}yes" >&6
3141	<	OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3142	<	else
3143	<	echo "$as_me:$LINENO: result: no" >&5
3144	<	echo "${ECHO_T}no" >&6
3145	<	fi
3146	<	rm -f conftest*
3147	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3148	<	echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3149	<	echo 'void f(){}' > conftest.cc
3150	<	if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3151	<	echo "$as_me:$LINENO: result: yes" >&5
3141	>	else
3142	>	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143	>	echo "${ECHO_T}no, using $LN_S" >&6
3144	>	fi
3145	>
3146	>	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147	>	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148	>	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149	>	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3151	>	else
3152	>	cat >conftest.make <<\_ACEOF
3153	>	all:
3154	>	@echo 'ac_maketemp="$(MAKE)"'
3155	>	_ACEOF
3156	>	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157	>	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158	>	if test -n "$ac_maketemp"; then
3159	>	eval ac_cv_prog_make_${ac_make}_set=yes
3160	>	else
3161	>	eval ac_cv_prog_make_${ac_make}_set=no
3162	>	fi
3163	>	rm -f conftest.make
3164	>	fi
3165	>	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166	>	echo "$as_me:$LINENO: result: yes" >&5
3167		echo "${ECHO_T}yes" >&6
3168	<	OOPSE_TEMPLATE_FLAGS="-instances=static"
3169	<	else
3170	<	echo "$as_me:$LINENO: result: no" >&5
3168	>	SET_MAKE=
3169	>	else
3170	>	echo "$as_me:$LINENO: result: no" >&5
3171	>	echo "${ECHO_T}no" >&6
3172	>	SET_MAKE="MAKE=${MAKE-make}"
3173	>	fi
3174	>
3175	>	if test -n "$ac_tool_prefix"; then
3176	>	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3177	>	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3178	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3179	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180	>	if test "${ac_cv_prog_RANLIB+set}" = set; then
3181	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3182	>	else
3183	>	if test -n "$RANLIB"; then
3184	>	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3185	>	else
3186	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187	>	for as_dir in $PATH
3188	>	do
3189	>	IFS=$as_save_IFS
3190	>	test -z "$as_dir" && as_dir=.
3191	>	for ac_exec_ext in '' $ac_executable_extensions; do
3192	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193	>	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3194	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195	>	break 2
3196	>	fi
3197	>	done
3198	>	done
3199	>
3200	>	fi
3201	>	fi
3202	>	RANLIB=$ac_cv_prog_RANLIB
3203	>	if test -n "$RANLIB"; then
3204	>	echo "$as_me:$LINENO: result: $RANLIB" >&5
3205	>	echo "${ECHO_T}$RANLIB" >&6
3206	>	else
3207	>	echo "$as_me:$LINENO: result: no" >&5
3208		echo "${ECHO_T}no" >&6
3209	+	fi
3210	+
3211	+	fi
3212	+	if test -z "$ac_cv_prog_RANLIB"; then
3213	+	ac_ct_RANLIB=$RANLIB
3214	+	# Extract the first word of "ranlib", so it can be a program name with args.
3215	+	set dummy ranlib; ac_word=$2
3216	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3217	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218	+	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3219	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3220	+	else
3221	+	if test -n "$ac_ct_RANLIB"; then
3222	+	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223	+	else
3224	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225	+	for as_dir in $PATH
3226	+	do
3227	+	IFS=$as_save_IFS
3228	+	test -z "$as_dir" && as_dir=.
3229	+	for ac_exec_ext in '' $ac_executable_extensions; do
3230	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231	+	ac_cv_prog_ac_ct_RANLIB="ranlib"
3232	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233	+	break 2
3234		fi
3235	<	rm -f conftest*
3236	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3237	<	echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3238	<	echo 'void f(){}' > conftest.cc
3239	<	if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3240	<	echo "$as_me:$LINENO: result: yes" >&5
3241	<	echo "${ECHO_T}yes" >&6
3242	<	OOPSE_TEMPLATE_FLAGS="-pto"
3243	<	else
3244	<	echo "$as_me:$LINENO: result: no" >&5
3235	>	done
3236	>	done
3237	>
3238	>	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3239	>	fi
3240	>	fi
3241	>	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3242	>	if test -n "$ac_ct_RANLIB"; then
3243	>	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3244	>	echo "${ECHO_T}$ac_ct_RANLIB" >&6
3245	>	else
3246	>	echo "$as_me:$LINENO: result: no" >&5
3247		echo "${ECHO_T}no" >&6
3248	+	fi
3249	+
3250	+	RANLIB=$ac_ct_RANLIB
3251	+	else
3252	+	RANLIB="$ac_cv_prog_RANLIB"
3253	+	fi
3254	+
3255	+
3256	+	# Extract the first word of "perl", so it can be a program name with args.
3257	+	set dummy perl; ac_word=$2
3258	+	echo "$as_me:$LINENO: checking for $ac_word" >&5
3259	+	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3260	+	if test "${ac_cv_path_PERLINTERP+set}" = set; then
3261	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3262	+	else
3263	+	case $PERLINTERP in
3264	+	[\\/]* | ?:[\\/]*)
3265	+	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3266	+	;;
3267	+	*)
3268	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3269	+	for as_dir in $PATH
3270	+	do
3271	+	IFS=$as_save_IFS
3272	+	test -z "$as_dir" && as_dir=.
3273	+	for ac_exec_ext in '' $ac_executable_extensions; do
3274	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3275	+	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3276	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3277	+	break 2
3278		fi
3279	<	rm -f conftest*
3280	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3340	<	echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3341	<	echo 'void f(){}' > conftest.cc
3342	<	if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3343	<	echo "$as_me:$LINENO: result: yes" >&5
3344	<	echo "${ECHO_T}yes" >&6
3279	>	done
3280	>	done
3281
3282	+	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283	+	;;
3284	+	esac
3285	+	fi
3286	+	PERLINTERP=$ac_cv_path_PERLINTERP
3287
3288	<	EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3289	<	else
3290	<	echo "$as_me:$LINENO: result: no" >&5
3288	>	if test -n "$PERLINTERP"; then
3289	>	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290	>	echo "${ECHO_T}$PERLINTERP" >&6
3291	>	else
3292	>	echo "$as_me:$LINENO: result: no" >&5
3293		echo "${ECHO_T}no" >&6
3294	+	fi
3295	+
3296	+	ac_cv_path_perlinterp="$PERLINTERP"
3297	+	_sHpB='#!'
3298	+
3299	+
3300	+	# Check whether --with-perl-shebang or --without-perl-shebang was given.
3301	+	if test "${with_perl_shebang+set}" = set; then
3302	+	withval="$with_perl_shebang"
3303	+	opt_perl_shebang="$withval"
3304	+	else
3305	+	opt_perl_shebang="not_set"
3306	+	fi;
3307	+	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308	+	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309	+	if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3311	+	else
3312	+	case "$opt_perl_shebang" in
3313	+	not_set  ) ax_cv_opt_perl_shebang=''
3314	+	;;
3315	+	*     )
3316	+	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317	+	esac
3318	+
3319	+	fi
3320	+	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321	+	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322	+	if test "A$ax_cv_opt_perl_shebang" != "A"
3323	+	then
3324	+	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325	+	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326	+	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327	+	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328	+
3329	+	# Automatic detection of sharpbang formula starts here
3330	+	else
3331	+	_somian_shbangperl=`$PERLINTERP -V:startperl`
3332	+	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333	+	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334	+	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335	+	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3337	+	else
3338	+	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339	+	if test "x$_somian_kspb_perl" == x
3340	+	then _somian_ksbp_warn_empty='durnit'
3341	+	else
3342	+	case "A$_somian_kspb_perl" in
3343	+	A#!*perl* )
3344	+	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345	+	;;
3346	+	A*    )  _somian_ksbp_warn_defau='trouble'
3347	+	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348	+	esac
3349	+	fi
3350	+
3351	+	fi
3352	+	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353	+	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354	+	# The above prints Checking ... result message to user.
3355	+	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356	+
3357	+	if test A${_somian_ksbp_warn_empty+set} == Aset
3358	+	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359	+	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360	+	fi
3361	+	# Inform user after printing result value
3362	+	if test A${_somian_ksbp_warn_defau+set} == Aset
3363	+	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364	+	echo "$as_me: Maybe Not good -" >&6;}
3365	+	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366	+	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367	+	else { echo "$as_me:$LINENO: OK Good result - " >&5
3368	+	echo "$as_me: OK Good result - " >&6;}
3369	+	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370	+	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371	+	fi
3372		fi
3373	+
3374	+	# Find a good install program.  We prefer a C program (faster),
3375	+	# so one script is as good as another.  But avoid the broken or
3376	+	# incompatible versions:
3377	+	# SysV /etc/install, /usr/sbin/install
3378	+	# SunOS /usr/etc/install
3379	+	# IRIX /sbin/install
3380	+	# AIX /bin/install
3381	+	# AmigaOS /C/install, which installs bootblocks on floppy discs
3382	+	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383	+	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384	+	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385	+	# OS/2's system install, which has a completely different semantic
3386	+	# ./install, which can be erroneously created by make from ./install.sh.
3387	+	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388	+	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389	+	if test -z "$INSTALL"; then
3390	+	if test "${ac_cv_path_install+set}" = set; then
3391	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3392	+	else
3393	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394	+	for as_dir in $PATH
3395	+	do
3396	+	IFS=$as_save_IFS
3397	+	test -z "$as_dir" && as_dir=.
3398	+	# Account for people who put trailing slashes in PATH elements.
3399	+	case $as_dir/ in
3400	+	./ | .// | /cC/* | \
3401	+	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402	+	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403	+	/usr/ucb/* ) ;;
3404	+	*)
3405	+	# OSF1 and SCO ODT 3.0 have their own names for install.
3406	+	# Don't use installbsd from OSF since it installs stuff as root
3407	+	# by default.
3408	+	for ac_prog in ginstall scoinst install; do
3409	+	for ac_exec_ext in '' $ac_executable_extensions; do
3410	+	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411	+	if test $ac_prog = install &&
3412	+	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413	+	# AIX install.  It has an incompatible calling convention.
3414	+	:
3415	+	elif test $ac_prog = install &&
3416	+	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417	+	# program-specific install script used by HP pwplus--don't use.
3418	+	:
3419	+	else
3420	+	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421	+	break 3
3422	+	fi
3423	+	fi
3424	+	done
3425	+	done
3426	+	;;
3427	+	esac
3428	+	done
3429	+
3430	+
3431		fi
3432	+	if test "${ac_cv_path_install+set}" = set; then
3433	+	INSTALL=$ac_cv_path_install
3434	+	else
3435	+	# As a last resort, use the slow shell script.  We don't cache a
3436	+	# path for INSTALL within a source directory, because that will
3437	+	# break other packages using the cache if that directory is
3438	+	# removed, or if the path is relative.
3439	+	INSTALL=$ac_install_sh
3440	+	fi
3441	+	fi
3442	+	echo "$as_me:$LINENO: result: $INSTALL" >&5
3443	+	echo "${ECHO_T}$INSTALL" >&6
3444
3445	+	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446	+	# It thinks the first close brace ends the variable substitution.
3447	+	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448
3449	+	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450
3451	+	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452
3453	<	ac_ext=f90
3454	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3455	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3456	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3457	<	if test -n "$ac_tool_prefix"; then
3458	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3459	<	do
3364	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3365	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3453	>	case "x$INSTALL" in
3454	>	x/*) ;;
3455	>	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456	>	esac
3457	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458	>	# Extract the first word of "ar", so it can be a program name with args.
3459	>	set dummy ar; ac_word=$2
3460		echo "$as_me:$LINENO: checking for $ac_word" >&5
3461		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462	<	if test "${ac_cv_prog_F90+set}" = set; then
3462	>	if test "${ac_cv_prog_AR+set}" = set; then
3463		echo $ECHO_N "(cached) $ECHO_C" >&6
3464		else
3465	<	if test -n "$F90"; then
3466	<	ac_cv_prog_F90="$F90" # Let the user override the test.
3465	>	if test -n "$AR"; then
3466	>	ac_cv_prog_AR="$AR" # Let the user override the test.
3467		else
3468		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469		for as_dir in $PATH
#	Line 3378 | Line 3472 | do
3472		test -z "$as_dir" && as_dir=.
3473		for ac_exec_ext in '' $ac_executable_extensions; do
3474		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475	<	ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3475	>	ac_cv_prog_AR="ar"
3476		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477		break 2
3478		fi
3479		done
3480		done
3481
3482	+	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483		fi
3484		fi
3485	<	F90=$ac_cv_prog_F90
3486	<	if test -n "$F90"; then
3487	<	echo "$as_me:$LINENO: result: $F90" >&5
3488	<	echo "${ECHO_T}$F90" >&6
3485	>	AR=$ac_cv_prog_AR
3486	>	if test -n "$AR"; then
3487	>	echo "$as_me:$LINENO: result: $AR" >&5
3488	>	echo "${ECHO_T}$AR" >&6
3489		else
3490		echo "$as_me:$LINENO: result: no" >&5
3491		echo "${ECHO_T}no" >&6
3492		fi
3493
3494	<	test -n "$F90" && break
3495	<	done
3494	>	if test "$AR" = "NONE"; then
3495	>	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496	>	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497	>	{ (exit 1); exit 1; }; }
3498	>	cat >confcache <<\_ACEOF
3499	>	# This file is a shell script that caches the results of configure
3500	>	# tests run on this system so they can be shared between configure
3501	>	# scripts and configure runs, see configure's option --config-cache.
3502	>	# It is not useful on other systems.  If it contains results you don't
3503	>	# want to keep, you may remove or edit it.
3504	>	#
3505	>	# config.status only pays attention to the cache file if you give it
3506	>	# the --recheck option to rerun configure.
3507	>	#
3508	>	# `ac_cv_env_foo' variables (set or unset) will be overridden when
3509	>	# loading this file, other *unset* `ac_cv_foo' will be assigned the
3510	>	# following values.
3511	>
3512	>	_ACEOF
3513	>
3514	>	# The following way of writing the cache mishandles newlines in values,
3515	>	# but we know of no workaround that is simple, portable, and efficient.
3516	>	# So, don't put newlines in cache variables' values.
3517	>	# Ultrix sh set writes to stderr and can't be redirected directly,
3518	>	# and sets the high bit in the cache file unless we assign to the vars.
3519	>	{
3520	>	(set) 2>&1 |
3521	>	case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522	>	*ac_space=\ *)
3523	>	# `set' does not quote correctly, so add quotes (double-quote
3524	>	# substitution turns \\\\ into \\, and sed turns \\ into \).
3525	>	sed -n \
3526	>	"s/'/'\\\\''/g;
3527	>	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528	>	;;
3529	>	*)
3530	>	# `set' quotes correctly as required by POSIX, so do not add quotes.
3531	>	sed -n \
3532	>	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533	>	;;
3534	>	esac;
3535	>	} |
3536	>	sed '
3537	>	t clear
3538	>	: clear
3539	>	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540	>	t end
3541	>	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542	>	: end' >>confcache
3543	>	if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544	>	if test -w $cache_file; then
3545	>	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546	>	cat confcache >$cache_file
3547	>	else
3548	>	echo "not updating unwritable cache $cache_file"
3549	>	fi
3550		fi
3551	<	if test -z "$F90"; then
3552	<	ac_ct_F90=$F90
3553	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3554	<	do
3555	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3407	<	set dummy $ac_prog; ac_word=$2
3551	>	rm -f confcache
3552	>	exit 1
3553	>	fi
3554	>	# Extract the first word of "ps", so it can be a program name with args.
3555	>	set dummy ps; ac_word=$2
3556		echo "$as_me:$LINENO: checking for $ac_word" >&5
3557		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558	<	if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3558	>	if test "${ac_cv_path_PS+set}" = set; then
3559		echo $ECHO_N "(cached) $ECHO_C" >&6
3560		else
3561	<	if test -n "$ac_ct_F90"; then
3562	<	ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3563	<	else
3564	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3561	>	case $PS in
3562	>	[\\/]* | ?:[\\/]*)
3563	>	ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564	>	;;
3565	>	*)
3566	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567		for as_dir in $PATH
3568		do
3569		IFS=$as_save_IFS
3570		test -z "$as_dir" && as_dir=.
3571		for ac_exec_ext in '' $ac_executable_extensions; do
3572		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573	<	ac_cv_prog_ac_ct_F90="$ac_prog"
3573	>	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575		break 2
3576		fi
3577		done
3578		done
3579
3580	+	;;
3581	+	esac
3582		fi
3583	<	fi
3584	<	ac_ct_F90=$ac_cv_prog_ac_ct_F90
3585	<	if test -n "$ac_ct_F90"; then
3586	<	echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3587	<	echo "${ECHO_T}$ac_ct_F90" >&6
3583	>	PS=$ac_cv_path_PS
3584	>
3585	>	if test -n "$PS"; then
3586	>	echo "$as_me:$LINENO: result: $PS" >&5
3587	>	echo "${ECHO_T}$PS" >&6
3588		else
3589		echo "$as_me:$LINENO: result: no" >&5
3590		echo "${ECHO_T}no" >&6
3591		fi
3592
3593	<	test -n "$ac_ct_F90" && break
3594	<	done
3593	>	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594	>	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595	>	if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3597	>	else
3598
3599	<	F90=$ac_ct_F90
3599	>	if $PS ax -o rss > /dev/null 2>&1; then
3600	>	ac_cv_prog_ps_ax=yes
3601	>	else
3602	>	ac_cv_prog_ps_ax=no
3603	>	fi
3604	>	if $PS -ef -o rss > /dev/null 2>&1; then
3605	>	ac_cv_prog_ps_ef=yes
3606	>	else
3607	>	ac_cv_prog_ps_ef=no
3608	>	fi
3609	>	if test "$ac_cv_prog_ps_ax" = yes; then
3610	>	ac_cv_prog_ps_syntax=BSD
3611	>	else
3612	>	if test "$ac_cv_prog_ps_ef" = yes; then
3613	>	ac_cv_prog_ps_syntax=POSIX
3614	>	else
3615	>	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616	>	echo "$as_me: error: Could not determine ps syntax" >&2;}
3617	>	{ (exit 1); exit 1; }; }
3618	>	fi
3619	>	fi
3620	>
3621		fi
3622	+	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623	+	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624
3625	+	cat >>confdefs.h <<_ACEOF
3626	+	#define PSCOMMAND $PS
3627	+	_ACEOF
3628
3629	<	# If we don't use `.F90' as extension, the preprocessor is not run on the
3630	<	# input file.
3631	<	ac_save_ext=$ac_ext
3632	<	ac_ext=F90
3633	<	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3634	<	echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3454	<	if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3455	<	echo $ECHO_N "(cached) $ECHO_C" >&6
3629	>	if test "$ac_cv_prog_ps_syntax" = BSD; then
3630	>
3631	>	cat >>confdefs.h <<\_ACEOF
3632	>	#define PSTYPE_IS_BSD 1
3633	>	_ACEOF
3634	>
3635		else
3636	<	cat >conftest.$ac_ext <<_ACEOF
3636	>	if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637
3638	<	program main
3638	>	cat >>confdefs.h <<\_ACEOF
3639	>	#define PSTYPE_IS_POSIX 1
3640	>	_ACEOF
3641
3642	<	#ifndef __GNUC__
3643	<	choke me
3644	<	#endif
3642	>	else
3643	>	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644	>	echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645	>	{ (exit 1); exit 1; }; }
3646	>	fi
3647	>	fi
3648
3649	<	end program main
3649	>	ac_ext=${FC_SRCEXT-f}
3650	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653
3654	+
3655	+	echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656	+	echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657	+	if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3659	+	else
3660	+	ac_ext=F90
3661	+	ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662	+	FCFLAGS_SRCEXT=""
3663	+	ac_cv_fc_srcext_F90=unknown
3664	+	for ac_flag in none -qsuffix=f=F90 -Tf; do
3665	+	test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666	+	cat >conftest.$ac_ext <<_ACEOF
3667	+	program main
3668	+
3669	+	end
3670		_ACEOF
3671		rm -f conftest.$ac_objext
3672		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3474 | Line 3677 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677		cat conftest.err >&5
3678		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679		(exit $ac_status); } &&
3680	<	{ ac_try='test -z "$ac_f90_werror_flag"
3680	>	{ ac_try='test -z "$ac_fc_werror_flag"
3681		|| test ! -s conftest.err'
3682		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683		(eval $ac_try) 2>&5
#	Line 3487 | Line 3690 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3690		ac_status=$?
3691		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692		(exit $ac_status); }; }; then
3693	<	ac_compiler_gnu=yes
3693	>	ac_cv_fc_srcext_F90=$ac_flag; break
3694		else
3695		echo "$as_me: failed program was:" >&5
3696		sed 's/^/| /' conftest.$ac_ext >&5
3697
3495	–	ac_compiler_gnu=no
3698		fi
3699		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700	<	ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3700	>	done
3701	>	rm -f conftest.$ac_objext conftest.F90
3702	>	FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703
3704		fi
3705	<	echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3706	<	echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3707	<	ac_ext=$ac_save_ext
3708	<	G95=`test $ac_compiler_gnu = yes && echo yes`
3709	<	ac_ext=c
3710	<	ac_cpp='$CPP $CPPFLAGS'
3711	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3712	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3713	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3705	>	echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706	>	echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707	>	if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708	>	{ { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709	>	echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710	>	{ (exit 1); exit 1; }; }
3711	>	else
3712	>	FC_SRCEXT=F90
3713	>	if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714	>	FCFLAGS_SRCEXT=""
3715	>	FCFLAGS_F90=""
3716	>	else
3717	>	FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718	>	FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719	>	fi
3720
3721
3722	+	fi
3723
3724
3725
3726	+
3727	+
3728		# Try to determine native compiler flags that allow us to use F90 suffix
3729		# for preprocessed f90 source.
3730
#	Line 3519 | Line 3732 | if test "$ac_test_PREPFLAG" != "set"; then
3732		PREPFLAG=""
3733		case "${host_cpu}-${host_os}" in
3734
3735	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3735	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736		PREPFLAG="-fpp1 "
3737		fi;;
3738	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3738	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739		PREPFLAG="-qsuffix=cpp=F90 "
3740		fi;;
3741		*darwin*)
3742	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3742	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743		PREPFLAG="-qsuffix=cpp=F90 "
3744		fi;;
3745		esac
#	Line 3541 | Line 3754 | echo $ECHO_N "checking to make sure F90 preprocessor f
3754		echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755
3756
3757	<	ac_ext=f90
3758	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3759	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3760	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3757	>	ac_ext=${FC_SRCEXT-f}
3758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761
3762		ac_save_ext=$ac_ext
3763		ac_ext=F90
3764	<	ac_save_F90FLAGS=$F90FLAGS
3764	>	ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765
3766		if test "$PREPFLAG"; then
3767	<	F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3767	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3768		fi
3769
3770		cat >conftest.$ac_ext <<_ACEOF
3771
3772
3773	<	program main
3561	<
3773	>	program conftest
3774		integer :: i
3775		i = 1
3776	+	end program conftest
3777
3565	–
3566	–	end program main
3567	–
3778		_ACEOF
3779		rm -f conftest.$ac_objext
3780		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3575 | Line 3785 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785		cat conftest.err >&5
3786		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787		(exit $ac_status); } &&
3788	<	{ ac_try='test -z "$ac_f90_werror_flag"
3788	>	{ ac_try='test -z "$ac_fc_werror_flag"
3789		|| test ! -s conftest.err'
3790		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791		(eval $ac_try) 2>&5
#	Line 3597 | Line 3807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3807		fi
3808		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809
3810	<	F90FLAGS=$ac_save_F90FLAGS
3810	>	FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811		ac_ext=$ac_save_ext
3812	<	ac_ext=c
3813	<	ac_cpp='$CPP $CPPFLAGS'
3814	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3815	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3606	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3812	>	ac_ext=${FC_SRCEXT-f}
3813	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816
3817
3818		if test "$prepflagworks" = 1; then
3819		echo "$as_me:$LINENO: result: yes" >&5
3820		echo "${ECHO_T}yes" >&6
3821	+	FCFLAGS_SRCEXT="${PREPFLAG}"
3822
3823		else
3824		echo "$as_me:$LINENO: result: no" >&5
#	Line 3630 | Line 3840 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3840		PREPDEFFLAG=""
3841		case "${host_cpu}-${host_os}" in
3842
3843	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3843	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844		PREPDEFFLAG=" "
3845		fi;;
3846	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3846	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847		PREPDEFFLAG="-WF,"
3848		fi;;
3849		*darwin*)
3850	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3850	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851		PREPDEFFLAG="-WF,"
3852		fi;;
3853		esac
#	Line 3652 | Line 3862 | echo $ECHO_N "checking to make sure F90 preprocessor d
3862		echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863
3864
3865	<	ac_ext=f90
3866	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3865	>	ac_ext=${FC_SRCEXT-f}
3866	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869
3870		ac_save_ext=$ac_ext
3871		ac_ext=F90
3872	<	ac_save_F90FLAGS=$F90FLAGS
3872	>	ac_save_FCFLAGS=$FCFLAGS
3873
3874		if test "$PREPDEFFLAG"; then
3875	<	F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3875	>	FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876		fi
3877
3878		cat >conftest.$ac_ext <<_ACEOF
3879
3880
3881	<	program main
3672	<
3881	>	program conftest
3882		integer :: i
3883		#ifdef TEST
3884		i = 1
3885		#else
3886		choke me
3887		#endif
3888	+	end program conftest
3889
3680	–
3681	–	end program main
3682	–
3890		_ACEOF
3891		rm -f conftest.$ac_objext
3892		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3690 | Line 3897 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3897		cat conftest.err >&5
3898		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899		(exit $ac_status); } &&
3900	<	{ ac_try='test -z "$ac_f90_werror_flag"
3900	>	{ ac_try='test -z "$ac_fc_werror_flag"
3901		|| test ! -s conftest.err'
3902		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903		(eval $ac_try) 2>&5
#	Line 3712 | Line 3919 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3919		fi
3920		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921
3922	<	F90FLAGS=$ac_save_F90FLAGS
3922	>	FCFLAGS=$ac_save_FCFLAGS
3923		ac_ext=$ac_save_ext
3924	<	ac_ext=c
3925	<	ac_cpp='$CPP $CPPFLAGS'
3926	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3927	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3721	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3924	>	ac_ext=${FC_SRCEXT-f}
3925	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928
3929
3724	–
3930		if test "$prepdefflagworks" = 1; then
3931		echo "$as_me:$LINENO: result: yes" >&5
3932		echo "${ECHO_T}yes" >&6
#	Line 3735 | Line 3940 | fi
3940		fi
3941		fi
3942
3943	<	ac_ext=f90
3944	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3945	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3946	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3947	<
3948	<
3949	<
3745	<	ac_ext=f90
3746	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3747	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3748	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3749	<	echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3750	<	echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3751	<	if test "${ac_cv_prog_f90_v+set}" = set; then
3943	>	ac_ext=${FC_SRCEXT-f}
3944	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949	>	if test "${ac_cv_prog_fc_v+set}" = set; then
3950		echo $ECHO_N "(cached) $ECHO_C" >&6
3951		else
3952	+	cat >conftest.$ac_ext <<_ACEOF
3953	+	program main
3954
3955	<	cat >conftest.$ac_ext <<_ACEOF
3756	<
3757	<	program main
3758	<
3759	<
3760	<	end program main
3761	<
3955	>	end
3956		_ACEOF
3957		rm -f conftest.$ac_objext
3958		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3769 | Line 3963 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3963		cat conftest.err >&5
3964		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965		(exit $ac_status); } &&
3966	<	{ ac_try='test -z "$ac_f90_werror_flag"
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
#	Line 3782 | Line 3976 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3976		ac_status=$?
3977		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978		(exit $ac_status); }; }; then
3979	<	ac_cv_prog_f90_v=
3979	>	ac_cv_prog_fc_v=
3980		# Try some options frequently used verbose output
3981		for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982	<	ac_ext=f90
3983	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3790	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3791	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3982	>	cat >conftest.$ac_ext <<_ACEOF
3983	>	program main
3984
3985	<	cat >conftest.$ac_ext <<_ACEOF
3794	<
3795	<	program main
3796	<
3797	<
3798	<	end program main
3799	<
3985	>	end
3986		_ACEOF
3987
3988		# Compile and link our simple test program by passing a flag (argument
3989	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3990	<	# "verbose" output that we can then parse for the Fortran 90 linker
3989	>	# 1 to this macro) to the Fortran compiler in order to get
3990	>	# "verbose" output that we can then parse for the Fortran linker
3991		# flags.
3992	<	ac_save_F90FLAGS=$F90FLAGS
3993	<	F90FLAGS="$F90FLAGS $ac_verb"
3992	>	ac_save_FFLAGS=$FCFLAGS
3993	>	FCFLAGS="$FCFLAGS $ac_verb"
3994	>	(eval echo $as_me:3994: \"$ac_link\") >&5
3995	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996	>	echo "$ac_fc_v_output" >&5
3997	>	FCFLAGS=$ac_save_FFLAGS
3998
3999	<	(eval echo $as_me:3809: \"$ac_link\") >&5
3810	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3811	<	echo "$ac_f90_v_output" >&5
3812	<	F90FLAGS=$ac_save_F90FLAGS
3999	>	rm -f conftest*
4000
4001	<	rm -f conftest.*
4002	<	ac_ext=f90
4003	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4004	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4005	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4001	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4003	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004	>	ac_fc_v_output="`echo $ac_fc_v_output |
4005	>	grep 'LPATH is:' |
4006	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007
4008	<	# If we are using xlf then replace all the commas with spaces.
4009	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4010	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4011	<	fi
4008	>	case $ac_fc_v_output in
4009	>	# If we are using xlf then replace all the commas with spaces.
4010	>	*xlfentry*)
4011	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012
4013	<	# If we are using Cray Fortran then delete quotes.
4014	<	# Use "\"" instead of '"' for font-lock-mode.
4015	<	# FIXME: a more general fix for quoted arguments with spaces?
4016	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4017	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4018	<	fi
4013	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4015	>	*mGLOB_options_string*)
4016	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017	>
4018	>	# If we are using Cray Fortran then delete quotes.
4019	>	# Use "\"" instead of '"' for font-lock-mode.
4020	>	# FIXME: a more general fix for quoted arguments with spaces?
4021	>	*cft90*)
4022	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023	>	esac
4024	>
4025	>
4026		# look for -l* and *.a constructs in the output
4027	<	for ac_arg in $ac_f90_v_output; do
4027	>	for ac_arg in $ac_fc_v_output; do
4028		case $ac_arg in
4029		[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030	<	ac_cv_prog_f90_v=$ac_verb
4030	>	ac_cv_prog_fc_v=$ac_verb
4031		break 2 ;;
4032		esac
4033		done
4034		done
4035	<	if test -z "$ac_cv_prog_f90_v"; then
4036	<	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4037	<	echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4035	>	if test -z "$ac_cv_prog_fc_v"; then
4036	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038		fi
4039		else
4040		echo "$as_me: failed program was:" >&5
#	Line 3851 | Line 4046 | fi
4046		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047
4048		fi
4049	<	echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4050	<	echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4051	<	echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4052	<	echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4053	<	if test "${ac_cv_flibs+set}" = set; then
4049	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053	>	if test "${ac_cv_fc_libs+set}" = set; then
4054		echo $ECHO_N "(cached) $ECHO_C" >&6
4055		else
4056	<	if test "x$F90LIBS" != "x"; then
4057	<	ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4056	>	if test "x$FCLIBS" != "x"; then
4057	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058		else
4059
3865	–	ac_ext=f90
3866	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3869	–
4060		cat >conftest.$ac_ext <<_ACEOF
4061	+	program main
4062
4063	<	program main
3873	<
3874	<
3875	<	end program main
3876	<
4063	>	end
4064		_ACEOF
4065
4066		# Compile and link our simple test program by passing a flag (argument
4067	<	# 1 to this macro) to the Fortran 90 compiler in order to get
4068	<	# "verbose" output that we can then parse for the Fortran 90 linker
4067	>	# 1 to this macro) to the Fortran compiler in order to get
4068	>	# "verbose" output that we can then parse for the Fortran linker
4069		# flags.
4070	<	ac_save_F90FLAGS=$F90FLAGS
4071	<	F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4070	>	ac_save_FFLAGS=$FCFLAGS
4071	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072	>	(eval echo $as_me:4072: \"$ac_link\") >&5
4073	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074	>	echo "$ac_fc_v_output" >&5
4075	>	FCFLAGS=$ac_save_FFLAGS
4076
4077	<	(eval echo $as_me:3886: \"$ac_link\") >&5
3887	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3888	<	echo "$ac_f90_v_output" >&5
3889	<	F90FLAGS=$ac_save_F90FLAGS
4077	>	rm -f conftest*
4078
4079	<	rm -f conftest.*
4080	<	ac_ext=f90
4081	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4082	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4083	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4079	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4081	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082	>	ac_fc_v_output="`echo $ac_fc_v_output |
4083	>	grep 'LPATH is:' |
4084	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085
4086	<	# If we are using xlf then replace all the commas with spaces.
4087	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4088	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4089	<	fi
4086	>	case $ac_fc_v_output in
4087	>	# If we are using xlf then replace all the commas with spaces.
4088	>	*xlfentry*)
4089	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090
4091	<	# If we are using Cray Fortran then delete quotes.
4092	<	# Use "\"" instead of '"' for font-lock-mode.
4093	<	# FIXME: a more general fix for quoted arguments with spaces?
4094	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3906	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3907	<	fi
4091	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4093	>	*mGLOB_options_string*)
4094	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095
4096	<	ac_cv_f90libs=
4096	>	# If we are using Cray Fortran then delete quotes.
4097	>	# Use "\"" instead of '"' for font-lock-mode.
4098	>	# FIXME: a more general fix for quoted arguments with spaces?
4099	>	*cft90*)
4100	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101	>	esac
4102
4103	+
4104	+
4105	+	ac_cv_fc_libs=
4106	+
4107		# Save positional arguments (if any)
4108		ac_save_positional="$@"
4109
4110	<	set X $ac_f90_v_output
4110	>	set X $ac_fc_v_output
4111		while test $# != 1; do
4112		shift
4113		ac_arg=$1
4114		case $ac_arg in
4115		[\\/]*.a | ?:[\\/]*.a)
4116		ac_exists=false
4117	<	for ac_i in $ac_cv_f90libs; do
4117	>	for ac_i in $ac_cv_fc_libs; do
4118		if test x"$ac_arg" = x"$ac_i"; then
4119		ac_exists=true
4120		break
#	Line 3928 | Line 4124 | else
4124		if test x"$ac_exists" = xtrue; then
4125		:
4126		else
4127	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128		fi
4129
4130		;;
4131		-bI:*)
4132		ac_exists=false
4133	<	for ac_i in $ac_cv_f90libs; do
4133	>	for ac_i in $ac_cv_fc_libs; do
4134		if test x"$ac_arg" = x"$ac_i"; then
4135		ac_exists=true
4136		break
#	Line 3946 | Line 4142 | else
4142		else
4143		if test "$ac_compiler_gnu" = yes; then
4144		for ac_link_opt in $ac_arg; do
4145	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146		done
4147		else
4148	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149		fi
4150		fi
4151
4152		;;
4153		# Ignore these flags.
4154	<	-lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155		;;
4156		-lkernel32)
4157	<	test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158		;;
4159		-[LRuY])
4160		# These flags, when seen by themselves, take an argument.
4161		# We remove the space between option and argument and re-iterate
4162		# unless we find an empty arg or a new option (starting with -)
4163		case $2 in
4164	<	"" | -*);;
4165	<	*)
4164	>	"" | -*);;
4165	>	*)
4166		ac_arg="$ac_arg$2"
3971	–
4167		shift; shift
4168		set X $ac_arg "$@"
4169		;;
#	Line 3977 | Line 4172 | fi
4172		-YP,*)
4173		for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174		ac_exists=false
4175	<	for ac_i in $ac_cv_f90libs; do
4175	>	for ac_i in $ac_cv_fc_libs; do
4176		if test x"$ac_j" = x"$ac_i"; then
4177		ac_exists=true
4178		break
#	Line 3988 | Line 4183 | else
4183		:
4184		else
4185		ac_arg="$ac_arg $ac_j"
4186	<	ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187		fi
4188
4189		done
4190		;;
4191		-[lLR]*)
4192		ac_exists=false
4193	<	for ac_i in $ac_cv_f90libs; do
4193	>	for ac_i in $ac_cv_fc_libs; do
4194		if test x"$ac_arg" = x"$ac_i"; then
4195		ac_exists=true
4196		break
#	Line 4005 | Line 4200 | else
4200		if test x"$ac_exists" = xtrue; then
4201		:
4202		else
4203	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204		fi
4205
4206		;;
#	Line 4020 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215		# must begin with a "/").
4216		case `(uname -sr) 2>/dev/null` in
4217		"SunOS 5"*)
4218	<	ac_ld_run_path=`echo $ac_f90_v_output |
4218	>	ac_ld_run_path=`echo $ac_fc_v_output |
4219		sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220		test "x$ac_ld_run_path" != x &&
4026	–
4221		if test "$ac_compiler_gnu" = yes; then
4222		for ac_link_opt in $ac_ld_run_path; do
4223	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224		done
4225		else
4226	<	ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227		fi
4228		;;
4229		esac
4230	<	fi # test "x$F90LIBS" = "x"
4230	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231
4232		fi
4233	<	echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234	<	echo "${ECHO_T}$ac_cv_flibs" >&6
4235	<	F90LIBS="$ac_cv_f90libs"
4233	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235	>	FCLIBS="$ac_cv_fc_libs"
4236
4043	–	ac_ext=f90
4044	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4045	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4046	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4237
4238	+	ac_ext=${FC_SRCEXT-f}
4239	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242
4243	<	echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244	<	echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245	<	if test "${ac_cv_f90_mangling+set}" = set; then
4243	>
4244	>	ac_ext=${FC_SRCEXT-f}
4245	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248	>
4249	>	echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250	>	echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251	>	if test "${ac_cv_fc_dummy_main+set}" = set; then
4252		echo $ECHO_N "(cached) $ECHO_C" >&6
4253		else
4254	<	ac_ext=f90
4255	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4256	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4258	<	cat >conftest.$ac_ext <<_ACEOF
4259	<	subroutine foobar()
4260	<	return
4261	<	end
4262	<	subroutine foo_bar()
4263	<	return
4264	<	end
4254	>	ac_fc_dm_save_LIBS=$LIBS
4255	>	LIBS="$LIBS $FCLIBS"
4256	>	ac_fortran_dm_var=FC_DUMMY_MAIN
4257	>	ac_ext=c
4258	>	ac_cpp='$CPP $CPPFLAGS'
4259	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262	>
4263	>	# First, try linking without a dummy main:
4264	>	cat >conftest.$ac_ext <<_ACEOF
4265	>	/* confdefs.h.  */
4266		_ACEOF
4267	+	cat confdefs.h >>conftest.$ac_ext
4268	+	cat >>conftest.$ac_ext <<_ACEOF
4269	+	/* end confdefs.h.  */
4270	+
4271	+	#ifdef FC_DUMMY_MAIN
4272	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4273	+	#  ifdef __cplusplus
4274	+	extern "C"
4275	+	#  endif
4276	+	int FC_DUMMY_MAIN() { return 1; }
4277	+	#endif
4278	+	#endif
4279	+	int
4280	+	main ()
4281	+	{
4282	+
4283	+	;
4284	+	return 0;
4285	+	}
4286	+	_ACEOF
4287	+	rm -f conftest.$ac_objext conftest$ac_exeext
4288	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4289	+	(eval $ac_link) 2>conftest.er1
4290	+	ac_status=$?
4291	+	grep -v '^ *+' conftest.er1 >conftest.err
4292	+	rm -f conftest.er1
4293	+	cat conftest.err >&5
4294	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4295	+	(exit $ac_status); } &&
4296	+	{ ac_try='test -z "$ac_c_werror_flag"
4297	+	|| test ! -s conftest.err'
4298	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4299	+	(eval $ac_try) 2>&5
4300	+	ac_status=$?
4301	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4302	+	(exit $ac_status); }; } &&
4303	+	{ ac_try='test -s conftest$ac_exeext'
4304	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4305	+	(eval $ac_try) 2>&5
4306	+	ac_status=$?
4307	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308	+	(exit $ac_status); }; }; then
4309	+	ac_cv_fortran_dummy_main=none
4310	+	else
4311	+	echo "$as_me: failed program was:" >&5
4312	+	sed 's/^/| /' conftest.$ac_ext >&5
4313	+
4314	+	ac_cv_fortran_dummy_main=unknown
4315	+	fi
4316	+	rm -f conftest.err conftest.$ac_objext \
4317	+	conftest$ac_exeext conftest.$ac_ext
4318	+
4319	+	if test $ac_cv_fortran_dummy_main = unknown; then
4320	+	for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321	+	cat >conftest.$ac_ext <<_ACEOF
4322	+	/* confdefs.h.  */
4323	+	_ACEOF
4324	+	cat confdefs.h >>conftest.$ac_ext
4325	+	cat >>conftest.$ac_ext <<_ACEOF
4326	+	/* end confdefs.h.  */
4327	+	#define $ac_fortran_dm_var $ac_func
4328	+	#ifdef FC_DUMMY_MAIN
4329	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4330	+	#  ifdef __cplusplus
4331	+	extern "C"
4332	+	#  endif
4333	+	int FC_DUMMY_MAIN() { return 1; }
4334	+	#endif
4335	+	#endif
4336	+	int
4337	+	main ()
4338	+	{
4339	+
4340	+	;
4341	+	return 0;
4342	+	}
4343	+	_ACEOF
4344	+	rm -f conftest.$ac_objext conftest$ac_exeext
4345	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4346	+	(eval $ac_link) 2>conftest.er1
4347	+	ac_status=$?
4348	+	grep -v '^ *+' conftest.er1 >conftest.err
4349	+	rm -f conftest.er1
4350	+	cat conftest.err >&5
4351	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4352	+	(exit $ac_status); } &&
4353	+	{ ac_try='test -z "$ac_c_werror_flag"
4354	+	|| test ! -s conftest.err'
4355	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4356	+	(eval $ac_try) 2>&5
4357	+	ac_status=$?
4358	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4359	+	(exit $ac_status); }; } &&
4360	+	{ ac_try='test -s conftest$ac_exeext'
4361	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4362	+	(eval $ac_try) 2>&5
4363	+	ac_status=$?
4364	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365	+	(exit $ac_status); }; }; then
4366	+	ac_cv_fortran_dummy_main=$ac_func; break
4367	+	else
4368	+	echo "$as_me: failed program was:" >&5
4369	+	sed 's/^/| /' conftest.$ac_ext >&5
4370	+
4371	+	fi
4372	+	rm -f conftest.err conftest.$ac_objext \
4373	+	conftest$ac_exeext conftest.$ac_ext
4374	+	done
4375	+	fi
4376	+	ac_ext=${FC_SRCEXT-f}
4377	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380	+	ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381	+	rm -f conftest*
4382	+	LIBS=$ac_fc_dm_save_LIBS
4383	+
4384	+	fi
4385	+	echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386	+	echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387	+	FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388	+	if test "$FC_DUMMY_MAIN" != unknown; then
4389	+	if test $FC_DUMMY_MAIN != none; then
4390	+
4391	+	cat >>confdefs.h <<_ACEOF
4392	+	#define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393	+	_ACEOF
4394	+
4395	+	if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396	+
4397	+	cat >>confdefs.h <<\_ACEOF
4398	+	#define FC_DUMMY_MAIN_EQ_F77 1
4399	+	_ACEOF
4400	+
4401	+	fi
4402	+	fi
4403	+	else
4404	+	{ { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405	+	See \`config.log' for more details." >&5
4406	+	echo "$as_me: error: linking to Fortran libraries from C fails
4407	+	See \`config.log' for more details." >&2;}
4408	+	{ (exit 1); exit 1; }; }
4409	+	fi
4410	+
4411	+
4412	+	ac_ext=${FC_SRCEXT-f}
4413	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416	+
4417	+	ac_ext=${FC_SRCEXT-f}
4418	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421	+	echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422	+	echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423	+	if test "${ac_cv_fc_mangling+set}" = set; then
4424	+	echo $ECHO_N "(cached) $ECHO_C" >&6
4425	+	else
4426	+	cat >conftest.$ac_ext <<_ACEOF
4427	+	subroutine foobar()
4428	+	return
4429	+	end
4430	+	subroutine foo_bar()
4431	+	return
4432	+	end
4433	+	_ACEOF
4434		rm -f conftest.$ac_objext
4435		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436		(eval $ac_compile) 2>conftest.er1
#	Line 4072 | Line 4440 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4440		cat conftest.err >&5
4441		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442		(exit $ac_status); } &&
4443	<	{ ac_try='test -z "$ac_f90_werror_flag"
4443	>	{ ac_try='test -z "$ac_fc_werror_flag"
4444		|| test ! -s conftest.err'
4445		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446		(eval $ac_try) 2>&5
#	Line 4085 | Line 4453 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4453		ac_status=$?
4454		echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455		(exit $ac_status); }; }; then
4456	<	mv conftest.$ac_objext cf90_test.$ac_objext
4456	>	mv conftest.$ac_objext cfortran_test.$ac_objext
4457
4458	+	ac_save_LIBS=$LIBS
4459	+	LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460	+
4461		ac_ext=c
4462		ac_cpp='$CPP $CPPFLAGS'
4463		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4095	–
4096	–	ac_save_LIBS=$LIBS
4097	–	LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4098	–
4466		ac_success=no
4467		for ac_foobar in foobar FOOBAR; do
4468		for ac_underscore in "" "_"; do
#	Line 4114 | Line 4481 | char $ac_func ();
4481		/* We use char because int might match the return type of a gcc2
4482		builtin and then its argument prototype would still apply.  */
4483		char $ac_func ();
4484	+	#ifdef FC_DUMMY_MAIN
4485	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4486	+	#  ifdef __cplusplus
4487	+	extern "C"
4488	+	#  endif
4489	+	int FC_DUMMY_MAIN() { return 1; }
4490	+	#endif
4491	+	#endif
4492		int
4493		main ()
4494		{
#	Line 4154 | Line 4529 | rm -f conftest.err conftest.$ac_objext \
4529		conftest$ac_exeext conftest.$ac_ext
4530		done
4531		done
4532	+	ac_ext=${FC_SRCEXT-f}
4533	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536
4537		if test "$ac_success" = "yes"; then
4538		case $ac_foobar in
4539	<	foobar)
4540	<	ac_case=lower
4541	<	ac_foo_bar=foo_bar
4542	<	;;
4543	<	FOOBAR)
4544	<	ac_case=upper
4545	<	ac_foo_bar=FOO_BAR
4546	<	;;
4539	>	foobar)
4540	>	ac_case=lower
4541	>	ac_foo_bar=foo_bar
4542	>	;;
4543	>	FOOBAR)
4544	>	ac_case=upper
4545	>	ac_foo_bar=FOO_BAR
4546	>	;;
4547		esac
4548
4549	+	ac_ext=c
4550	+	ac_cpp='$CPP $CPPFLAGS'
4551	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554		ac_success_extra=no
4555		for ac_extra in "" "_"; do
4556	<	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557	<
4174	<	cat >conftest.$ac_ext <<_ACEOF
4556	>	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557	>	cat >conftest.$ac_ext <<_ACEOF
4558		/* confdefs.h.  */
4559		_ACEOF
4560		cat confdefs.h >>conftest.$ac_ext
#	Line 4185 | Line 4568 | char $ac_func ();
4568		/* We use char because int might match the return type of a gcc2
4569		builtin and then its argument prototype would still apply.  */
4570		char $ac_func ();
4571	+	#ifdef FC_DUMMY_MAIN
4572	+	#ifndef FC_DUMMY_MAIN_EQ_F77
4573	+	#  ifdef __cplusplus
4574	+	extern "C"
4575	+	#  endif
4576	+	int FC_DUMMY_MAIN() { return 1; }
4577	+	#endif
4578	+	#endif
4579		int
4580		main ()
4581		{
#	Line 4224 | Line 4615 | rm -f conftest.err conftest.$ac_objext \
4615		rm -f conftest.err conftest.$ac_objext \
4616		conftest$ac_exeext conftest.$ac_ext
4617		done
4618	+	ac_ext=${FC_SRCEXT-f}
4619	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622
4623		if test "$ac_success_extra" = "yes"; then
4624	<	ac_cv_f90_mangling="$ac_case case"
4624	>	ac_cv_fc_mangling="$ac_case case"
4625		if test -z "$ac_underscore"; then
4626	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4626	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627		else
4628	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4234	<
4628	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629		fi
4630		if test -z "$ac_extra"; then
4631	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4631	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632		else
4633	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4633	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634		fi
4635		else
4636	<	ac_cv_f90_mangling="unknown"
4636	>	ac_cv_fc_mangling="unknown"
4637		fi
4638		else
4639	<	ac_cv_f90_mangling="unknown"
4246	<
4639	>	ac_cv_fc_mangling="unknown"
4640		fi
4641
4642		LIBS=$ac_save_LIBS
4643	<	ac_ext=f90
4251	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4252	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4253	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4254	<	rm -f cf90_test* conftest*
4643	>	rm -f cfortran_test* conftest*
4644		else
4645		echo "$as_me: failed program was:" >&5
4646		sed 's/^/| /' conftest.$ac_ext >&5
4647
4648	+	{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649	+	See \`config.log' for more details." >&5
4650	+	echo "$as_me: error: cannot compile a simple Fortran program
4651	+	See \`config.log' for more details." >&2;}
4652	+	{ (exit 1); exit 1; }; }
4653		fi
4654		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4261	–	ac_ext=f90
4262	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4263	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4264	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4655
4656		fi
4657	<	echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4658	<	echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4657	>	echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658	>	echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659
4660	+	ac_ext=${FC_SRCEXT-f}
4661	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664
4665	+	ac_ext=${FC_SRCEXT-f}
4666	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669
4670	<	case $ac_cv_f90_mangling in
4670	>
4671	>	case $ac_cv_fc_mangling in
4672		"lower case, no underscore, no extra underscore")
4673		cat >>confdefs.h <<\_ACEOF
4674	<	#define F90_FUNC(name,NAME) name
4674	>	#define FC_FUNC(name,NAME) name
4675		_ACEOF
4676
4677		cat >>confdefs.h <<\_ACEOF
4678	<	#define F90_FUNC_(name,NAME) name
4678	>	#define FC_FUNC_(name,NAME) name
4679		_ACEOF
4680		;;
4681		"lower case, no underscore, extra underscore")
4682		cat >>confdefs.h <<\_ACEOF
4683	<	#define F90_FUNC(name,NAME) name
4683	>	#define FC_FUNC(name,NAME) name
4684		_ACEOF
4685
4686		cat >>confdefs.h <<\_ACEOF
4687	<	#define F90_FUNC_(name,NAME) name ## _
4687	>	#define FC_FUNC_(name,NAME) name ## _
4688		_ACEOF
4689		;;
4690		"lower case, underscore, no extra underscore")
4691		cat >>confdefs.h <<\_ACEOF
4692	<	#define F90_FUNC(name,NAME) name ## _
4692	>	#define FC_FUNC(name,NAME) name ## _
4693		_ACEOF
4694
4695		cat >>confdefs.h <<\_ACEOF
4696	<	#define F90_FUNC_(name,NAME) name ## _
4696	>	#define FC_FUNC_(name,NAME) name ## _
4697		_ACEOF
4698		;;
4699		"lower case, underscore, extra underscore")
4700		cat >>confdefs.h <<\_ACEOF
4701	<	#define F90_FUNC(name,NAME) name ## _
4701	>	#define FC_FUNC(name,NAME) name ## _
4702		_ACEOF
4703
4704		cat >>confdefs.h <<\_ACEOF
4705	<	#define F90_FUNC_(name,NAME) name ## __
4705	>	#define FC_FUNC_(name,NAME) name ## __
4706		_ACEOF
4707		;;
4708		"upper case, no underscore, no extra underscore")
4709		cat >>confdefs.h <<\_ACEOF
4710	<	#define F90_FUNC(name,NAME) NAME
4710	>	#define FC_FUNC(name,NAME) NAME
4711		_ACEOF
4712
4713		cat >>confdefs.h <<\_ACEOF
4714	<	#define F90_FUNC_(name,NAME) NAME
4714	>	#define FC_FUNC_(name,NAME) NAME
4715		_ACEOF
4716		;;
4717		"upper case, no underscore, extra underscore")
4718		cat >>confdefs.h <<\_ACEOF
4719	<	#define F90_FUNC(name,NAME) NAME
4719	>	#define FC_FUNC(name,NAME) NAME
4720		_ACEOF
4721
4722		cat >>confdefs.h <<\_ACEOF
4723	<	#define F90_FUNC_(name,NAME) NAME ## _
4723	>	#define FC_FUNC_(name,NAME) NAME ## _
4724		_ACEOF
4725		;;
4726		"upper case, underscore, no extra underscore")
4727		cat >>confdefs.h <<\_ACEOF
4728	<	#define F90_FUNC(name,NAME) NAME ## _
4728	>	#define FC_FUNC(name,NAME) NAME ## _
4729		_ACEOF
4730
4731		cat >>confdefs.h <<\_ACEOF
4732	<	#define F90_FUNC_(name,NAME) NAME ## _
4732	>	#define FC_FUNC_(name,NAME) NAME ## _
4733		_ACEOF
4734		;;
4735		"upper case, underscore, extra underscore")
4736		cat >>confdefs.h <<\_ACEOF
4737	<	#define F90_FUNC(name,NAME) NAME ## _
4737	>	#define FC_FUNC(name,NAME) NAME ## _
4738		_ACEOF
4739
4740		cat >>confdefs.h <<\_ACEOF
4741	<	#define F90_FUNC_(name,NAME) NAME ## __
4741	>	#define FC_FUNC_(name,NAME) NAME ## __
4742		_ACEOF
4743		;;
4744		*)
4745	<	{ echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4746	<	echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4745	>	{ echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746	>	echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747	>	;;
4748	>	esac
4749	>
4750	>	ac_ext=${FC_SRCEXT-f}
4751	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754	>
4755	>
4756	>
4757	>	ac_ext=${FC_SRCEXT-f}
4758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763	>	if test "${ac_cv_prog_fc_v+set}" = set; then
4764	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4765	>	else
4766	>	cat >conftest.$ac_ext <<_ACEOF
4767	>	program main
4768	>
4769	>	end
4770	>	_ACEOF
4771	>	rm -f conftest.$ac_objext
4772	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773	>	(eval $ac_compile) 2>conftest.er1
4774	>	ac_status=$?
4775	>	grep -v '^ *+' conftest.er1 >conftest.err
4776	>	rm -f conftest.er1
4777	>	cat conftest.err >&5
4778	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779	>	(exit $ac_status); } &&
4780	>	{ ac_try='test -z "$ac_fc_werror_flag"
4781	>	|| test ! -s conftest.err'
4782	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783	>	(eval $ac_try) 2>&5
4784	>	ac_status=$?
4785	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786	>	(exit $ac_status); }; } &&
4787	>	{ ac_try='test -s conftest.$ac_objext'
4788	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789	>	(eval $ac_try) 2>&5
4790	>	ac_status=$?
4791	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792	>	(exit $ac_status); }; }; then
4793	>	ac_cv_prog_fc_v=
4794	>	# Try some options frequently used verbose output
4795	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796	>	cat >conftest.$ac_ext <<_ACEOF
4797	>	program main
4798	>
4799	>	end
4800	>	_ACEOF
4801	>
4802	>	# Compile and link our simple test program by passing a flag (argument
4803	>	# 1 to this macro) to the Fortran compiler in order to get
4804	>	# "verbose" output that we can then parse for the Fortran linker
4805	>	# flags.
4806	>	ac_save_FFLAGS=$FCFLAGS
4807	>	FCFLAGS="$FCFLAGS $ac_verb"
4808	>	(eval echo $as_me:4808: \"$ac_link\") >&5
4809	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810	>	echo "$ac_fc_v_output" >&5
4811	>	FCFLAGS=$ac_save_FFLAGS
4812	>
4813	>	rm -f conftest*
4814	>
4815	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4817	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818	>	ac_fc_v_output="`echo $ac_fc_v_output |
4819	>	grep 'LPATH is:' |
4820	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821	>
4822	>	case $ac_fc_v_output in
4823	>	# If we are using xlf then replace all the commas with spaces.
4824	>	*xlfentry*)
4825	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826	>
4827	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4829	>	*mGLOB_options_string*)
4830	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831	>
4832	>	# If we are using Cray Fortran then delete quotes.
4833	>	# Use "\"" instead of '"' for font-lock-mode.
4834	>	# FIXME: a more general fix for quoted arguments with spaces?
4835	>	*cft90*)
4836	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837	>	esac
4838	>
4839	>
4840	>	# look for -l* and *.a constructs in the output
4841	>	for ac_arg in $ac_fc_v_output; do
4842	>	case $ac_arg in
4843	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844	>	ac_cv_prog_fc_v=$ac_verb
4845	>	break 2 ;;
4846	>	esac
4847	>	done
4848	>	done
4849	>	if test -z "$ac_cv_prog_fc_v"; then
4850	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852	>	fi
4853	>	else
4854	>	echo "$as_me: failed program was:" >&5
4855	>	sed 's/^/| /' conftest.$ac_ext >&5
4856	>
4857	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858	>	echo "$as_me: WARNING: compilation failed" >&2;}
4859	>	fi
4860	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861	>
4862	>	fi
4863	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867	>	if test "${ac_cv_fc_libs+set}" = set; then
4868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4869	>	else
4870	>	if test "x$FCLIBS" != "x"; then
4871	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872	>	else
4873	>
4874	>	cat >conftest.$ac_ext <<_ACEOF
4875	>	program main
4876	>
4877	>	end
4878	>	_ACEOF
4879	>
4880	>	# Compile and link our simple test program by passing a flag (argument
4881	>	# 1 to this macro) to the Fortran compiler in order to get
4882	>	# "verbose" output that we can then parse for the Fortran linker
4883	>	# flags.
4884	>	ac_save_FFLAGS=$FCFLAGS
4885	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886	>	(eval echo $as_me:4886: \"$ac_link\") >&5
4887	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888	>	echo "$ac_fc_v_output" >&5
4889	>	FCFLAGS=$ac_save_FFLAGS
4890	>
4891	>	rm -f conftest*
4892	>
4893	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4895	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896	>	ac_fc_v_output="`echo $ac_fc_v_output |
4897	>	grep 'LPATH is:' |
4898	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899	>
4900	>	case $ac_fc_v_output in
4901	>	# If we are using xlf then replace all the commas with spaces.
4902	>	*xlfentry*)
4903	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904	>
4905	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4907	>	*mGLOB_options_string*)
4908	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909	>
4910	>	# If we are using Cray Fortran then delete quotes.
4911	>	# Use "\"" instead of '"' for font-lock-mode.
4912	>	# FIXME: a more general fix for quoted arguments with spaces?
4913	>	*cft90*)
4914	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915	>	esac
4916	>
4917	>
4918	>
4919	>	ac_cv_fc_libs=
4920	>
4921	>	# Save positional arguments (if any)
4922	>	ac_save_positional="$@"
4923	>
4924	>	set X $ac_fc_v_output
4925	>	while test $# != 1; do
4926	>	shift
4927	>	ac_arg=$1
4928	>	case $ac_arg in
4929	>	[\\/]*.a | ?:[\\/]*.a)
4930	>	ac_exists=false
4931	>	for ac_i in $ac_cv_fc_libs; do
4932	>	if test x"$ac_arg" = x"$ac_i"; then
4933	>	ac_exists=true
4934	>	break
4935	>	fi
4936	>	done
4937	>
4938	>	if test x"$ac_exists" = xtrue; then
4939	>	:
4940	>	else
4941	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942	>	fi
4943	>
4944		;;
4945	+	-bI:*)
4946	+	ac_exists=false
4947	+	for ac_i in $ac_cv_fc_libs; do
4948	+	if test x"$ac_arg" = x"$ac_i"; then
4949	+	ac_exists=true
4950	+	break
4951	+	fi
4952	+	done
4953	+
4954	+	if test x"$ac_exists" = xtrue; then
4955	+	:
4956	+	else
4957	+	if test "$ac_compiler_gnu" = yes; then
4958	+	for ac_link_opt in $ac_arg; do
4959	+	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960	+	done
4961	+	else
4962	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963	+	fi
4964	+	fi
4965	+
4966	+	;;
4967	+	# Ignore these flags.
4968	+	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969	+	;;
4970	+	-lkernel32)
4971	+	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972	+	;;
4973	+	-[LRuY])
4974	+	# These flags, when seen by themselves, take an argument.
4975	+	# We remove the space between option and argument and re-iterate
4976	+	# unless we find an empty arg or a new option (starting with -)
4977	+	case $2 in
4978	+	"" | -*);;
4979	+	*)
4980	+	ac_arg="$ac_arg$2"
4981	+	shift; shift
4982	+	set X $ac_arg "$@"
4983	+	;;
4984	+	esac
4985	+	;;
4986	+	-YP,*)
4987	+	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988	+	ac_exists=false
4989	+	for ac_i in $ac_cv_fc_libs; do
4990	+	if test x"$ac_j" = x"$ac_i"; then
4991	+	ac_exists=true
4992	+	break
4993	+	fi
4994	+	done
4995	+
4996	+	if test x"$ac_exists" = xtrue; then
4997	+	:
4998	+	else
4999	+	ac_arg="$ac_arg $ac_j"
5000	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001	+	fi
5002	+
5003	+	done
5004	+	;;
5005	+	-[lLR]*)
5006	+	ac_exists=false
5007	+	for ac_i in $ac_cv_fc_libs; do
5008	+	if test x"$ac_arg" = x"$ac_i"; then
5009	+	ac_exists=true
5010	+	break
5011	+	fi
5012	+	done
5013	+
5014	+	if test x"$ac_exists" = xtrue; then
5015	+	:
5016	+	else
5017	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018	+	fi
5019	+
5020	+	;;
5021	+	# Ignore everything else.
5022	+	esac
5023	+	done
5024	+	# restore positional arguments
5025	+	set X $ac_save_positional; shift
5026	+
5027	+	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028	+	# then we insist that the "run path" must be an absolute path (i.e. it
5029	+	# must begin with a "/").
5030	+	case `(uname -sr) 2>/dev/null` in
5031	+	"SunOS 5"*)
5032	+	ac_ld_run_path=`echo $ac_fc_v_output |
5033	+	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034	+	test "x$ac_ld_run_path" != x &&
5035	+	if test "$ac_compiler_gnu" = yes; then
5036	+	for ac_link_opt in $ac_ld_run_path; do
5037	+	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038	+	done
5039	+	else
5040	+	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041	+	fi
5042	+	;;
5043		esac
5044	+	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045
5046	+	fi
5047	+	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048	+	echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049	+	FCLIBS="$ac_cv_fc_libs"
5050
5051
5052	+	ac_ext=${FC_SRCEXT-f}
5053	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056
5057
5058	+
5059		echo "$as_me:$LINENO: checking for module suffix" >&5
5060		echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061		rm -f conftest*
5062		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063		rm -f work*
5064	<	cat >conftest.f90 <<EOF
5064	>	cat >conftest.$ac_ext <<EOF
5065		module conftest
5066		integer n
5067		parameter (n=1)
#	Line 4366 | Line 5070 | modcase="lower"
5070		# SGI and absoft compilers generates module name in upper case!
5071		testname="conftest"
5072		modcase="lower"
5073	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5074	<	MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5073	>	if (eval $ac_compile) 2>/dev/null ; then
5074	>	MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075		MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076		if test -z "$MOD" ; then
5077		MOD=`ls CONFTEST* 2>/dev/null \
5078	<	| grep -v CONFTEST.f | grep -v CONFTEST.o`
5078	>	| grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079		MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080		if test -n "$MOD" ; then
5081		testname="CONFTEST"
#	Line 4411 | Line 5115 | rm -f work*
5115		rm -f conftest*
5116		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117		rm -f work*
5118	<	cat >conftest.f90 <<EOF
5118	>	cat >conftest.$ac_ext <<EOF
5119		module conftest
5120		integer n
5121		parameter (n=1)
#	Line 4419 | Line 5123 | testname="conftest"
5123		EOF
5124		# SGI and absoft compilers generates module name in upper case!
5125		testname="conftest"
5126	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5127	<	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5126	>	if (eval $ac_compile) 2>/dev/null ; then
5127	>	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128		mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129		if test -n "$mod" ; then
5130		testname="CONFTEST"
#	Line 4429 | Line 5133 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5133		if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134		cp $testname.$MOD conf
5135		rm -f conftest* CONFTEST*
5136	<	cat >conftest1.f90 <<EOF
5136	>	cat >conftest1.$ac_ext <<EOF
5137		program main
5138		use conftest
5139		print *, n
#	Line 4437 | Line 5141 | EOF
5141		EOF
5142		F90_WORK_FILES_ARG=""
5143		F90MODINCSPEC=""
5144	<	if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5144	>	if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145		MODDIRFLAG="-I"
5146		F90MODINCSPEC="-I<dir>"
5147		echo "$as_me:$LINENO: result: -I" >&5
5148		echo "${ECHO_T}-I" >&6
5149	<	elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5149	>	elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150		MODDIRFLAG="-M"
5151		F90MODINCSPEC="-M<dir>"
5152		echo "$as_me:$LINENO: result: -M" >&5
5153		echo "${ECHO_T}-M" >&6
5154	<	elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5154	>	elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155		MODDIRFLAG="-p"
5156		F90MODINCSPEC="-p<dir>"
5157		echo "$as_me:$LINENO: result: -p" >&5
#	Line 4456 | Line 5160 | echo "${ECHO_T}-p" >&6
5160		cp work.pc conf/mpimod.pc
5161		echo "mpimod.pc" > conf/mpimod.pcl
5162		echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163	<	if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5163	>	if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164		MODDIRFLAG='-cl,mpimod.pcl'
5165		echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166		echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
#	Line 4486 | Line 5190 | else
5190		if test "${ac_cv_f90_module_names+set}" = set; then
5191		echo $ECHO_N "(cached) $ECHO_C" >&6
5192		else
5193	<	ac_ext=f90
5194	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5195	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5196	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5193	>	ac_ext=${FC_SRCEXT-f}
5194	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197
5198		# carry out the test in a new directory, so that we don't miss anything
5199		mkdir conftest
#	Line 4507 | Line 5211 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5211		cat conftest.err >&5
5212		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213		(exit $ac_status); } &&
5214	<	{ ac_try='test -z "$ac_f90_werror_flag"
5214	>	{ ac_try='test -z "$ac_fc_werror_flag"
5215		|| test ! -s conftest.err'
5216		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217		(eval $ac_try) 2>&5
#	Line 4623 | Line 5327 | rm -rf conftest
5327		cd ..
5328		# cleanup
5329		rm -rf conftest
5330	<	ac_ext=f90
5331	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5332	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5333	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5330	>	ac_ext=${FC_SRCEXT-f}
5331	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334
5335		fi
5336		echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
#	Line 4715 | Line 5419 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5419		ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420
5421
5422	<	ac_ext=cc
5423	<	ac_cpp='$CXXCPP $CPPFLAGS'
5424	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5422	>	ac_ext=c
5423	>	ac_cpp='$CPP $CPPFLAGS'
5424	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427
5428
5429
#	Line 4744 | Line 5448 | char asin ();
5448		/* We use char because int might match the return type of a gcc2
5449		builtin and then its argument prototype would still apply.  */
5450		char asin ();
5451	+	#ifdef FC_DUMMY_MAIN
5452	+	#ifndef FC_DUMMY_MAIN_EQ_F77
5453	+	#  ifdef __cplusplus
5454	+	extern "C"
5455	+	#  endif
5456	+	int FC_DUMMY_MAIN() { return 1; }
5457	+	#endif
5458	+	#endif
5459		int
5460		main ()
5461		{
#	Line 4761 | Line 5473 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5473		cat conftest.err >&5
5474		echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475		(exit $ac_status); } &&
5476	<	{ ac_try='test -z "$ac_cxx_werror_flag"
5476	>	{ ac_try='test -z "$ac_c_werror_flag"
5477		|| test ! -s conftest.err'
5478		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479		(eval $ac_try) 2>&5
#	Line 4797 | Line 5509 | fi
5509		else
5510		exit
5511		fi
4800	–
4801	–
4802	–	ac_ext=c
4803	–	ac_cpp='$CPP $CPPFLAGS'
4804	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4805	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4806	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5512
5513
5514		echo "$as_me:$LINENO: checking for ANSI C header files" >&5
#	Line 4822 | Line 5527 | cat >>conftest.$ac_ext <<_ACEOF
5527		#include <string.h>
5528		#include <float.h>
5529
5530	+	#ifdef FC_DUMMY_MAIN
5531	+	#ifndef FC_DUMMY_MAIN_EQ_F77
5532	+	#  ifdef __cplusplus
5533	+	extern "C"
5534	+	#  endif
5535	+	int FC_DUMMY_MAIN() { return 1; }
5536	+	#endif
5537	+	#endif
5538		int
5539		main ()
5540		{
#	Line 5113 | Line 5826 | char inflateEnd ();
5826		/* We use char because int might match the return type of a gcc2
5827		builtin and then its argument prototype would still apply.  */
5828		char inflateEnd ();
5829	<	int
5830	<	main ()
5831	<	{
5832	<	inflateEnd ();
5833	<	;
5834	<	return 0;
5835	<	}
5836	<	_ACEOF
5837	<	rm -f conftest.$ac_objext conftest$ac_exeext
5838	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5839	<	(eval $ac_link) 2>conftest.er1
5840	<	ac_status=$?
5841	<	grep -v '^ *+' conftest.er1 >conftest.err
5842	<	rm -f conftest.er1
5843	<	cat conftest.err >&5
5844	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5845	<	(exit $ac_status); } &&
5846	<	{ ac_try='test -z "$ac_c_werror_flag"
5847	<	|| test ! -s conftest.err'
5848	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5849	<	(eval $ac_try) 2>&5
5850	<	ac_status=$?
5851	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5852	<	(exit $ac_status); }; } &&
5853	<	{ ac_try='test -s conftest$ac_exeext'
5854	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5855	<	(eval $ac_try) 2>&5
5856	<	ac_status=$?
5857	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5858	<	(exit $ac_status); }; }; then
5859	<	ac_cv_lib_z_inflateEnd=yes
5860	<	else
5861	<	echo "$as_me: failed program was:" >&5
5862	<	sed 's/^/| /' conftest.$ac_ext >&5
5863	<
5864	<	ac_cv_lib_z_inflateEnd=no
5865	<	fi
5866	<	rm -f conftest.err conftest.$ac_objext \
5867	<	conftest$ac_exeext conftest.$ac_ext
5868	<	LIBS=$ac_check_lib_save_LIBS
5869	<	fi
5870	<	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5871	<	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5872	<	if test $ac_cv_lib_z_inflateEnd = yes; then
5873	<	zlib_cv_libz=yes
5874	<	else
5875	<	zlib_cv_libz=no
5876	<	fi
5877	<
5878	<	if test "${ac_cv_header_zlib_h+set}" = set; then
5879	<	echo "$as_me:$LINENO: checking for zlib.h" >&5
5880	<	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5881	<	if test "${ac_cv_header_zlib_h+set}" = set; then
5882	<	echo $ECHO_N "(cached) $ECHO_C" >&6
5883	<	fi
5884	<	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5885	<	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5886	<	else
5887	<	# Is the header compilable?
5888	<	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5889	<	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5890	<	cat >conftest.$ac_ext <<_ACEOF
5891	<	/* confdefs.h.  */
5892	<	_ACEOF
5893	<	cat confdefs.h >>conftest.$ac_ext
5894	<	cat >>conftest.$ac_ext <<_ACEOF
5895	<	/* end confdefs.h.  */
5896	<	$ac_includes_default
5897	<	#include <zlib.h>
5898	<	_ACEOF
5899	<	rm -f conftest.$ac_objext
5900	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5901	<	(eval $ac_compile) 2>conftest.er1
5902	<	ac_status=$?
5903	<	grep -v '^ *+' conftest.er1 >conftest.err
5904	<	rm -f conftest.er1
5905	<	cat conftest.err >&5
5906	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5907	<	(exit $ac_status); } &&
5908	<	{ ac_try='test -z "$ac_c_werror_flag"
5909	<	|| test ! -s conftest.err'
5910	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5911	<	(eval $ac_try) 2>&5
5912	<	ac_status=$?
5913	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5914	<	(exit $ac_status); }; } &&
5915	<	{ ac_try='test -s conftest.$ac_objext'
5916	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5917	<	(eval $ac_try) 2>&5
5918	<	ac_status=$?
5919	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5920	<	(exit $ac_status); }; }; then
5921	<	ac_header_compiler=yes
5922	<	else
5923	<	echo "$as_me: failed program was:" >&5
5924	<	sed 's/^/| /' conftest.$ac_ext >&5
5925	<
5926	<	ac_header_compiler=no
5927	<	fi
5928	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5929	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5930	<	echo "${ECHO_T}$ac_header_compiler" >&6
5931	<
5932	<	# Is the header present?
5933	<	echo "$as_me:$LINENO: checking zlib.h presence" >&5
5934	<	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5935	<	cat >conftest.$ac_ext <<_ACEOF
5936	<	/* confdefs.h.  */
5937	<	_ACEOF
5938	<	cat confdefs.h >>conftest.$ac_ext
5939	<	cat >>conftest.$ac_ext <<_ACEOF
5940	<	/* end confdefs.h.  */
5941	<	#include <zlib.h>
5942	<	_ACEOF
5943	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5944	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5945	<	ac_status=$?
5946	<	grep -v '^ *+' conftest.er1 >conftest.err
5947	<	rm -f conftest.er1
5948	<	cat conftest.err >&5
5949	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5950	<	(exit $ac_status); } >/dev/null; then
5951	<	if test -s conftest.err; then
5952	<	ac_cpp_err=$ac_c_preproc_warn_flag
5953	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5954	<	else
5955	<	ac_cpp_err=
5956	<	fi
5957	<	else
5958	<	ac_cpp_err=yes
5959	<	fi
5960	<	if test -z "$ac_cpp_err"; then
5961	<	ac_header_preproc=yes
5962	<	else
5963	<	echo "$as_me: failed program was:" >&5
5964	<	sed 's/^/| /' conftest.$ac_ext >&5
5965	<
5966	<	ac_header_preproc=no
5967	<	fi
5968	<	rm -f conftest.err conftest.$ac_ext
5969	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5970	<	echo "${ECHO_T}$ac_header_preproc" >&6
5971	<
5972	<	# So?  What about this header?
5973	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5974	<	yes:no: )
5975	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5976	<	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5977	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5978	<	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5979	<	ac_header_preproc=yes
5980	<	;;
5981	<	no:yes:* )
5982	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5983	<	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5984	<	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5985	<	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5986	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5987	<	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5988	<	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5989	<	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5990	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5991	<	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5992	<	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5993	<	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5994	<	(
5995	<	cat <<\_ASBOX
5996	<	## ------------------------------ ##
5997	<	## Report this to gezelter@nd.edu ##
5998	<	## ------------------------------ ##
5999	<	_ASBOX
6000	<	) |
6001	<	sed "s/^/$as_me: WARNING:     /" >&2
6002	<	;;
6003	<	esac
6004	<	echo "$as_me:$LINENO: checking for zlib.h" >&5
6005	<	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6006	<	if test "${ac_cv_header_zlib_h+set}" = set; then
6007	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6008	<	else
6009	<	ac_cv_header_zlib_h=$ac_header_preproc
6010	<	fi
6011	<	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6012	<	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6013	<
6014	<	fi
6015	<	if test $ac_cv_header_zlib_h = yes; then
6016	<	zlib_cv_zlib_h=yes
6017	<	else
6018	<	zlib_cv_zlib_h=no
6019	<	fi
6020	<
6021	<
6022	<	ac_ext=c
6023	<	ac_cpp='$CPP $CPPFLAGS'
6024	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6025	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6026	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6027	<
6028	<	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6029	<	then
6030	<	#
6031	<	# If both library and header were found, use them
6032	<	#
6033	<
6034	<	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6035	<	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6036	<	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6037	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6038	<	else
6039	<	ac_check_lib_save_LIBS=$LIBS
6040	<	LIBS="-lz  $LIBS"
6041	<	cat >conftest.$ac_ext <<_ACEOF
6042	<	/* confdefs.h.  */
6043	<	_ACEOF
6044	<	cat confdefs.h >>conftest.$ac_ext
6045	<	cat >>conftest.$ac_ext <<_ACEOF
6046	<	/* end confdefs.h.  */
6047	<
6048	<	/* Override any gcc2 internal prototype to avoid an error.  */
6049	<	#ifdef __cplusplus
6050	<	extern "C"
6051	<	#endif
6052	<	/* We use char because int might match the return type of a gcc2
6053	<	builtin and then its argument prototype would still apply.  */
6054	<	char inflateEnd ();
6055	<	int
6056	<	main ()
6057	<	{
6058	<	inflateEnd ();
6059	<	;
6060	<	return 0;
6061	<	}
6062	<	_ACEOF
6063	<	rm -f conftest.$ac_objext conftest$ac_exeext
6064	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6065	<	(eval $ac_link) 2>conftest.er1
6066	<	ac_status=$?
6067	<	grep -v '^ *+' conftest.er1 >conftest.err
6068	<	rm -f conftest.er1
6069	<	cat conftest.err >&5
6070	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6071	<	(exit $ac_status); } &&
6072	<	{ ac_try='test -z "$ac_c_werror_flag"
6073	<	|| test ! -s conftest.err'
6074	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6075	<	(eval $ac_try) 2>&5
6076	<	ac_status=$?
6077	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6078	<	(exit $ac_status); }; } &&
6079	<	{ ac_try='test -s conftest$ac_exeext'
6080	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6081	<	(eval $ac_try) 2>&5
6082	<	ac_status=$?
6083	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6084	<	(exit $ac_status); }; }; then
6085	<	ac_cv_lib_z_inflateEnd=yes
6086	<	else
6087	<	echo "$as_me: failed program was:" >&5
6088	<	sed 's/^/| /' conftest.$ac_ext >&5
6089	<
6090	<	ac_cv_lib_z_inflateEnd=no
6091	<	fi
6092	<	rm -f conftest.err conftest.$ac_objext \
6093	<	conftest$ac_exeext conftest.$ac_ext
6094	<	LIBS=$ac_check_lib_save_LIBS
6095	<	fi
6096	<	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6097	<	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6098	<	if test $ac_cv_lib_z_inflateEnd = yes; then
6099	<	cat >>confdefs.h <<_ACEOF
6100	<	#define HAVE_LIBZ 1
6101	<	_ACEOF
6102	<
6103	<	LIBS="-lz $LIBS"
6104	<
6105	<	fi
6106	<
6107	<	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6108	<	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6109	<	echo "$as_me:$LINENO: result: ok" >&5
6110	<	echo "${ECHO_T}ok" >&6
6111	<	else
6112	<	#
6113	<	# If either header or library was not found, revert and bomb
6114	<	#
6115	<	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6116	<	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6117	<	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6118	<	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6119	<	echo "$as_me:$LINENO: result: failed" >&5
6120	<	echo "${ECHO_T}failed" >&6
6121	<	{ { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6122	<	echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6123	<	{ (exit 1); exit 1; }; }
6124	<	fi
6125	<	fi
6126	<
6127	<
6128	<
6129	<
6130	<
6131	<
6132	<
6133	<
6134	<	for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
6135	<	do
6136	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6137	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
6138	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
6139	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6140	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
6141	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6142	<	fi
6143	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6144	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6145	<	else
6146	<	# Is the header compilable?
6147	<	echo "$as_me:$LINENO: checking $ac_header usability" >&5
6148	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6149	<	cat >conftest.$ac_ext <<_ACEOF
6150	<	/* confdefs.h.  */
6151	<	_ACEOF
6152	<	cat confdefs.h >>conftest.$ac_ext
6153	<	cat >>conftest.$ac_ext <<_ACEOF
6154	<	/* end confdefs.h.  */
6155	<	$ac_includes_default
6156	<	#include <$ac_header>
6157	<	_ACEOF
6158	<	rm -f conftest.$ac_objext
6159	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6160	<	(eval $ac_compile) 2>conftest.er1
6161	<	ac_status=$?
6162	<	grep -v '^ *+' conftest.er1 >conftest.err
6163	<	rm -f conftest.er1
6164	<	cat conftest.err >&5
6165	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6166	<	(exit $ac_status); } &&
6167	<	{ ac_try='test -z "$ac_c_werror_flag"
6168	<	|| test ! -s conftest.err'
6169	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6170	<	(eval $ac_try) 2>&5
6171	<	ac_status=$?
6172	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6173	<	(exit $ac_status); }; } &&
6174	<	{ ac_try='test -s conftest.$ac_objext'
6175	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6176	<	(eval $ac_try) 2>&5
6177	<	ac_status=$?
6178	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6179	<	(exit $ac_status); }; }; then
6180	<	ac_header_compiler=yes
6181	<	else
6182	<	echo "$as_me: failed program was:" >&5
6183	<	sed 's/^/| /' conftest.$ac_ext >&5
6184	<
6185	<	ac_header_compiler=no
6186	<	fi
6187	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6188	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6189	<	echo "${ECHO_T}$ac_header_compiler" >&6
6190	<
6191	<	# Is the header present?
6192	<	echo "$as_me:$LINENO: checking $ac_header presence" >&5
6193	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6194	<	cat >conftest.$ac_ext <<_ACEOF
6195	<	/* confdefs.h.  */
6196	<	_ACEOF
6197	<	cat confdefs.h >>conftest.$ac_ext
6198	<	cat >>conftest.$ac_ext <<_ACEOF
6199	<	/* end confdefs.h.  */
6200	<	#include <$ac_header>
6201	<	_ACEOF
6202	<	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6203	<	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6204	<	ac_status=$?
6205	<	grep -v '^ *+' conftest.er1 >conftest.err
6206	<	rm -f conftest.er1
6207	<	cat conftest.err >&5
6208	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6209	<	(exit $ac_status); } >/dev/null; then
6210	<	if test -s conftest.err; then
6211	<	ac_cpp_err=$ac_c_preproc_warn_flag
6212	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6213	<	else
6214	<	ac_cpp_err=
6215	<	fi
6216	<	else
6217	<	ac_cpp_err=yes
6218	<	fi
6219	<	if test -z "$ac_cpp_err"; then
6220	<	ac_header_preproc=yes
6221	<	else
6222	<	echo "$as_me: failed program was:" >&5
6223	<	sed 's/^/| /' conftest.$ac_ext >&5
6224	<
6225	<	ac_header_preproc=no
6226	<	fi
6227	<	rm -f conftest.err conftest.$ac_ext
6228	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6229	<	echo "${ECHO_T}$ac_header_preproc" >&6
6230	<
6231	<	# So?  What about this header?
6232	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6233	<	yes:no: )
6234	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6235	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6236	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6237	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6238	<	ac_header_preproc=yes
6239	<	;;
6240	<	no:yes:* )
6241	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6242	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6243	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6244	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6245	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6246	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6247	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6248	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6249	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6250	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6251	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6252	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6253	<	(
6254	<	cat <<\_ASBOX
6255	<	## ------------------------------ ##
6256	<	## Report this to gezelter@nd.edu ##
6257	<	## ------------------------------ ##
6258	<	_ASBOX
6259	<	) |
6260	<	sed "s/^/$as_me: WARNING:     /" >&2
6261	<	;;
6262	<	esac
6263	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
6264	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6265	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
6266	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6267	<	else
6268	<	eval "$as_ac_Header=\$ac_header_preproc"
6269	<	fi
6270	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6271	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5829	>	#ifdef FC_DUMMY_MAIN
5830	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5831	>	#  ifdef __cplusplus
5832	>	extern "C"
5833	>	#  endif
5834	>	int FC_DUMMY_MAIN() { return 1; }
5835	>	#endif
5836	>	#endif
5837	>	int
5838	>	main ()
5839	>	{
5840	>	inflateEnd ();
5841	>	;
5842	>	return 0;
5843	>	}
5844	>	_ACEOF
5845	>	rm -f conftest.$ac_objext conftest$ac_exeext
5846	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847	>	(eval $ac_link) 2>conftest.er1
5848	>	ac_status=$?
5849	>	grep -v '^ *+' conftest.er1 >conftest.err
5850	>	rm -f conftest.er1
5851	>	cat conftest.err >&5
5852	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853	>	(exit $ac_status); } &&
5854	>	{ ac_try='test -z "$ac_c_werror_flag"
5855	>	|| test ! -s conftest.err'
5856	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857	>	(eval $ac_try) 2>&5
5858	>	ac_status=$?
5859	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860	>	(exit $ac_status); }; } &&
5861	>	{ ac_try='test -s conftest$ac_exeext'
5862	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863	>	(eval $ac_try) 2>&5
5864	>	ac_status=$?
5865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866	>	(exit $ac_status); }; }; then
5867	>	ac_cv_lib_z_inflateEnd=yes
5868	>	else
5869	>	echo "$as_me: failed program was:" >&5
5870	>	sed 's/^/| /' conftest.$ac_ext >&5
5871	>
5872	>	ac_cv_lib_z_inflateEnd=no
5873	>	fi
5874	>	rm -f conftest.err conftest.$ac_objext \
5875	>	conftest$ac_exeext conftest.$ac_ext
5876	>	LIBS=$ac_check_lib_save_LIBS
5877	>	fi
5878	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880	>	if test $ac_cv_lib_z_inflateEnd = yes; then
5881	>	zlib_cv_libz=yes
5882	>	else
5883	>	zlib_cv_libz=no
5884	>	fi
5885	>
5886	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5887	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
5888	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5890	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5891	>	fi
5892	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894	>	else
5895	>	# Is the header compilable?
5896	>	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897	>	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898	>	cat >conftest.$ac_ext <<_ACEOF
5899	>	/* confdefs.h.  */
5900	>	_ACEOF
5901	>	cat confdefs.h >>conftest.$ac_ext
5902	>	cat >>conftest.$ac_ext <<_ACEOF
5903	>	/* end confdefs.h.  */
5904	>	$ac_includes_default
5905	>	#include <zlib.h>
5906	>	_ACEOF
5907	>	rm -f conftest.$ac_objext
5908	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5909	>	(eval $ac_compile) 2>conftest.er1
5910	>	ac_status=$?
5911	>	grep -v '^ *+' conftest.er1 >conftest.err
5912	>	rm -f conftest.er1
5913	>	cat conftest.err >&5
5914	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915	>	(exit $ac_status); } &&
5916	>	{ ac_try='test -z "$ac_c_werror_flag"
5917	>	|| test ! -s conftest.err'
5918	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919	>	(eval $ac_try) 2>&5
5920	>	ac_status=$?
5921	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5922	>	(exit $ac_status); }; } &&
5923	>	{ ac_try='test -s conftest.$ac_objext'
5924	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5925	>	(eval $ac_try) 2>&5
5926	>	ac_status=$?
5927	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5928	>	(exit $ac_status); }; }; then
5929	>	ac_header_compiler=yes
5930	>	else
5931	>	echo "$as_me: failed program was:" >&5
5932	>	sed 's/^/| /' conftest.$ac_ext >&5
5933	>
5934	>	ac_header_compiler=no
5935	>	fi
5936	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5937	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5938	>	echo "${ECHO_T}$ac_header_compiler" >&6
5939	>
5940	>	# Is the header present?
5941	>	echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942	>	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943	>	cat >conftest.$ac_ext <<_ACEOF
5944	>	/* confdefs.h.  */
5945	>	_ACEOF
5946	>	cat confdefs.h >>conftest.$ac_ext
5947	>	cat >>conftest.$ac_ext <<_ACEOF
5948	>	/* end confdefs.h.  */
5949	>	#include <zlib.h>
5950	>	_ACEOF
5951	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5953	>	ac_status=$?
5954	>	grep -v '^ *+' conftest.er1 >conftest.err
5955	>	rm -f conftest.er1
5956	>	cat conftest.err >&5
5957	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958	>	(exit $ac_status); } >/dev/null; then
5959	>	if test -s conftest.err; then
5960	>	ac_cpp_err=$ac_c_preproc_warn_flag
5961	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962	>	else
5963	>	ac_cpp_err=
5964	>	fi
5965	>	else
5966	>	ac_cpp_err=yes
5967	>	fi
5968	>	if test -z "$ac_cpp_err"; then
5969	>	ac_header_preproc=yes
5970	>	else
5971	>	echo "$as_me: failed program was:" >&5
5972	>	sed 's/^/| /' conftest.$ac_ext >&5
5973	>
5974	>	ac_header_preproc=no
5975	>	fi
5976	>	rm -f conftest.err conftest.$ac_ext
5977	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5978	>	echo "${ECHO_T}$ac_header_preproc" >&6
5979	>
5980	>	# So?  What about this header?
5981	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982	>	yes:no: )
5983	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984	>	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986	>	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987	>	ac_header_preproc=yes
5988	>	;;
5989	>	no:yes:* )
5990	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991	>	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993	>	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995	>	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997	>	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999	>	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001	>	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002	>	(
6003	>	cat <<\_ASBOX
6004	>	## ------------------------------ ##
6005	>	## Report this to gezelter@nd.edu ##
6006	>	## ------------------------------ ##
6007	>	_ASBOX
6008	>	) |
6009	>	sed "s/^/$as_me: WARNING:     /" >&2
6010	>	;;
6011	>	esac
6012	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6013	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6015	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6016	>	else
6017	>	ac_cv_header_zlib_h=$ac_header_preproc
6018	>	fi
6019	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021	>
6022	>	fi
6023	>	if test $ac_cv_header_zlib_h = yes; then
6024	>	zlib_cv_zlib_h=yes
6025	>	else
6026	>	zlib_cv_zlib_h=no
6027	>	fi
6028	>
6029	>
6030	>	ac_ext=c
6031	>	ac_cpp='$CPP $CPPFLAGS'
6032	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035	>
6036	>	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037	>	then
6038	>	#
6039	>	# If both library and header were found, use them
6040	>	#
6041	>
6042	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6046	>	else
6047	>	ac_check_lib_save_LIBS=$LIBS
6048	>	LIBS="-lz  $LIBS"
6049	>	cat >conftest.$ac_ext <<_ACEOF
6050	>	/* confdefs.h.  */
6051	>	_ACEOF
6052	>	cat confdefs.h >>conftest.$ac_ext
6053	>	cat >>conftest.$ac_ext <<_ACEOF
6054	>	/* end confdefs.h.  */
6055	>
6056	>	/* Override any gcc2 internal prototype to avoid an error.  */
6057	>	#ifdef __cplusplus
6058	>	extern "C"
6059	>	#endif
6060	>	/* We use char because int might match the return type of a gcc2
6061	>	builtin and then its argument prototype would still apply.  */
6062	>	char inflateEnd ();
6063	>	#ifdef FC_DUMMY_MAIN
6064	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6065	>	#  ifdef __cplusplus
6066	>	extern "C"
6067	>	#  endif
6068	>	int FC_DUMMY_MAIN() { return 1; }
6069	>	#endif
6070	>	#endif
6071	>	int
6072	>	main ()
6073	>	{
6074	>	inflateEnd ();
6075	>	;
6076	>	return 0;
6077	>	}
6078	>	_ACEOF
6079	>	rm -f conftest.$ac_objext conftest$ac_exeext
6080	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081	>	(eval $ac_link) 2>conftest.er1
6082	>	ac_status=$?
6083	>	grep -v '^ *+' conftest.er1 >conftest.err
6084	>	rm -f conftest.er1
6085	>	cat conftest.err >&5
6086	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087	>	(exit $ac_status); } &&
6088	>	{ ac_try='test -z "$ac_c_werror_flag"
6089	>	|| test ! -s conftest.err'
6090	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091	>	(eval $ac_try) 2>&5
6092	>	ac_status=$?
6093	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094	>	(exit $ac_status); }; } &&
6095	>	{ ac_try='test -s conftest$ac_exeext'
6096	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097	>	(eval $ac_try) 2>&5
6098	>	ac_status=$?
6099	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100	>	(exit $ac_status); }; }; then
6101	>	ac_cv_lib_z_inflateEnd=yes
6102	>	else
6103	>	echo "$as_me: failed program was:" >&5
6104	>	sed 's/^/| /' conftest.$ac_ext >&5
6105	>
6106	>	ac_cv_lib_z_inflateEnd=no
6107	>	fi
6108	>	rm -f conftest.err conftest.$ac_objext \
6109	>	conftest$ac_exeext conftest.$ac_ext
6110	>	LIBS=$ac_check_lib_save_LIBS
6111	>	fi
6112	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114	>	if test $ac_cv_lib_z_inflateEnd = yes; then
6115	>	cat >>confdefs.h <<_ACEOF
6116	>	#define HAVE_LIBZ 1
6117	>	_ACEOF
6118	>
6119	>	LIBS="-lz $LIBS"
6120	>
6121	>	fi
6122	>
6123	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125	>	echo "$as_me:$LINENO: result: ok" >&5
6126	>	echo "${ECHO_T}ok" >&6
6127	>	else
6128	>	#
6129	>	# If either header or library was not found, revert and bomb
6130	>	#
6131	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133	>	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134	>	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135	>	echo "$as_me:$LINENO: result: failed" >&5
6136	>	echo "${ECHO_T}failed" >&6
6137	>	{ { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138	>	echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139	>	{ (exit 1); exit 1; }; }
6140	>	fi
6141	>	fi
6142	>
6143	>
6144	>
6145	>	# Check whether --with-fftw or --without-fftw was given.
6146	>	if test "${with_fftw+set}" = set; then
6147	>	withval="$with_fftw"
6148	>
6149	>	else
6150	>	with_fftw=yes
6151	>	fi;
6152	>	if test "$with_fftw" = "no"; then
6153	>
6154	>	cat >>confdefs.h <<\_ACEOF
6155	>	#define WITHOUT_FFTW
6156	>	_ACEOF
6157	>
6158	>	fi
6159	>	if test "$with_fftw" = "yes"; then
6160	>	sizeof_real=8
6161	>
6162	>
6163	>	if test -z "$ac_fftw_firstname"; then
6164	>
6165	>	sizeof_real=$sizeof_real
6166	>	if test $sizeof_real = 8; then
6167	>	prec="double"
6168	>	fftwcheckprefix=d
6169	>	else
6170	>	prec="single"
6171	>	fftwcheckprefix=s
6172	>	fi
6173	>
6174	>	xfftwname=${fftwcheckprefix}fftw3
6175	>
6176	>	ok="no"
6177	>	# check header doesn't work, since we must use mpicc to get includes,
6178	>	# we cant trust cpp.
6179	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181	>	cat >conftest.$ac_ext <<_ACEOF
6182	>	/* confdefs.h.  */
6183	>	_ACEOF
6184	>	cat confdefs.h >>conftest.$ac_ext
6185	>	cat >>conftest.$ac_ext <<_ACEOF
6186	>	/* end confdefs.h.  */
6187	>	#include <$xfftwname.h>
6188	>	#ifdef FC_DUMMY_MAIN
6189	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6190	>	#  ifdef __cplusplus
6191	>	extern "C"
6192	>	#  endif
6193	>	int FC_DUMMY_MAIN() { return 1; }
6194	>	#endif
6195	>	#endif
6196	>	int
6197	>	main ()
6198	>	{
6199	>
6200	>	;
6201	>	return 0;
6202	>	}
6203	>	_ACEOF
6204	>	rm -f conftest.$ac_objext
6205	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206	>	(eval $ac_compile) 2>conftest.er1
6207	>	ac_status=$?
6208	>	grep -v '^ *+' conftest.er1 >conftest.err
6209	>	rm -f conftest.er1
6210	>	cat conftest.err >&5
6211	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212	>	(exit $ac_status); } &&
6213	>	{ ac_try='test -z "$ac_c_werror_flag"
6214	>	|| test ! -s conftest.err'
6215	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216	>	(eval $ac_try) 2>&5
6217	>	ac_status=$?
6218	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6219	>	(exit $ac_status); }; } &&
6220	>	{ ac_try='test -s conftest.$ac_objext'
6221	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6222	>	(eval $ac_try) 2>&5
6223	>	ac_status=$?
6224	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225	>	(exit $ac_status); }; }; then
6226	>
6227	>	fftwname=$xfftwname
6228	>	echo "$as_me:$LINENO: result: yes" >&5
6229	>	echo "${ECHO_T}yes" >&6
6230	>
6231	>	else
6232	>	echo "$as_me: failed program was:" >&5
6233	>	sed 's/^/| /' conftest.$ac_ext >&5
6234	>
6235	>	echo "$as_me:$LINENO: result: no" >&5
6236	>	echo "${ECHO_T}no" >&6
6237	>	fi
6238	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6239	>
6240	>	# fftwname was set if we found a header
6241	>
6242	>	if test -n "$fftwname"; then
6243	>	# we cannot run the code since an MPI program might not be allowed
6244	>	# on a login node of a supercomputer
6245	>	cat >conftest.$ac_ext <<_ACEOF
6246	>	/* confdefs.h.  */
6247	>	_ACEOF
6248	>	cat confdefs.h >>conftest.$ac_ext
6249	>	cat >>conftest.$ac_ext <<_ACEOF
6250	>	/* end confdefs.h.  */
6251	>	#include <$fftwname.h>
6252	>	#ifdef FC_DUMMY_MAIN
6253	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6254	>	#  ifdef __cplusplus
6255	>	extern "C"
6256	>	#  endif
6257	>	int FC_DUMMY_MAIN() { return 1; }
6258	>	#endif
6259	>	#endif
6260	>	int
6261	>	main ()
6262	>	{
6263	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264	>	;
6265	>	return 0;
6266	>	}
6267	>	_ACEOF
6268	>	rm -f conftest.$ac_objext
6269	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270	>	(eval $ac_compile) 2>conftest.er1
6271	>	ac_status=$?
6272	>	grep -v '^ *+' conftest.er1 >conftest.err
6273	>	rm -f conftest.er1
6274	>	cat conftest.err >&5
6275	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276	>	(exit $ac_status); } &&
6277	>	{ ac_try='test -z "$ac_c_werror_flag"
6278	>	|| test ! -s conftest.err'
6279	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280	>	(eval $ac_try) 2>&5
6281	>	ac_status=$?
6282	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283	>	(exit $ac_status); }; } &&
6284	>	{ ac_try='test -s conftest.$ac_objext'
6285	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286	>	(eval $ac_try) 2>&5
6287	>	ac_status=$?
6288	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289	>	(exit $ac_status); }; }; then
6290	>
6291	>	ok=yes
6292	>	usedprefix=$fftwcheckprefix
6293	>
6294	>	else
6295	>	echo "$as_me: failed program was:" >&5
6296	>	sed 's/^/| /' conftest.$ac_ext >&5
6297	>
6298	>	ok=no
6299	>	fi
6300	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301	>	fi
6302	>
6303	>	if test "$ok" != "yes"; then
6304	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306	>	cat >conftest.$ac_ext <<_ACEOF
6307	>	/* confdefs.h.  */
6308	>	_ACEOF
6309	>	cat confdefs.h >>conftest.$ac_ext
6310	>	cat >>conftest.$ac_ext <<_ACEOF
6311	>	/* end confdefs.h.  */
6312	>	#include <fftw3.h>
6313	>	#ifdef FC_DUMMY_MAIN
6314	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6315	>	#  ifdef __cplusplus
6316	>	extern "C"
6317	>	#  endif
6318	>	int FC_DUMMY_MAIN() { return 1; }
6319	>	#endif
6320	>	#endif
6321	>	int
6322	>	main ()
6323	>	{
6324	>
6325	>	;
6326	>	return 0;
6327	>	}
6328	>	_ACEOF
6329	>	rm -f conftest.$ac_objext
6330	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6331	>	(eval $ac_compile) 2>conftest.er1
6332	>	ac_status=$?
6333	>	grep -v '^ *+' conftest.er1 >conftest.err
6334	>	rm -f conftest.er1
6335	>	cat conftest.err >&5
6336	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337	>	(exit $ac_status); } &&
6338	>	{ ac_try='test -z "$ac_c_werror_flag"
6339	>	|| test ! -s conftest.err'
6340	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341	>	(eval $ac_try) 2>&5
6342	>	ac_status=$?
6343	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6344	>	(exit $ac_status); }; } &&
6345	>	{ ac_try='test -s conftest.$ac_objext'
6346	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6347	>	(eval $ac_try) 2>&5
6348	>	ac_status=$?
6349	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350	>	(exit $ac_status); }; }; then
6351	>	echo "$as_me:$LINENO: result: yes" >&5
6352	>	echo "${ECHO_T}yes" >&6
6353	>	else
6354	>	echo "$as_me: failed program was:" >&5
6355	>	sed 's/^/| /' conftest.$ac_ext >&5
6356	>
6357	>
6358	>	echo "$as_me:$LINENO: result: no" >&5
6359	>	echo "${ECHO_T}no" >&6
6360	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361	>	Do you have $prec precision FFTW installed? If you are using packages,
6362	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363	>	software at www.fftw.org.
6364	>	If you compiled FFTW yourself:
6365	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6366	>	use --with-mpi. It is a good idea to install both single & double.
6367	>	If you have installed FFTW in a non-standard location, you should
6368	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369	>	variables before running configure.
6370	>	That is also necessary to do if your compiler doesn't search
6371	>	/usr/local/include and /usr/local/lib by default." >&5
6372	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373	>	Do you have $prec precision FFTW installed? If you are using packages,
6374	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375	>	software at www.fftw.org.
6376	>	If you compiled FFTW yourself:
6377	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6378	>	use --with-mpi. It is a good idea to install both single & double.
6379	>	If you have installed FFTW in a non-standard location, you should
6380	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381	>	variables before running configure.
6382	>	That is also necessary to do if your compiler doesn't search
6383	>	/usr/local/include and /usr/local/lib by default." >&2;}
6384	>	{ (exit 1); exit 1; }; }
6385	>
6386	>	fi
6387	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6388	>	cat >conftest.$ac_ext <<_ACEOF
6389	>	/* confdefs.h.  */
6390	>	_ACEOF
6391	>	cat confdefs.h >>conftest.$ac_ext
6392	>	cat >>conftest.$ac_ext <<_ACEOF
6393	>	/* end confdefs.h.  */
6394	>	#include <fftw3.h>
6395	>	#ifdef FC_DUMMY_MAIN
6396	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6397	>	#  ifdef __cplusplus
6398	>	extern "C"
6399	>	#  endif
6400	>	int FC_DUMMY_MAIN() { return 1; }
6401	>	#endif
6402	>	#endif
6403	>	int
6404	>	main ()
6405	>	{
6406	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407	>	;
6408	>	return 0;
6409	>	}
6410	>	_ACEOF
6411	>	rm -f conftest.$ac_objext
6412	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413	>	(eval $ac_compile) 2>conftest.er1
6414	>	ac_status=$?
6415	>	grep -v '^ *+' conftest.er1 >conftest.err
6416	>	rm -f conftest.er1
6417	>	cat conftest.err >&5
6418	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419	>	(exit $ac_status); } &&
6420	>	{ ac_try='test -z "$ac_c_werror_flag"
6421	>	|| test ! -s conftest.err'
6422	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423	>	(eval $ac_try) 2>&5
6424	>	ac_status=$?
6425	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426	>	(exit $ac_status); }; } &&
6427	>	{ ac_try='test -s conftest.$ac_objext'
6428	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429	>	(eval $ac_try) 2>&5
6430	>	ac_status=$?
6431	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432	>	(exit $ac_status); }; }; then
6433	>
6434	>	usedprefix=""
6435	>	fftwname=fftw3
6436	>
6437	>	else
6438	>	echo "$as_me: failed program was:" >&5
6439	>	sed 's/^/| /' conftest.$ac_ext >&5
6440	>
6441	>
6442	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443	>	Do you have $prec precision FFTW installed? If you are using packages,
6444	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445	>	software at www.fftw.org.
6446	>	If you compiled FFTW yourself:
6447	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6448	>	use --with-mpi. It is a good idea to install both single & double.
6449	>	If you have installed FFTW in a non-standard location, you should
6450	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451	>	variables before running configure.
6452	>	That is also necessary to do if your compiler doesn't search
6453	>	/usr/local/include and /usr/local/lib by default." >&5
6454	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455	>	Do you have $prec precision FFTW installed? If you are using packages,
6456	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457	>	software at www.fftw.org.
6458	>	If you compiled FFTW yourself:
6459	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6460	>	use --with-mpi. It is a good idea to install both single & double.
6461	>	If you have installed FFTW in a non-standard location, you should
6462	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463	>	variables before running configure.
6464	>	That is also necessary to do if your compiler doesn't search
6465	>	/usr/local/include and /usr/local/lib by default." >&2;}
6466	>	{ (exit 1); exit 1; }; }
6467	>	fi
6468	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469	>	fi
6470	>
6471	>
6472	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6477	>	else
6478	>	ac_check_lib_save_LIBS=$LIBS
6479	>	LIBS="-l$fftwname  $LIBS"
6480	>	cat >conftest.$ac_ext <<_ACEOF
6481	>	/* confdefs.h.  */
6482	>	_ACEOF
6483	>	cat confdefs.h >>conftest.$ac_ext
6484	>	cat >>conftest.$ac_ext <<_ACEOF
6485	>	/* end confdefs.h.  */
6486	>
6487	>
6488	>	#ifdef FC_DUMMY_MAIN
6489	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6490	>	#  ifdef __cplusplus
6491	>	extern "C"
6492	>	#  endif
6493	>	int FC_DUMMY_MAIN() { return 1; }
6494	>	#endif
6495	>	#endif
6496	>	int
6497	>	main ()
6498	>	{
6499	>	main ();
6500	>	;
6501	>	return 0;
6502	>	}
6503	>	_ACEOF
6504	>	rm -f conftest.$ac_objext conftest$ac_exeext
6505	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506	>	(eval $ac_link) 2>conftest.er1
6507	>	ac_status=$?
6508	>	grep -v '^ *+' conftest.er1 >conftest.err
6509	>	rm -f conftest.er1
6510	>	cat conftest.err >&5
6511	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512	>	(exit $ac_status); } &&
6513	>	{ ac_try='test -z "$ac_c_werror_flag"
6514	>	|| test ! -s conftest.err'
6515	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516	>	(eval $ac_try) 2>&5
6517	>	ac_status=$?
6518	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519	>	(exit $ac_status); }; } &&
6520	>	{ ac_try='test -s conftest$ac_exeext'
6521	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522	>	(eval $ac_try) 2>&5
6523	>	ac_status=$?
6524	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525	>	(exit $ac_status); }; }; then
6526	>	eval "$as_ac_Lib=yes"
6527	>	else
6528	>	echo "$as_me: failed program was:" >&5
6529	>	sed 's/^/| /' conftest.$ac_ext >&5
6530	>
6531	>	eval "$as_ac_Lib=no"
6532	>	fi
6533	>	rm -f conftest.err conftest.$ac_objext \
6534	>	conftest$ac_exeext conftest.$ac_ext
6535	>	LIBS=$ac_check_lib_save_LIBS
6536	>	fi
6537	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540	>	cat >>confdefs.h <<_ACEOF
6541	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542	>	_ACEOF
6543	>
6544	>	LIBS="-l$fftwname $LIBS"
6545	>
6546	>	else
6547	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549	>	{ (exit 1); exit 1; }; }
6550	>	fi
6551	>
6552	>	ac_fftw_savedprefix=$usedprefix
6553	>	ac_fftw_firstname=$fftwname
6554	>
6555	>	else
6556	>
6557	>	fftwname=${ac_fftw_savedprefix}fftw3
6558	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560	>	cat >conftest.$ac_ext <<_ACEOF
6561	>	/* confdefs.h.  */
6562	>	_ACEOF
6563	>	cat confdefs.h >>conftest.$ac_ext
6564	>	cat >>conftest.$ac_ext <<_ACEOF
6565	>	/* end confdefs.h.  */
6566	>	#include <$fftwname.h>
6567	>	#ifdef FC_DUMMY_MAIN
6568	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6569	>	#  ifdef __cplusplus
6570	>	extern "C"
6571	>	#  endif
6572	>	int FC_DUMMY_MAIN() { return 1; }
6573	>	#endif
6574	>	#endif
6575	>	int
6576	>	main ()
6577	>	{
6578	>
6579	>	;
6580	>	return 0;
6581	>	}
6582	>	_ACEOF
6583	>	rm -f conftest.$ac_objext
6584	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585	>	(eval $ac_compile) 2>conftest.er1
6586	>	ac_status=$?
6587	>	grep -v '^ *+' conftest.er1 >conftest.err
6588	>	rm -f conftest.er1
6589	>	cat conftest.err >&5
6590	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591	>	(exit $ac_status); } &&
6592	>	{ ac_try='test -z "$ac_c_werror_flag"
6593	>	|| test ! -s conftest.err'
6594	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595	>	(eval $ac_try) 2>&5
6596	>	ac_status=$?
6597	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598	>	(exit $ac_status); }; } &&
6599	>	{ ac_try='test -s conftest.$ac_objext'
6600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601	>	(eval $ac_try) 2>&5
6602	>	ac_status=$?
6603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604	>	(exit $ac_status); }; }; then
6605	>	echo "$as_me:$LINENO: result: yes" >&5
6606	>	echo "${ECHO_T}yes" >&6
6607	>	LIBS="-l$fftwname $LIBS"
6608	>	cat >conftest.$ac_ext <<_ACEOF
6609	>	/* confdefs.h.  */
6610	>	_ACEOF
6611	>	cat confdefs.h >>conftest.$ac_ext
6612	>	cat >>conftest.$ac_ext <<_ACEOF
6613	>	/* end confdefs.h.  */
6614	>
6615	>
6616	>	#ifdef FC_DUMMY_MAIN
6617	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6618	>	#  ifdef __cplusplus
6619	>	extern "C"
6620	>	#  endif
6621	>	int FC_DUMMY_MAIN() { return 1; }
6622	>	#endif
6623	>	#endif
6624	>	int
6625	>	main ()
6626	>	{
6627	>	main ();
6628	>	;
6629	>	return 0;
6630	>	}
6631	>	_ACEOF
6632	>	rm -f conftest.$ac_objext conftest$ac_exeext
6633	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634	>	(eval $ac_link) 2>conftest.er1
6635	>	ac_status=$?
6636	>	grep -v '^ *+' conftest.er1 >conftest.err
6637	>	rm -f conftest.er1
6638	>	cat conftest.err >&5
6639	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640	>	(exit $ac_status); } &&
6641	>	{ ac_try='test -z "$ac_c_werror_flag"
6642	>	|| test ! -s conftest.err'
6643	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644	>	(eval $ac_try) 2>&5
6645	>	ac_status=$?
6646	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647	>	(exit $ac_status); }; } &&
6648	>	{ ac_try='test -s conftest$ac_exeext'
6649	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650	>	(eval $ac_try) 2>&5
6651	>	ac_status=$?
6652	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653	>	(exit $ac_status); }; }; then
6654	>	:
6655	>	else
6656	>	echo "$as_me: failed program was:" >&5
6657	>	sed 's/^/| /' conftest.$ac_ext >&5
6658	>
6659	>	fi
6660	>	rm -f conftest.err conftest.$ac_objext \
6661	>	conftest$ac_exeext conftest.$ac_ext
6662	>	else
6663	>	echo "$as_me: failed program was:" >&5
6664	>	sed 's/^/| /' conftest.$ac_ext >&5
6665	>
6666	>
6667	>	echo "$as_me:$LINENO: result: no" >&5
6668	>	echo "${ECHO_T}no" >&6
6669	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673	>	{ (exit 1); exit 1; }; }
6674	>
6675	>	fi
6676	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677	>
6678	>	fi
6679	>
6680	>
6681	>
6682	>	if test "$with_mpi" = "yes"; then
6683	>
6684	>	if test -z "$ac_fftw_firstname"; then
6685	>
6686	>	sizeof_real=$sizeof_real
6687	>	if test $sizeof_real = 8; then
6688	>	prec="double"
6689	>	fftwcheckprefix=d
6690	>	else
6691	>	prec="single"
6692	>	fftwcheckprefix=s
6693	>	fi
6694	>
6695	>	xfftwname=${fftwcheckprefix}fftw3_mpi
6696	>
6697	>	ok="no"
6698	>	# check header doesn't work, since we must use mpicc to get includes,
6699	>	# we cant trust cpp.
6700	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702	>	cat >conftest.$ac_ext <<_ACEOF
6703	>	/* confdefs.h.  */
6704	>	_ACEOF
6705	>	cat confdefs.h >>conftest.$ac_ext
6706	>	cat >>conftest.$ac_ext <<_ACEOF
6707	>	/* end confdefs.h.  */
6708	>	#include <$xfftwname.h>
6709	>	#ifdef FC_DUMMY_MAIN
6710	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6711	>	#  ifdef __cplusplus
6712	>	extern "C"
6713	>	#  endif
6714	>	int FC_DUMMY_MAIN() { return 1; }
6715	>	#endif
6716	>	#endif
6717	>	int
6718	>	main ()
6719	>	{
6720	>
6721	>	;
6722	>	return 0;
6723	>	}
6724	>	_ACEOF
6725	>	rm -f conftest.$ac_objext
6726	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727	>	(eval $ac_compile) 2>conftest.er1
6728	>	ac_status=$?
6729	>	grep -v '^ *+' conftest.er1 >conftest.err
6730	>	rm -f conftest.er1
6731	>	cat conftest.err >&5
6732	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733	>	(exit $ac_status); } &&
6734	>	{ ac_try='test -z "$ac_c_werror_flag"
6735	>	|| test ! -s conftest.err'
6736	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737	>	(eval $ac_try) 2>&5
6738	>	ac_status=$?
6739	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740	>	(exit $ac_status); }; } &&
6741	>	{ ac_try='test -s conftest.$ac_objext'
6742	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743	>	(eval $ac_try) 2>&5
6744	>	ac_status=$?
6745	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746	>	(exit $ac_status); }; }; then
6747	>
6748	>	fftwname=$xfftwname
6749	>	echo "$as_me:$LINENO: result: yes" >&5
6750	>	echo "${ECHO_T}yes" >&6
6751	>
6752	>	else
6753	>	echo "$as_me: failed program was:" >&5
6754	>	sed 's/^/| /' conftest.$ac_ext >&5
6755	>
6756	>	echo "$as_me:$LINENO: result: no" >&5
6757	>	echo "${ECHO_T}no" >&6
6758	>	fi
6759	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760	>
6761	>	# fftwname was set if we found a header
6762	>
6763	>	if test -n "$fftwname"; then
6764	>	# we cannot run the code since an MPI program might not be allowed
6765	>	# on a login node of a supercomputer
6766	>	cat >conftest.$ac_ext <<_ACEOF
6767	>	/* confdefs.h.  */
6768	>	_ACEOF
6769	>	cat confdefs.h >>conftest.$ac_ext
6770	>	cat >>conftest.$ac_ext <<_ACEOF
6771	>	/* end confdefs.h.  */
6772	>	#include <$fftwname.h>
6773	>	#ifdef FC_DUMMY_MAIN
6774	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6775	>	#  ifdef __cplusplus
6776	>	extern "C"
6777	>	#  endif
6778	>	int FC_DUMMY_MAIN() { return 1; }
6779	>	#endif
6780	>	#endif
6781	>	int
6782	>	main ()
6783	>	{
6784	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785	>	;
6786	>	return 0;
6787	>	}
6788	>	_ACEOF
6789	>	rm -f conftest.$ac_objext
6790	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791	>	(eval $ac_compile) 2>conftest.er1
6792	>	ac_status=$?
6793	>	grep -v '^ *+' conftest.er1 >conftest.err
6794	>	rm -f conftest.er1
6795	>	cat conftest.err >&5
6796	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797	>	(exit $ac_status); } &&
6798	>	{ ac_try='test -z "$ac_c_werror_flag"
6799	>	|| test ! -s conftest.err'
6800	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801	>	(eval $ac_try) 2>&5
6802	>	ac_status=$?
6803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804	>	(exit $ac_status); }; } &&
6805	>	{ ac_try='test -s conftest.$ac_objext'
6806	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807	>	(eval $ac_try) 2>&5
6808	>	ac_status=$?
6809	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810	>	(exit $ac_status); }; }; then
6811	>
6812	>	ok=yes
6813	>	usedprefix=$fftwcheckprefix
6814	>
6815	>	else
6816	>	echo "$as_me: failed program was:" >&5
6817	>	sed 's/^/| /' conftest.$ac_ext >&5
6818	>
6819	>	ok=no
6820	>	fi
6821	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822	>	fi
6823	>
6824	>	if test "$ok" != "yes"; then
6825	>	echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826	>	echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827	>	cat >conftest.$ac_ext <<_ACEOF
6828	>	/* confdefs.h.  */
6829	>	_ACEOF
6830	>	cat confdefs.h >>conftest.$ac_ext
6831	>	cat >>conftest.$ac_ext <<_ACEOF
6832	>	/* end confdefs.h.  */
6833	>	#include <fftw3_mpi.h>
6834	>	#ifdef FC_DUMMY_MAIN
6835	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6836	>	#  ifdef __cplusplus
6837	>	extern "C"
6838	>	#  endif
6839	>	int FC_DUMMY_MAIN() { return 1; }
6840	>	#endif
6841	>	#endif
6842	>	int
6843	>	main ()
6844	>	{
6845	>
6846	>	;
6847	>	return 0;
6848	>	}
6849	>	_ACEOF
6850	>	rm -f conftest.$ac_objext
6851	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852	>	(eval $ac_compile) 2>conftest.er1
6853	>	ac_status=$?
6854	>	grep -v '^ *+' conftest.er1 >conftest.err
6855	>	rm -f conftest.er1
6856	>	cat conftest.err >&5
6857	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858	>	(exit $ac_status); } &&
6859	>	{ ac_try='test -z "$ac_c_werror_flag"
6860	>	|| test ! -s conftest.err'
6861	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862	>	(eval $ac_try) 2>&5
6863	>	ac_status=$?
6864	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865	>	(exit $ac_status); }; } &&
6866	>	{ ac_try='test -s conftest.$ac_objext'
6867	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868	>	(eval $ac_try) 2>&5
6869	>	ac_status=$?
6870	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871	>	(exit $ac_status); }; }; then
6872	>	echo "$as_me:$LINENO: result: yes" >&5
6873	>	echo "${ECHO_T}yes" >&6
6874	>	else
6875	>	echo "$as_me: failed program was:" >&5
6876	>	sed 's/^/| /' conftest.$ac_ext >&5
6877	>
6878	>
6879	>	echo "$as_me:$LINENO: result: no" >&5
6880	>	echo "${ECHO_T}no" >&6
6881	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882	>	Do you have $prec precision FFTW installed? If you are using packages,
6883	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884	>	software at www.fftw.org.
6885	>	If you compiled FFTW yourself:
6886	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6887	>	use --with-mpi. It is a good idea to install both single & double.
6888	>	If you have installed FFTW in a non-standard location, you should
6889	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890	>	variables before running configure.
6891	>	That is also necessary to do if your compiler doesn't search
6892	>	/usr/local/include and /usr/local/lib by default." >&5
6893	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894	>	Do you have $prec precision FFTW installed? If you are using packages,
6895	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896	>	software at www.fftw.org.
6897	>	If you compiled FFTW yourself:
6898	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6899	>	use --with-mpi. It is a good idea to install both single & double.
6900	>	If you have installed FFTW in a non-standard location, you should
6901	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902	>	variables before running configure.
6903	>	That is also necessary to do if your compiler doesn't search
6904	>	/usr/local/include and /usr/local/lib by default." >&2;}
6905	>	{ (exit 1); exit 1; }; }
6906	>
6907	>	fi
6908	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909	>	cat >conftest.$ac_ext <<_ACEOF
6910	>	/* confdefs.h.  */
6911	>	_ACEOF
6912	>	cat confdefs.h >>conftest.$ac_ext
6913	>	cat >>conftest.$ac_ext <<_ACEOF
6914	>	/* end confdefs.h.  */
6915	>	#include <fftw3_mpi.h>
6916	>	#ifdef FC_DUMMY_MAIN
6917	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6918	>	#  ifdef __cplusplus
6919	>	extern "C"
6920	>	#  endif
6921	>	int FC_DUMMY_MAIN() { return 1; }
6922	>	#endif
6923	>	#endif
6924	>	int
6925	>	main ()
6926	>	{
6927	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928	>	;
6929	>	return 0;
6930	>	}
6931	>	_ACEOF
6932	>	rm -f conftest.$ac_objext
6933	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934	>	(eval $ac_compile) 2>conftest.er1
6935	>	ac_status=$?
6936	>	grep -v '^ *+' conftest.er1 >conftest.err
6937	>	rm -f conftest.er1
6938	>	cat conftest.err >&5
6939	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940	>	(exit $ac_status); } &&
6941	>	{ ac_try='test -z "$ac_c_werror_flag"
6942	>	|| test ! -s conftest.err'
6943	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944	>	(eval $ac_try) 2>&5
6945	>	ac_status=$?
6946	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947	>	(exit $ac_status); }; } &&
6948	>	{ ac_try='test -s conftest.$ac_objext'
6949	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950	>	(eval $ac_try) 2>&5
6951	>	ac_status=$?
6952	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953	>	(exit $ac_status); }; }; then
6954	>
6955	>	usedprefix=""
6956	>	fftwname=fftw3_mpi
6957	>
6958	>	else
6959	>	echo "$as_me: failed program was:" >&5
6960	>	sed 's/^/| /' conftest.$ac_ext >&5
6961	>
6962	>
6963	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964	>	Do you have $prec precision FFTW installed? If you are using packages,
6965	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966	>	software at www.fftw.org.
6967	>	If you compiled FFTW yourself:
6968	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6969	>	use --with-mpi. It is a good idea to install both single & double.
6970	>	If you have installed FFTW in a non-standard location, you should
6971	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972	>	variables before running configure.
6973	>	That is also necessary to do if your compiler doesn't search
6974	>	/usr/local/include and /usr/local/lib by default." >&5
6975	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976	>	Do you have $prec precision FFTW installed? If you are using packages,
6977	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978	>	software at www.fftw.org.
6979	>	If you compiled FFTW yourself:
6980	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6981	>	use --with-mpi. It is a good idea to install both single & double.
6982	>	If you have installed FFTW in a non-standard location, you should
6983	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984	>	variables before running configure.
6985	>	That is also necessary to do if your compiler doesn't search
6986	>	/usr/local/include and /usr/local/lib by default." >&2;}
6987	>	{ (exit 1); exit 1; }; }
6988	>	fi
6989	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990	>	fi
6991	>
6992	>
6993	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6998	>	else
6999	>	ac_check_lib_save_LIBS=$LIBS
7000	>	LIBS="-l$fftwname  $LIBS"
7001	>	cat >conftest.$ac_ext <<_ACEOF
7002	>	/* confdefs.h.  */
7003	>	_ACEOF
7004	>	cat confdefs.h >>conftest.$ac_ext
7005	>	cat >>conftest.$ac_ext <<_ACEOF
7006	>	/* end confdefs.h.  */
7007	>
7008	>
7009	>	#ifdef FC_DUMMY_MAIN
7010	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7011	>	#  ifdef __cplusplus
7012	>	extern "C"
7013	>	#  endif
7014	>	int FC_DUMMY_MAIN() { return 1; }
7015	>	#endif
7016	>	#endif
7017	>	int
7018	>	main ()
7019	>	{
7020	>	main ();
7021	>	;
7022	>	return 0;
7023	>	}
7024	>	_ACEOF
7025	>	rm -f conftest.$ac_objext conftest$ac_exeext
7026	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027	>	(eval $ac_link) 2>conftest.er1
7028	>	ac_status=$?
7029	>	grep -v '^ *+' conftest.er1 >conftest.err
7030	>	rm -f conftest.er1
7031	>	cat conftest.err >&5
7032	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033	>	(exit $ac_status); } &&
7034	>	{ ac_try='test -z "$ac_c_werror_flag"
7035	>	|| test ! -s conftest.err'
7036	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037	>	(eval $ac_try) 2>&5
7038	>	ac_status=$?
7039	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040	>	(exit $ac_status); }; } &&
7041	>	{ ac_try='test -s conftest$ac_exeext'
7042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043	>	(eval $ac_try) 2>&5
7044	>	ac_status=$?
7045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046	>	(exit $ac_status); }; }; then
7047	>	eval "$as_ac_Lib=yes"
7048	>	else
7049	>	echo "$as_me: failed program was:" >&5
7050	>	sed 's/^/| /' conftest.$ac_ext >&5
7051	>
7052	>	eval "$as_ac_Lib=no"
7053	>	fi
7054	>	rm -f conftest.err conftest.$ac_objext \
7055	>	conftest$ac_exeext conftest.$ac_ext
7056	>	LIBS=$ac_check_lib_save_LIBS
7057	>	fi
7058	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061	>	cat >>confdefs.h <<_ACEOF
7062	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063	>	_ACEOF
7064	>
7065	>	LIBS="-l$fftwname $LIBS"
7066	>
7067	>	else
7068	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070	>	{ (exit 1); exit 1; }; }
7071	>	fi
7072	>
7073	>	ac_fftw_savedprefix=$usedprefix
7074	>	ac_fftw_firstname=$fftwname
7075	>
7076	>	else
7077	>
7078	>	fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081	>	cat >conftest.$ac_ext <<_ACEOF
7082	>	/* confdefs.h.  */
7083	>	_ACEOF
7084	>	cat confdefs.h >>conftest.$ac_ext
7085	>	cat >>conftest.$ac_ext <<_ACEOF
7086	>	/* end confdefs.h.  */
7087	>	#include <$fftwname.h>
7088	>	#ifdef FC_DUMMY_MAIN
7089	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7090	>	#  ifdef __cplusplus
7091	>	extern "C"
7092	>	#  endif
7093	>	int FC_DUMMY_MAIN() { return 1; }
7094	>	#endif
7095	>	#endif
7096	>	int
7097	>	main ()
7098	>	{
7099	>
7100	>	;
7101	>	return 0;
7102	>	}
7103	>	_ACEOF
7104	>	rm -f conftest.$ac_objext
7105	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106	>	(eval $ac_compile) 2>conftest.er1
7107	>	ac_status=$?
7108	>	grep -v '^ *+' conftest.er1 >conftest.err
7109	>	rm -f conftest.er1
7110	>	cat conftest.err >&5
7111	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112	>	(exit $ac_status); } &&
7113	>	{ ac_try='test -z "$ac_c_werror_flag"
7114	>	|| test ! -s conftest.err'
7115	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116	>	(eval $ac_try) 2>&5
7117	>	ac_status=$?
7118	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119	>	(exit $ac_status); }; } &&
7120	>	{ ac_try='test -s conftest.$ac_objext'
7121	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122	>	(eval $ac_try) 2>&5
7123	>	ac_status=$?
7124	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125	>	(exit $ac_status); }; }; then
7126	>	echo "$as_me:$LINENO: result: yes" >&5
7127	>	echo "${ECHO_T}yes" >&6
7128	>	LIBS="-l$fftwname $LIBS"
7129	>	cat >conftest.$ac_ext <<_ACEOF
7130	>	/* confdefs.h.  */
7131	>	_ACEOF
7132	>	cat confdefs.h >>conftest.$ac_ext
7133	>	cat >>conftest.$ac_ext <<_ACEOF
7134	>	/* end confdefs.h.  */
7135	>
7136	>
7137	>	#ifdef FC_DUMMY_MAIN
7138	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7139	>	#  ifdef __cplusplus
7140	>	extern "C"
7141	>	#  endif
7142	>	int FC_DUMMY_MAIN() { return 1; }
7143	>	#endif
7144	>	#endif
7145	>	int
7146	>	main ()
7147	>	{
7148	>	main ();
7149	>	;
7150	>	return 0;
7151	>	}
7152	>	_ACEOF
7153	>	rm -f conftest.$ac_objext conftest$ac_exeext
7154	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155	>	(eval $ac_link) 2>conftest.er1
7156	>	ac_status=$?
7157	>	grep -v '^ *+' conftest.er1 >conftest.err
7158	>	rm -f conftest.er1
7159	>	cat conftest.err >&5
7160	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161	>	(exit $ac_status); } &&
7162	>	{ ac_try='test -z "$ac_c_werror_flag"
7163	>	|| test ! -s conftest.err'
7164	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165	>	(eval $ac_try) 2>&5
7166	>	ac_status=$?
7167	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168	>	(exit $ac_status); }; } &&
7169	>	{ ac_try='test -s conftest$ac_exeext'
7170	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171	>	(eval $ac_try) 2>&5
7172	>	ac_status=$?
7173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174	>	(exit $ac_status); }; }; then
7175	>	:
7176	>	else
7177	>	echo "$as_me: failed program was:" >&5
7178	>	sed 's/^/| /' conftest.$ac_ext >&5
7179	>
7180	>	fi
7181	>	rm -f conftest.err conftest.$ac_objext \
7182	>	conftest$ac_exeext conftest.$ac_ext
7183	>	else
7184	>	echo "$as_me: failed program was:" >&5
7185	>	sed 's/^/| /' conftest.$ac_ext >&5
7186	>
7187	>
7188	>	echo "$as_me:$LINENO: result: no" >&5
7189	>	echo "${ECHO_T}no" >&6
7190	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194	>	{ (exit 1); exit 1; }; }
7195	>
7196	>	fi
7197	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198	>
7199	>	fi
7200	>
7201	>
7202	>	fi
7203	>
7204	>	case ${ac_fftw_savedprefix} in
7205	>	d)
7206	>	cat >>confdefs.h <<\_ACEOF
7207	>	#define FFTW_NAME_DFFTW
7208	>	_ACEOF
7209	>	;;
7210	>	*)
7211	>	cat >>confdefs.h <<\_ACEOF
7212	>	#define FFTW_NAME_FFTW
7213	>	_ACEOF
7214	>	;;
7215	>	esac
7216	>	else
7217	>	echo "*******************************************************************"
7218	>	echo "* FFTW libraries and include files are required for computing     *"
7219	>	echo "* undulation spectra with the staticProps program.  If you don't  *"
7220	>	echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221	>	echo "* analyze your trajectories for this property.                    *"
7222	>	echo "*******************************************************************"
7223	>	fi # end of fftw check
7224	>
7225	>	# Checks for header files.
7226	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228	>	if test "${ac_cv_header_stdc+set}" = set; then
7229	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7230	>	else
7231	>	cat >conftest.$ac_ext <<_ACEOF
7232	>	/* confdefs.h.  */
7233	>	_ACEOF
7234	>	cat confdefs.h >>conftest.$ac_ext
7235	>	cat >>conftest.$ac_ext <<_ACEOF
7236	>	/* end confdefs.h.  */
7237	>	#include <stdlib.h>
7238	>	#include <stdarg.h>
7239	>	#include <string.h>
7240	>	#include <float.h>
7241	>
7242	>	#ifdef FC_DUMMY_MAIN
7243	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7244	>	#  ifdef __cplusplus
7245	>	extern "C"
7246	>	#  endif
7247	>	int FC_DUMMY_MAIN() { return 1; }
7248	>	#endif
7249	>	#endif
7250	>	int
7251	>	main ()
7252	>	{
7253	>
7254	>	;
7255	>	return 0;
7256	>	}
7257	>	_ACEOF
7258	>	rm -f conftest.$ac_objext
7259	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260	>	(eval $ac_compile) 2>conftest.er1
7261	>	ac_status=$?
7262	>	grep -v '^ *+' conftest.er1 >conftest.err
7263	>	rm -f conftest.er1
7264	>	cat conftest.err >&5
7265	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266	>	(exit $ac_status); } &&
7267	>	{ ac_try='test -z "$ac_c_werror_flag"
7268	>	|| test ! -s conftest.err'
7269	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270	>	(eval $ac_try) 2>&5
7271	>	ac_status=$?
7272	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273	>	(exit $ac_status); }; } &&
7274	>	{ ac_try='test -s conftest.$ac_objext'
7275	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276	>	(eval $ac_try) 2>&5
7277	>	ac_status=$?
7278	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279	>	(exit $ac_status); }; }; then
7280	>	ac_cv_header_stdc=yes
7281	>	else
7282	>	echo "$as_me: failed program was:" >&5
7283	>	sed 's/^/| /' conftest.$ac_ext >&5
7284	>
7285	>	ac_cv_header_stdc=no
7286	>	fi
7287	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288	>
7289	>	if test $ac_cv_header_stdc = yes; then
7290	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291	>	cat >conftest.$ac_ext <<_ACEOF
7292	>	/* confdefs.h.  */
7293	>	_ACEOF
7294	>	cat confdefs.h >>conftest.$ac_ext
7295	>	cat >>conftest.$ac_ext <<_ACEOF
7296	>	/* end confdefs.h.  */
7297	>	#include <string.h>
7298	>
7299	>	_ACEOF
7300	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301	>	$EGREP "memchr" >/dev/null 2>&1; then
7302	>	:
7303	>	else
7304	>	ac_cv_header_stdc=no
7305	>	fi
7306	>	rm -f conftest*
7307	>
7308	>	fi
7309	>
7310	>	if test $ac_cv_header_stdc = yes; then
7311	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312	>	cat >conftest.$ac_ext <<_ACEOF
7313	>	/* confdefs.h.  */
7314	>	_ACEOF
7315	>	cat confdefs.h >>conftest.$ac_ext
7316	>	cat >>conftest.$ac_ext <<_ACEOF
7317	>	/* end confdefs.h.  */
7318	>	#include <stdlib.h>
7319	>
7320	>	_ACEOF
7321	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322	>	$EGREP "free" >/dev/null 2>&1; then
7323	>	:
7324	>	else
7325	>	ac_cv_header_stdc=no
7326	>	fi
7327	>	rm -f conftest*
7328	>
7329	>	fi
7330	>
7331	>	if test $ac_cv_header_stdc = yes; then
7332	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333	>	if test "$cross_compiling" = yes; then
7334	>	:
7335	>	else
7336	>	cat >conftest.$ac_ext <<_ACEOF
7337	>	/* confdefs.h.  */
7338	>	_ACEOF
7339	>	cat confdefs.h >>conftest.$ac_ext
7340	>	cat >>conftest.$ac_ext <<_ACEOF
7341	>	/* end confdefs.h.  */
7342	>	#include <ctype.h>
7343	>	#if ((' ' & 0x0FF) == 0x020)
7344	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346	>	#else
7347	>	# define ISLOWER(c) \
7348	>	(('a' <= (c) && (c) <= 'i') \
7349	>	|| ('j' <= (c) && (c) <= 'r') \
7350	>	|| ('s' <= (c) && (c) <= 'z'))
7351	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352	>	#endif
7353	>
7354	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355	>	int
7356	>	main ()
7357	>	{
7358	>	int i;
7359	>	for (i = 0; i < 256; i++)
7360	>	if (XOR (islower (i), ISLOWER (i))
7361	>	|| toupper (i) != TOUPPER (i))
7362	>	exit(2);
7363	>	exit (0);
7364	>	}
7365	>	_ACEOF
7366	>	rm -f conftest$ac_exeext
7367	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368	>	(eval $ac_link) 2>&5
7369	>	ac_status=$?
7370	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373	>	(eval $ac_try) 2>&5
7374	>	ac_status=$?
7375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376	>	(exit $ac_status); }; }; then
7377	>	:
7378	>	else
7379	>	echo "$as_me: program exited with status $ac_status" >&5
7380	>	echo "$as_me: failed program was:" >&5
7381	>	sed 's/^/| /' conftest.$ac_ext >&5
7382	>
7383	>	( exit $ac_status )
7384	>	ac_cv_header_stdc=no
7385	>	fi
7386	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387	>	fi
7388	>	fi
7389	>	fi
7390	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392	>	if test $ac_cv_header_stdc = yes; then
7393	>
7394	>	cat >>confdefs.h <<\_ACEOF
7395	>	#define STDC_HEADERS 1
7396	>	_ACEOF
7397	>
7398	>	fi
7399	>
7400	>
7401	>
7402	>
7403	>
7404	>
7405	>
7406	>
7407	>
7408	>
7409	>
7410	>
7411	>
7412	>
7413	>
7414	>
7415	>
7416	>
7417	>
7418	>
7419	>
7420	>
7421	>
7422	>
7423	>
7424	>
7425	>	for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7426	>	do
7427	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7430	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7433	>	fi
7434	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436	>	else
7437	>	# Is the header compilable?
7438	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440	>	cat >conftest.$ac_ext <<_ACEOF
7441	>	/* confdefs.h.  */
7442	>	_ACEOF
7443	>	cat confdefs.h >>conftest.$ac_ext
7444	>	cat >>conftest.$ac_ext <<_ACEOF
7445	>	/* end confdefs.h.  */
7446	>	$ac_includes_default
7447	>	#include <$ac_header>
7448	>	_ACEOF
7449	>	rm -f conftest.$ac_objext
7450	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451	>	(eval $ac_compile) 2>conftest.er1
7452	>	ac_status=$?
7453	>	grep -v '^ *+' conftest.er1 >conftest.err
7454	>	rm -f conftest.er1
7455	>	cat conftest.err >&5
7456	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457	>	(exit $ac_status); } &&
7458	>	{ ac_try='test -z "$ac_c_werror_flag"
7459	>	|| test ! -s conftest.err'
7460	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461	>	(eval $ac_try) 2>&5
7462	>	ac_status=$?
7463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464	>	(exit $ac_status); }; } &&
7465	>	{ ac_try='test -s conftest.$ac_objext'
7466	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467	>	(eval $ac_try) 2>&5
7468	>	ac_status=$?
7469	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470	>	(exit $ac_status); }; }; then
7471	>	ac_header_compiler=yes
7472	>	else
7473	>	echo "$as_me: failed program was:" >&5
7474	>	sed 's/^/| /' conftest.$ac_ext >&5
7475	>
7476	>	ac_header_compiler=no
7477	>	fi
7478	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480	>	echo "${ECHO_T}$ac_header_compiler" >&6
7481	>
7482	>	# Is the header present?
7483	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485	>	cat >conftest.$ac_ext <<_ACEOF
7486	>	/* confdefs.h.  */
7487	>	_ACEOF
7488	>	cat confdefs.h >>conftest.$ac_ext
7489	>	cat >>conftest.$ac_ext <<_ACEOF
7490	>	/* end confdefs.h.  */
7491	>	#include <$ac_header>
7492	>	_ACEOF
7493	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495	>	ac_status=$?
7496	>	grep -v '^ *+' conftest.er1 >conftest.err
7497	>	rm -f conftest.er1
7498	>	cat conftest.err >&5
7499	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500	>	(exit $ac_status); } >/dev/null; then
7501	>	if test -s conftest.err; then
7502	>	ac_cpp_err=$ac_c_preproc_warn_flag
7503	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504	>	else
7505	>	ac_cpp_err=
7506	>	fi
7507	>	else
7508	>	ac_cpp_err=yes
7509	>	fi
7510	>	if test -z "$ac_cpp_err"; then
7511	>	ac_header_preproc=yes
7512	>	else
7513	>	echo "$as_me: failed program was:" >&5
7514	>	sed 's/^/| /' conftest.$ac_ext >&5
7515	>
7516	>	ac_header_preproc=no
7517	>	fi
7518	>	rm -f conftest.err conftest.$ac_ext
7519	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520	>	echo "${ECHO_T}$ac_header_preproc" >&6
7521	>
7522	>	# So?  What about this header?
7523	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524	>	yes:no: )
7525	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529	>	ac_header_preproc=yes
7530	>	;;
7531	>	no:yes:* )
7532	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544	>	(
7545	>	cat <<\_ASBOX
7546	>	## ------------------------------ ##
7547	>	## Report this to gezelter@nd.edu ##
7548	>	## ------------------------------ ##
7549	>	_ASBOX
7550	>	) |
7551	>	sed "s/^/$as_me: WARNING:     /" >&2
7552	>	;;
7553	>	esac
7554	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7555	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7558	>	else
7559	>	eval "$as_ac_Header=\$ac_header_preproc"
7560	>	fi
7561	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563	>
7564	>	fi
7565	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566	>	cat >>confdefs.h <<_ACEOF
7567	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568	>	_ACEOF
7569	>
7570	>	fi
7571	>
7572	>	done
7573	>
7574	>
7575	>	# Checks for typedefs, structures, and compiler characteristics.
7576	>	echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577	>	echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578	>	if test "${ac_cv_header_stdbool_h+set}" = set; then
7579	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7580	>	else
7581	>	cat >conftest.$ac_ext <<_ACEOF
7582	>	/* confdefs.h.  */
7583	>	_ACEOF
7584	>	cat confdefs.h >>conftest.$ac_ext
7585	>	cat >>conftest.$ac_ext <<_ACEOF
7586	>	/* end confdefs.h.  */
7587	>
7588	>	#include <stdbool.h>
7589	>	#ifndef bool
7590	>	# error bool is not defined
7591	>	#endif
7592	>	#ifndef false
7593	>	# error false is not defined
7594	>	#endif
7595	>	#if false
7596	>	# error false is not 0
7597	>	#endif
7598	>	#ifndef true
7599	>	# error true is not defined
7600	>	#endif
7601	>	#if true != 1
7602	>	# error true is not 1
7603	>	#endif
7604	>	#ifndef __bool_true_false_are_defined
7605	>	# error __bool_true_false_are_defined is not defined
7606	>	#endif
7607	>
7608	>	struct s { _Bool s: 1; _Bool t; } s;
7609	>
7610	>	char a[true == 1 ? 1 : -1];
7611	>	char b[false == 0 ? 1 : -1];
7612	>	char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613	>	char d[(bool) -0.5 == true ? 1 : -1];
7614	>	bool e = &s;
7615	>	char f[(_Bool) -0.0 == false ? 1 : -1];
7616	>	char g[true];
7617	>	char h[sizeof (_Bool)];
7618	>	char i[sizeof s.t];
7619	>
7620	>	#ifdef FC_DUMMY_MAIN
7621	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7622	>	#  ifdef __cplusplus
7623	>	extern "C"
7624	>	#  endif
7625	>	int FC_DUMMY_MAIN() { return 1; }
7626	>	#endif
7627	>	#endif
7628	>	int
7629	>	main ()
7630	>	{
7631	>	return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632	>	;
7633	>	return 0;
7634	>	}
7635	>	_ACEOF
7636	>	rm -f conftest.$ac_objext
7637	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638	>	(eval $ac_compile) 2>conftest.er1
7639	>	ac_status=$?
7640	>	grep -v '^ *+' conftest.er1 >conftest.err
7641	>	rm -f conftest.er1
7642	>	cat conftest.err >&5
7643	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644	>	(exit $ac_status); } &&
7645	>	{ ac_try='test -z "$ac_c_werror_flag"
7646	>	|| test ! -s conftest.err'
7647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648	>	(eval $ac_try) 2>&5
7649	>	ac_status=$?
7650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651	>	(exit $ac_status); }; } &&
7652	>	{ ac_try='test -s conftest.$ac_objext'
7653	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654	>	(eval $ac_try) 2>&5
7655	>	ac_status=$?
7656	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657	>	(exit $ac_status); }; }; then
7658	>	ac_cv_header_stdbool_h=yes
7659	>	else
7660	>	echo "$as_me: failed program was:" >&5
7661	>	sed 's/^/| /' conftest.$ac_ext >&5
7662	>
7663	>	ac_cv_header_stdbool_h=no
7664	>	fi
7665	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666	>	fi
7667	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668	>	echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669	>	echo "$as_me:$LINENO: checking for _Bool" >&5
7670	>	echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671	>	if test "${ac_cv_type__Bool+set}" = set; then
7672	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7673	>	else
7674	>	cat >conftest.$ac_ext <<_ACEOF
7675	>	/* confdefs.h.  */
7676	>	_ACEOF
7677	>	cat confdefs.h >>conftest.$ac_ext
7678	>	cat >>conftest.$ac_ext <<_ACEOF
7679	>	/* end confdefs.h.  */
7680	>	$ac_includes_default
7681	>	#ifdef FC_DUMMY_MAIN
7682	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7683	>	#  ifdef __cplusplus
7684	>	extern "C"
7685	>	#  endif
7686	>	int FC_DUMMY_MAIN() { return 1; }
7687	>	#endif
7688	>	#endif
7689	>	int
7690	>	main ()
7691	>	{
7692	>	if ((_Bool *) 0)
7693	>	return 0;
7694	>	if (sizeof (_Bool))
7695	>	return 0;
7696	>	;
7697	>	return 0;
7698	>	}
7699	>	_ACEOF
7700	>	rm -f conftest.$ac_objext
7701	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702	>	(eval $ac_compile) 2>conftest.er1
7703	>	ac_status=$?
7704	>	grep -v '^ *+' conftest.er1 >conftest.err
7705	>	rm -f conftest.er1
7706	>	cat conftest.err >&5
7707	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708	>	(exit $ac_status); } &&
7709	>	{ ac_try='test -z "$ac_c_werror_flag"
7710	>	|| test ! -s conftest.err'
7711	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712	>	(eval $ac_try) 2>&5
7713	>	ac_status=$?
7714	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715	>	(exit $ac_status); }; } &&
7716	>	{ ac_try='test -s conftest.$ac_objext'
7717	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718	>	(eval $ac_try) 2>&5
7719	>	ac_status=$?
7720	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721	>	(exit $ac_status); }; }; then
7722	>	ac_cv_type__Bool=yes
7723	>	else
7724	>	echo "$as_me: failed program was:" >&5
7725	>	sed 's/^/| /' conftest.$ac_ext >&5
7726	>
7727	>	ac_cv_type__Bool=no
7728	>	fi
7729	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730	>	fi
7731	>	echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732	>	echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733	>	if test $ac_cv_type__Bool = yes; then
7734	>
7735	>	cat >>confdefs.h <<_ACEOF
7736	>	#define HAVE__BOOL 1
7737	>	_ACEOF
7738	>
7739	>
7740	>	fi
7741	>
7742	>	if test $ac_cv_header_stdbool_h = yes; then
7743	>
7744	>	cat >>confdefs.h <<\_ACEOF
7745	>	#define HAVE_STDBOOL_H 1
7746	>	_ACEOF
7747	>
7748	>	fi
7749	>
7750	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752	>	if test "${ac_cv_c_const+set}" = set; then
7753	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7754	>	else
7755	>	cat >conftest.$ac_ext <<_ACEOF
7756	>	/* confdefs.h.  */
7757	>	_ACEOF
7758	>	cat confdefs.h >>conftest.$ac_ext
7759	>	cat >>conftest.$ac_ext <<_ACEOF
7760	>	/* end confdefs.h.  */
7761	>
7762	>	#ifdef FC_DUMMY_MAIN
7763	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7764	>	#  ifdef __cplusplus
7765	>	extern "C"
7766	>	#  endif
7767	>	int FC_DUMMY_MAIN() { return 1; }
7768	>	#endif
7769	>	#endif
7770	>	int
7771	>	main ()
7772	>	{
7773	>	/* FIXME: Include the comments suggested by Paul. */
7774	>	#ifndef __cplusplus
7775	>	/* Ultrix mips cc rejects this.  */
7776	>	typedef int charset[2];
7777	>	const charset x;
7778	>	/* SunOS 4.1.1 cc rejects this.  */
7779	>	char const *const *ccp;
7780	>	char **p;
7781	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7782	>	struct point {int x, y;};
7783	>	static struct point const zero = {0,0};
7784	>	/* AIX XL C 1.02.0.0 rejects this.
7785	>	It does not let you subtract one const X* pointer from another in
7786	>	an arm of an if-expression whose if-part is not a constant
7787	>	expression */
7788	>	const char *g = "string";
7789	>	ccp = &g + (g ? g-g : 0);
7790	>	/* HPUX 7.0 cc rejects these. */
7791	>	++ccp;
7792	>	p = (char**) ccp;
7793	>	ccp = (char const *const *) p;
7794	>	{ /* SCO 3.2v4 cc rejects this.  */
7795	>	char *t;
7796	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7797	>
7798	>	*t++ = 0;
7799	>	}
7800	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801	>	int x[] = {25, 17};
7802	>	const int *foo = &x[0];
7803	>	++foo;
7804	>	}
7805	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806	>	typedef const int *iptr;
7807	>	iptr p = 0;
7808	>	++p;
7809	>	}
7810	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7811	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812	>	struct s { int j; const int *ap[3]; };
7813	>	struct s *b; b->j = 5;
7814	>	}
7815	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816	>	const int foo = 10;
7817	>	}
7818	>	#endif
7819	>
7820	>	;
7821	>	return 0;
7822	>	}
7823	>	_ACEOF
7824	>	rm -f conftest.$ac_objext
7825	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826	>	(eval $ac_compile) 2>conftest.er1
7827	>	ac_status=$?
7828	>	grep -v '^ *+' conftest.er1 >conftest.err
7829	>	rm -f conftest.er1
7830	>	cat conftest.err >&5
7831	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832	>	(exit $ac_status); } &&
7833	>	{ ac_try='test -z "$ac_c_werror_flag"
7834	>	|| test ! -s conftest.err'
7835	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836	>	(eval $ac_try) 2>&5
7837	>	ac_status=$?
7838	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839	>	(exit $ac_status); }; } &&
7840	>	{ ac_try='test -s conftest.$ac_objext'
7841	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842	>	(eval $ac_try) 2>&5
7843	>	ac_status=$?
7844	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845	>	(exit $ac_status); }; }; then
7846	>	ac_cv_c_const=yes
7847	>	else
7848	>	echo "$as_me: failed program was:" >&5
7849	>	sed 's/^/| /' conftest.$ac_ext >&5
7850	>
7851	>	ac_cv_c_const=no
7852	>	fi
7853	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854	>	fi
7855	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856	>	echo "${ECHO_T}$ac_cv_c_const" >&6
7857	>	if test $ac_cv_c_const = no; then
7858	>
7859	>	cat >>confdefs.h <<\_ACEOF
7860	>	#define const
7861	>	_ACEOF
7862	>
7863	>	fi
7864	>
7865	>	echo "$as_me:$LINENO: checking for inline" >&5
7866	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867	>	if test "${ac_cv_c_inline+set}" = set; then
7868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7869	>	else
7870	>	ac_cv_c_inline=no
7871	>	for ac_kw in inline __inline__ __inline; do
7872	>	cat >conftest.$ac_ext <<_ACEOF
7873	>	/* confdefs.h.  */
7874	>	_ACEOF
7875	>	cat confdefs.h >>conftest.$ac_ext
7876	>	cat >>conftest.$ac_ext <<_ACEOF
7877	>	/* end confdefs.h.  */
7878	>	#ifndef __cplusplus
7879	>	typedef int foo_t;
7880	>	static $ac_kw foo_t static_foo () {return 0; }
7881	>	$ac_kw foo_t foo () {return 0; }
7882	>	#endif
7883	>
7884	>	_ACEOF
7885	>	rm -f conftest.$ac_objext
7886	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887	>	(eval $ac_compile) 2>conftest.er1
7888	>	ac_status=$?
7889	>	grep -v '^ *+' conftest.er1 >conftest.err
7890	>	rm -f conftest.er1
7891	>	cat conftest.err >&5
7892	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893	>	(exit $ac_status); } &&
7894	>	{ ac_try='test -z "$ac_c_werror_flag"
7895	>	|| test ! -s conftest.err'
7896	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897	>	(eval $ac_try) 2>&5
7898	>	ac_status=$?
7899	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900	>	(exit $ac_status); }; } &&
7901	>	{ ac_try='test -s conftest.$ac_objext'
7902	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903	>	(eval $ac_try) 2>&5
7904	>	ac_status=$?
7905	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906	>	(exit $ac_status); }; }; then
7907	>	ac_cv_c_inline=$ac_kw; break
7908	>	else
7909	>	echo "$as_me: failed program was:" >&5
7910	>	sed 's/^/| /' conftest.$ac_ext >&5
7911	>
7912	>	fi
7913	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914	>	done
7915	>
7916	>	fi
7917	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
7919	>
7920	>
7921	>	case $ac_cv_c_inline in
7922	>	inline | yes) ;;
7923	>	*)
7924	>	case $ac_cv_c_inline in
7925	>	no) ac_val=;;
7926	>	*) ac_val=$ac_cv_c_inline;;
7927	>	esac
7928	>	cat >>confdefs.h <<_ACEOF
7929	>	#ifndef __cplusplus
7930	>	#define inline $ac_val
7931	>	#endif
7932	>	_ACEOF
7933	>	;;
7934	>	esac
7935	>
7936	>	echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937	>	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938	>	if test "${ac_cv_c_restrict+set}" = set; then
7939	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7940	>	else
7941	>	ac_cv_c_restrict=no
7942	>	# Try the official restrict keyword, then gcc's __restrict, and
7943	>	# the less common variants.
7944	>	for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945	>	cat >conftest.$ac_ext <<_ACEOF
7946	>	/* confdefs.h.  */
7947	>	_ACEOF
7948	>	cat confdefs.h >>conftest.$ac_ext
7949	>	cat >>conftest.$ac_ext <<_ACEOF
7950	>	/* end confdefs.h.  */
7951	>	float * $ac_kw x;
7952	>	_ACEOF
7953	>	rm -f conftest.$ac_objext
7954	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955	>	(eval $ac_compile) 2>conftest.er1
7956	>	ac_status=$?
7957	>	grep -v '^ *+' conftest.er1 >conftest.err
7958	>	rm -f conftest.er1
7959	>	cat conftest.err >&5
7960	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961	>	(exit $ac_status); } &&
7962	>	{ ac_try='test -z "$ac_c_werror_flag"
7963	>	|| test ! -s conftest.err'
7964	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965	>	(eval $ac_try) 2>&5
7966	>	ac_status=$?
7967	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968	>	(exit $ac_status); }; } &&
7969	>	{ ac_try='test -s conftest.$ac_objext'
7970	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971	>	(eval $ac_try) 2>&5
7972	>	ac_status=$?
7973	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974	>	(exit $ac_status); }; }; then
7975	>	ac_cv_c_restrict=$ac_kw; break
7976	>	else
7977	>	echo "$as_me: failed program was:" >&5
7978	>	sed 's/^/| /' conftest.$ac_ext >&5
7979	>
7980	>	fi
7981	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982	>	done
7983	>
7984	>	fi
7985	>	echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986	>	echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987	>	case $ac_cv_c_restrict in
7988	>	restrict) ;;
7989	>	no)
7990	>	cat >>confdefs.h <<\_ACEOF
7991	>	#define restrict
7992	>	_ACEOF
7993	>	;;
7994	>	*)  cat >>confdefs.h <<_ACEOF
7995	>	#define restrict $ac_cv_c_restrict
7996	>	_ACEOF
7997	>	;;
7998	>	esac
7999	>
8000	>	echo "$as_me:$LINENO: checking for size_t" >&5
8001	>	echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002	>	if test "${ac_cv_type_size_t+set}" = set; then
8003	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8004	>	else
8005	>	cat >conftest.$ac_ext <<_ACEOF
8006	>	/* confdefs.h.  */
8007	>	_ACEOF
8008	>	cat confdefs.h >>conftest.$ac_ext
8009	>	cat >>conftest.$ac_ext <<_ACEOF
8010	>	/* end confdefs.h.  */
8011	>	$ac_includes_default
8012	>	#ifdef FC_DUMMY_MAIN
8013	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8014	>	#  ifdef __cplusplus
8015	>	extern "C"
8016	>	#  endif
8017	>	int FC_DUMMY_MAIN() { return 1; }
8018	>	#endif
8019	>	#endif
8020	>	int
8021	>	main ()
8022	>	{
8023	>	if ((size_t *) 0)
8024	>	return 0;
8025	>	if (sizeof (size_t))
8026	>	return 0;
8027	>	;
8028	>	return 0;
8029	>	}
8030	>	_ACEOF
8031	>	rm -f conftest.$ac_objext
8032	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033	>	(eval $ac_compile) 2>conftest.er1
8034	>	ac_status=$?
8035	>	grep -v '^ *+' conftest.er1 >conftest.err
8036	>	rm -f conftest.er1
8037	>	cat conftest.err >&5
8038	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039	>	(exit $ac_status); } &&
8040	>	{ ac_try='test -z "$ac_c_werror_flag"
8041	>	|| test ! -s conftest.err'
8042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043	>	(eval $ac_try) 2>&5
8044	>	ac_status=$?
8045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046	>	(exit $ac_status); }; } &&
8047	>	{ ac_try='test -s conftest.$ac_objext'
8048	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049	>	(eval $ac_try) 2>&5
8050	>	ac_status=$?
8051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052	>	(exit $ac_status); }; }; then
8053	>	ac_cv_type_size_t=yes
8054	>	else
8055	>	echo "$as_me: failed program was:" >&5
8056	>	sed 's/^/| /' conftest.$ac_ext >&5
8057	>
8058	>	ac_cv_type_size_t=no
8059	>	fi
8060	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061	>	fi
8062	>	echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063	>	echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064	>	if test $ac_cv_type_size_t = yes; then
8065	>	:
8066	>	else
8067	>
8068	>	cat >>confdefs.h <<_ACEOF
8069	>	#define size_t unsigned
8070	>	_ACEOF
8071	>
8072	>	fi
8073	>
8074	>	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075	>	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076	>	if test "${ac_cv_header_time+set}" = set; then
8077	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8078	>	else
8079	>	cat >conftest.$ac_ext <<_ACEOF
8080	>	/* confdefs.h.  */
8081	>	_ACEOF
8082	>	cat confdefs.h >>conftest.$ac_ext
8083	>	cat >>conftest.$ac_ext <<_ACEOF
8084	>	/* end confdefs.h.  */
8085	>	#include <sys/types.h>
8086	>	#include <sys/time.h>
8087	>	#include <time.h>
8088	>
8089	>	#ifdef FC_DUMMY_MAIN
8090	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8091	>	#  ifdef __cplusplus
8092	>	extern "C"
8093	>	#  endif
8094	>	int FC_DUMMY_MAIN() { return 1; }
8095	>	#endif
8096	>	#endif
8097	>	int
8098	>	main ()
8099	>	{
8100	>	if ((struct tm *) 0)
8101	>	return 0;
8102	>	;
8103	>	return 0;
8104	>	}
8105	>	_ACEOF
8106	>	rm -f conftest.$ac_objext
8107	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108	>	(eval $ac_compile) 2>conftest.er1
8109	>	ac_status=$?
8110	>	grep -v '^ *+' conftest.er1 >conftest.err
8111	>	rm -f conftest.er1
8112	>	cat conftest.err >&5
8113	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114	>	(exit $ac_status); } &&
8115	>	{ ac_try='test -z "$ac_c_werror_flag"
8116	>	|| test ! -s conftest.err'
8117	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118	>	(eval $ac_try) 2>&5
8119	>	ac_status=$?
8120	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121	>	(exit $ac_status); }; } &&
8122	>	{ ac_try='test -s conftest.$ac_objext'
8123	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124	>	(eval $ac_try) 2>&5
8125	>	ac_status=$?
8126	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127	>	(exit $ac_status); }; }; then
8128	>	ac_cv_header_time=yes
8129	>	else
8130	>	echo "$as_me: failed program was:" >&5
8131	>	sed 's/^/| /' conftest.$ac_ext >&5
8132	>
8133	>	ac_cv_header_time=no
8134	>	fi
8135	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136	>	fi
8137	>	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138	>	echo "${ECHO_T}$ac_cv_header_time" >&6
8139	>	if test $ac_cv_header_time = yes; then
8140	>
8141	>	cat >>confdefs.h <<\_ACEOF
8142	>	#define TIME_WITH_SYS_TIME 1
8143	>	_ACEOF
8144	>
8145	>	fi
8146	>
8147	>	echo "$as_me:$LINENO: checking for clock_t" >&5
8148	>	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149	>	if test "${ac_cv_type_clock_t+set}" = set; then
8150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8151	>	else
8152	>	cat >conftest.$ac_ext <<_ACEOF
8153	>	/* confdefs.h.  */
8154	>	_ACEOF
8155	>	cat confdefs.h >>conftest.$ac_ext
8156	>	cat >>conftest.$ac_ext <<_ACEOF
8157	>	/* end confdefs.h.  */
8158	>	$ac_includes_default
8159	>	#ifdef FC_DUMMY_MAIN
8160	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8161	>	#  ifdef __cplusplus
8162	>	extern "C"
8163	>	#  endif
8164	>	int FC_DUMMY_MAIN() { return 1; }
8165	>	#endif
8166	>	#endif
8167	>	int
8168	>	main ()
8169	>	{
8170	>	if ((clock_t *) 0)
8171	>	return 0;
8172	>	if (sizeof (clock_t))
8173	>	return 0;
8174	>	;
8175	>	return 0;
8176	>	}
8177	>	_ACEOF
8178	>	rm -f conftest.$ac_objext
8179	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180	>	(eval $ac_compile) 2>conftest.er1
8181	>	ac_status=$?
8182	>	grep -v '^ *+' conftest.er1 >conftest.err
8183	>	rm -f conftest.er1
8184	>	cat conftest.err >&5
8185	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186	>	(exit $ac_status); } &&
8187	>	{ ac_try='test -z "$ac_c_werror_flag"
8188	>	|| test ! -s conftest.err'
8189	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190	>	(eval $ac_try) 2>&5
8191	>	ac_status=$?
8192	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193	>	(exit $ac_status); }; } &&
8194	>	{ ac_try='test -s conftest.$ac_objext'
8195	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196	>	(eval $ac_try) 2>&5
8197	>	ac_status=$?
8198	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199	>	(exit $ac_status); }; }; then
8200	>	ac_cv_type_clock_t=yes
8201	>	else
8202	>	echo "$as_me: failed program was:" >&5
8203	>	sed 's/^/| /' conftest.$ac_ext >&5
8204	>
8205	>	ac_cv_type_clock_t=no
8206	>	fi
8207	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208	>	fi
8209	>	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210	>	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211	>	if test $ac_cv_type_clock_t = yes; then
8212	>
8213	>	cat >>confdefs.h <<_ACEOF
8214	>	#define HAVE_CLOCK_T 1
8215	>	_ACEOF
8216	>
8217	>
8218	>	fi
8219	>
8220	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222	>	if test "${ac_cv_c_const+set}" = set; then
8223	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8224	>	else
8225	>	cat >conftest.$ac_ext <<_ACEOF
8226	>	/* confdefs.h.  */
8227	>	_ACEOF
8228	>	cat confdefs.h >>conftest.$ac_ext
8229	>	cat >>conftest.$ac_ext <<_ACEOF
8230	>	/* end confdefs.h.  */
8231	>
8232	>	#ifdef FC_DUMMY_MAIN
8233	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8234	>	#  ifdef __cplusplus
8235	>	extern "C"
8236	>	#  endif
8237	>	int FC_DUMMY_MAIN() { return 1; }
8238	>	#endif
8239	>	#endif
8240	>	int
8241	>	main ()
8242	>	{
8243	>	/* FIXME: Include the comments suggested by Paul. */
8244	>	#ifndef __cplusplus
8245	>	/* Ultrix mips cc rejects this.  */
8246	>	typedef int charset[2];
8247	>	const charset x;
8248	>	/* SunOS 4.1.1 cc rejects this.  */
8249	>	char const *const *ccp;
8250	>	char **p;
8251	>	/* NEC SVR4.0.2 mips cc rejects this.  */
8252	>	struct point {int x, y;};
8253	>	static struct point const zero = {0,0};
8254	>	/* AIX XL C 1.02.0.0 rejects this.
8255	>	It does not let you subtract one const X* pointer from another in
8256	>	an arm of an if-expression whose if-part is not a constant
8257	>	expression */
8258	>	const char *g = "string";
8259	>	ccp = &g + (g ? g-g : 0);
8260	>	/* HPUX 7.0 cc rejects these. */
8261	>	++ccp;
8262	>	p = (char**) ccp;
8263	>	ccp = (char const *const *) p;
8264	>	{ /* SCO 3.2v4 cc rejects this.  */
8265	>	char *t;
8266	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
8267	>
8268	>	*t++ = 0;
8269	>	}
8270	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271	>	int x[] = {25, 17};
8272	>	const int *foo = &x[0];
8273	>	++foo;
8274	>	}
8275	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276	>	typedef const int *iptr;
8277	>	iptr p = 0;
8278	>	++p;
8279	>	}
8280	>	{ /* AIX XL C 1.02.0.0 rejects this saying
8281	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282	>	struct s { int j; const int *ap[3]; };
8283	>	struct s *b; b->j = 5;
8284	>	}
8285	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286	>	const int foo = 10;
8287	>	}
8288	>	#endif
8289	>
8290	>	;
8291	>	return 0;
8292	>	}
8293	>	_ACEOF
8294	>	rm -f conftest.$ac_objext
8295	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296	>	(eval $ac_compile) 2>conftest.er1
8297	>	ac_status=$?
8298	>	grep -v '^ *+' conftest.er1 >conftest.err
8299	>	rm -f conftest.er1
8300	>	cat conftest.err >&5
8301	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302	>	(exit $ac_status); } &&
8303	>	{ ac_try='test -z "$ac_c_werror_flag"
8304	>	|| test ! -s conftest.err'
8305	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306	>	(eval $ac_try) 2>&5
8307	>	ac_status=$?
8308	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309	>	(exit $ac_status); }; } &&
8310	>	{ ac_try='test -s conftest.$ac_objext'
8311	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312	>	(eval $ac_try) 2>&5
8313	>	ac_status=$?
8314	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315	>	(exit $ac_status); }; }; then
8316	>	ac_cv_c_const=yes
8317	>	else
8318	>	echo "$as_me: failed program was:" >&5
8319	>	sed 's/^/| /' conftest.$ac_ext >&5
8320	>
8321	>	ac_cv_c_const=no
8322	>	fi
8323	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324	>	fi
8325	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326	>	echo "${ECHO_T}$ac_cv_c_const" >&6
8327	>	if test $ac_cv_c_const = no; then
8328	>
8329	>	cat >>confdefs.h <<\_ACEOF
8330	>	#define const
8331	>	_ACEOF
8332	>
8333	>	fi
8334	>
8335	>	echo "$as_me:$LINENO: checking for inline" >&5
8336	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337	>	if test "${ac_cv_c_inline+set}" = set; then
8338	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8339	>	else
8340	>	ac_cv_c_inline=no
8341	>	for ac_kw in inline __inline__ __inline; do
8342	>	cat >conftest.$ac_ext <<_ACEOF
8343	>	/* confdefs.h.  */
8344	>	_ACEOF
8345	>	cat confdefs.h >>conftest.$ac_ext
8346	>	cat >>conftest.$ac_ext <<_ACEOF
8347	>	/* end confdefs.h.  */
8348	>	#ifndef __cplusplus
8349	>	typedef int foo_t;
8350	>	static $ac_kw foo_t static_foo () {return 0; }
8351	>	$ac_kw foo_t foo () {return 0; }
8352	>	#endif
8353	>
8354	>	_ACEOF
8355	>	rm -f conftest.$ac_objext
8356	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357	>	(eval $ac_compile) 2>conftest.er1
8358	>	ac_status=$?
8359	>	grep -v '^ *+' conftest.er1 >conftest.err
8360	>	rm -f conftest.er1
8361	>	cat conftest.err >&5
8362	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363	>	(exit $ac_status); } &&
8364	>	{ ac_try='test -z "$ac_c_werror_flag"
8365	>	|| test ! -s conftest.err'
8366	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367	>	(eval $ac_try) 2>&5
8368	>	ac_status=$?
8369	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370	>	(exit $ac_status); }; } &&
8371	>	{ ac_try='test -s conftest.$ac_objext'
8372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373	>	(eval $ac_try) 2>&5
8374	>	ac_status=$?
8375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376	>	(exit $ac_status); }; }; then
8377	>	ac_cv_c_inline=$ac_kw; break
8378	>	else
8379	>	echo "$as_me: failed program was:" >&5
8380	>	sed 's/^/| /' conftest.$ac_ext >&5
8381	>
8382	>	fi
8383	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384	>	done
8385	>
8386	>	fi
8387	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
8389	>
8390	>
8391	>	case $ac_cv_c_inline in
8392	>	inline | yes) ;;
8393	>	*)
8394	>	case $ac_cv_c_inline in
8395	>	no) ac_val=;;
8396	>	*) ac_val=$ac_cv_c_inline;;
8397	>	esac
8398	>	cat >>confdefs.h <<_ACEOF
8399	>	#ifndef __cplusplus
8400	>	#define inline $ac_val
8401	>	#endif
8402	>	_ACEOF
8403	>	;;
8404	>	esac
8405	>
8406	>
8407	>	# Checks for library functions.
8408	>
8409	>	for ac_header in stdlib.h
8410	>	do
8411	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8414	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8417	>	fi
8418	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420	>	else
8421	>	# Is the header compilable?
8422	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424	>	cat >conftest.$ac_ext <<_ACEOF
8425	>	/* confdefs.h.  */
8426	>	_ACEOF
8427	>	cat confdefs.h >>conftest.$ac_ext
8428	>	cat >>conftest.$ac_ext <<_ACEOF
8429	>	/* end confdefs.h.  */
8430	>	$ac_includes_default
8431	>	#include <$ac_header>
8432	>	_ACEOF
8433	>	rm -f conftest.$ac_objext
8434	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435	>	(eval $ac_compile) 2>conftest.er1
8436	>	ac_status=$?
8437	>	grep -v '^ *+' conftest.er1 >conftest.err
8438	>	rm -f conftest.er1
8439	>	cat conftest.err >&5
8440	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441	>	(exit $ac_status); } &&
8442	>	{ ac_try='test -z "$ac_c_werror_flag"
8443	>	|| test ! -s conftest.err'
8444	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445	>	(eval $ac_try) 2>&5
8446	>	ac_status=$?
8447	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448	>	(exit $ac_status); }; } &&
8449	>	{ ac_try='test -s conftest.$ac_objext'
8450	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451	>	(eval $ac_try) 2>&5
8452	>	ac_status=$?
8453	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454	>	(exit $ac_status); }; }; then
8455	>	ac_header_compiler=yes
8456	>	else
8457	>	echo "$as_me: failed program was:" >&5
8458	>	sed 's/^/| /' conftest.$ac_ext >&5
8459	>
8460	>	ac_header_compiler=no
8461	>	fi
8462	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464	>	echo "${ECHO_T}$ac_header_compiler" >&6
8465	>
8466	>	# Is the header present?
8467	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469	>	cat >conftest.$ac_ext <<_ACEOF
8470	>	/* confdefs.h.  */
8471	>	_ACEOF
8472	>	cat confdefs.h >>conftest.$ac_ext
8473	>	cat >>conftest.$ac_ext <<_ACEOF
8474	>	/* end confdefs.h.  */
8475	>	#include <$ac_header>
8476	>	_ACEOF
8477	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479	>	ac_status=$?
8480	>	grep -v '^ *+' conftest.er1 >conftest.err
8481	>	rm -f conftest.er1
8482	>	cat conftest.err >&5
8483	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484	>	(exit $ac_status); } >/dev/null; then
8485	>	if test -s conftest.err; then
8486	>	ac_cpp_err=$ac_c_preproc_warn_flag
8487	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488	>	else
8489	>	ac_cpp_err=
8490	>	fi
8491	>	else
8492	>	ac_cpp_err=yes
8493	>	fi
8494	>	if test -z "$ac_cpp_err"; then
8495	>	ac_header_preproc=yes
8496	>	else
8497	>	echo "$as_me: failed program was:" >&5
8498	>	sed 's/^/| /' conftest.$ac_ext >&5
8499	>
8500	>	ac_header_preproc=no
8501	>	fi
8502	>	rm -f conftest.err conftest.$ac_ext
8503	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504	>	echo "${ECHO_T}$ac_header_preproc" >&6
8505	>
8506	>	# So?  What about this header?
8507	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508	>	yes:no: )
8509	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513	>	ac_header_preproc=yes
8514	>	;;
8515	>	no:yes:* )
8516	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528	>	(
8529	>	cat <<\_ASBOX
8530	>	## ------------------------------ ##
8531	>	## Report this to gezelter@nd.edu ##
8532	>	## ------------------------------ ##
8533	>	_ASBOX
8534	>	) |
8535	>	sed "s/^/$as_me: WARNING:     /" >&2
8536	>	;;
8537	>	esac
8538	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8539	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8542	>	else
8543	>	eval "$as_ac_Header=\$ac_header_preproc"
8544	>	fi
8545	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547	>
8548	>	fi
8549	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550	>	cat >>confdefs.h <<_ACEOF
8551	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552	>	_ACEOF
8553	>
8554	>	fi
8555	>
8556	>	done
8557	>
8558	>	echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559	>	echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8562	>	else
8563	>	if test "$cross_compiling" = yes; then
8564	>	ac_cv_func_malloc_0_nonnull=no
8565	>	else
8566	>	cat >conftest.$ac_ext <<_ACEOF
8567	>	/* confdefs.h.  */
8568	>	_ACEOF
8569	>	cat confdefs.h >>conftest.$ac_ext
8570	>	cat >>conftest.$ac_ext <<_ACEOF
8571	>	/* end confdefs.h.  */
8572	>	#if STDC_HEADERS || HAVE_STDLIB_H
8573	>	# include <stdlib.h>
8574	>	#else
8575	>	char *malloc ();
8576	>	#endif
8577	>
8578	>	#ifdef FC_DUMMY_MAIN
8579	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8580	>	#  ifdef __cplusplus
8581	>	extern "C"
8582	>	#  endif
8583	>	int FC_DUMMY_MAIN() { return 1; }
8584	>	#endif
8585	>	#endif
8586	>	int
8587	>	main ()
8588	>	{
8589	>	exit (malloc (0) ? 0 : 1);
8590	>	;
8591	>	return 0;
8592	>	}
8593	>	_ACEOF
8594	>	rm -f conftest$ac_exeext
8595	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596	>	(eval $ac_link) 2>&5
8597	>	ac_status=$?
8598	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601	>	(eval $ac_try) 2>&5
8602	>	ac_status=$?
8603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604	>	(exit $ac_status); }; }; then
8605	>	ac_cv_func_malloc_0_nonnull=yes
8606	>	else
8607	>	echo "$as_me: program exited with status $ac_status" >&5
8608	>	echo "$as_me: failed program was:" >&5
8609	>	sed 's/^/| /' conftest.$ac_ext >&5
8610	>
8611	>	( exit $ac_status )
8612	>	ac_cv_func_malloc_0_nonnull=no
8613	>	fi
8614	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615	>	fi
8616	>	fi
8617	>	echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618	>	echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619	>	if test $ac_cv_func_malloc_0_nonnull = yes; then
8620	>
8621	>	cat >>confdefs.h <<\_ACEOF
8622	>	#define HAVE_MALLOC 1
8623	>	_ACEOF
8624	>
8625	>	else
8626	>	cat >>confdefs.h <<\_ACEOF
8627	>	#define HAVE_MALLOC 0
8628	>	_ACEOF
8629	>
8630	>	case $LIBOBJS in
8631	>	"malloc.$ac_objext"   | \
8632	>	*" malloc.$ac_objext"   | \
8633	>	"malloc.$ac_objext "* | \
8634	>	*" malloc.$ac_objext "* ) ;;
8635	>	*) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636	>	esac
8637	>
8638	>
8639	>	cat >>confdefs.h <<\_ACEOF
8640	>	#define malloc rpl_malloc
8641	>	_ACEOF
8642	>
8643	>	fi
8644	>
8645	>
8646	>
8647	>	echo "$as_me:$LINENO: checking for working memcmp" >&5
8648	>	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649	>	if test "${ac_cv_func_memcmp_working+set}" = set; then
8650	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8651	>	else
8652	>	if test "$cross_compiling" = yes; then
8653	>	ac_cv_func_memcmp_working=no
8654	>	else
8655	>	cat >conftest.$ac_ext <<_ACEOF
8656	>	/* confdefs.h.  */
8657	>	_ACEOF
8658	>	cat confdefs.h >>conftest.$ac_ext
8659	>	cat >>conftest.$ac_ext <<_ACEOF
8660	>	/* end confdefs.h.  */
8661	>	$ac_includes_default
8662	>	#ifdef FC_DUMMY_MAIN
8663	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8664	>	#  ifdef __cplusplus
8665	>	extern "C"
8666	>	#  endif
8667	>	int FC_DUMMY_MAIN() { return 1; }
8668	>	#endif
8669	>	#endif
8670	>	int
8671	>	main ()
8672	>	{
8673	>
8674	>	/* Some versions of memcmp are not 8-bit clean.  */
8675	>	char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676	>	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677	>	exit (1);
8678	>
8679	>	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680	>	or more and with at least one buffer not starting on a 4-byte boundary.
8681	>	William Lewis provided this test program.   */
8682	>	{
8683	>	char foo[21];
8684	>	char bar[21];
8685	>	int i;
8686	>	for (i = 0; i < 4; i++)
8687	>	{
8688	>	char *a = foo + i;
8689	>	char *b = bar + i;
8690	>	strcpy (a, "--------01111111");
8691	>	strcpy (b, "--------10000000");
8692	>	if (memcmp (a, b, 16) >= 0)
8693	>	exit (1);
8694	>	}
8695	>	exit (0);
8696	>	}
8697	>
8698	>	;
8699	>	return 0;
8700	>	}
8701	>	_ACEOF
8702	>	rm -f conftest$ac_exeext
8703	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704	>	(eval $ac_link) 2>&5
8705	>	ac_status=$?
8706	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709	>	(eval $ac_try) 2>&5
8710	>	ac_status=$?
8711	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712	>	(exit $ac_status); }; }; then
8713	>	ac_cv_func_memcmp_working=yes
8714	>	else
8715	>	echo "$as_me: program exited with status $ac_status" >&5
8716	>	echo "$as_me: failed program was:" >&5
8717	>	sed 's/^/| /' conftest.$ac_ext >&5
8718	>
8719	>	( exit $ac_status )
8720	>	ac_cv_func_memcmp_working=no
8721	>	fi
8722	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723	>	fi
8724	>	fi
8725	>	echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726	>	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727	>	test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728	>	"memcmp.$ac_objext"   | \
8729	>	*" memcmp.$ac_objext"   | \
8730	>	"memcmp.$ac_objext "* | \
8731	>	*" memcmp.$ac_objext "* ) ;;
8732	>	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733	>	esac
8734	>
8735	>
8736	>
8737	>	for ac_header in stdlib.h
8738	>	do
8739	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8742	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8745	>	fi
8746	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748	>	else
8749	>	# Is the header compilable?
8750	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752	>	cat >conftest.$ac_ext <<_ACEOF
8753	>	/* confdefs.h.  */
8754	>	_ACEOF
8755	>	cat confdefs.h >>conftest.$ac_ext
8756	>	cat >>conftest.$ac_ext <<_ACEOF
8757	>	/* end confdefs.h.  */
8758	>	$ac_includes_default
8759	>	#include <$ac_header>
8760	>	_ACEOF
8761	>	rm -f conftest.$ac_objext
8762	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763	>	(eval $ac_compile) 2>conftest.er1
8764	>	ac_status=$?
8765	>	grep -v '^ *+' conftest.er1 >conftest.err
8766	>	rm -f conftest.er1
8767	>	cat conftest.err >&5
8768	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769	>	(exit $ac_status); } &&
8770	>	{ ac_try='test -z "$ac_c_werror_flag"
8771	>	|| test ! -s conftest.err'
8772	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773	>	(eval $ac_try) 2>&5
8774	>	ac_status=$?
8775	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776	>	(exit $ac_status); }; } &&
8777	>	{ ac_try='test -s conftest.$ac_objext'
8778	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779	>	(eval $ac_try) 2>&5
8780	>	ac_status=$?
8781	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782	>	(exit $ac_status); }; }; then
8783	>	ac_header_compiler=yes
8784	>	else
8785	>	echo "$as_me: failed program was:" >&5
8786	>	sed 's/^/| /' conftest.$ac_ext >&5
8787	>
8788	>	ac_header_compiler=no
8789	>	fi
8790	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792	>	echo "${ECHO_T}$ac_header_compiler" >&6
8793	>
8794	>	# Is the header present?
8795	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797	>	cat >conftest.$ac_ext <<_ACEOF
8798	>	/* confdefs.h.  */
8799	>	_ACEOF
8800	>	cat confdefs.h >>conftest.$ac_ext
8801	>	cat >>conftest.$ac_ext <<_ACEOF
8802	>	/* end confdefs.h.  */
8803	>	#include <$ac_header>
8804	>	_ACEOF
8805	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807	>	ac_status=$?
8808	>	grep -v '^ *+' conftest.er1 >conftest.err
8809	>	rm -f conftest.er1
8810	>	cat conftest.err >&5
8811	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812	>	(exit $ac_status); } >/dev/null; then
8813	>	if test -s conftest.err; then
8814	>	ac_cpp_err=$ac_c_preproc_warn_flag
8815	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816	>	else
8817	>	ac_cpp_err=
8818	>	fi
8819	>	else
8820	>	ac_cpp_err=yes
8821	>	fi
8822	>	if test -z "$ac_cpp_err"; then
8823	>	ac_header_preproc=yes
8824	>	else
8825	>	echo "$as_me: failed program was:" >&5
8826	>	sed 's/^/| /' conftest.$ac_ext >&5
8827	>
8828	>	ac_header_preproc=no
8829	>	fi
8830	>	rm -f conftest.err conftest.$ac_ext
8831	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832	>	echo "${ECHO_T}$ac_header_preproc" >&6
8833	>
8834	>	# So?  What about this header?
8835	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836	>	yes:no: )
8837	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841	>	ac_header_preproc=yes
8842	>	;;
8843	>	no:yes:* )
8844	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856	>	(
8857	>	cat <<\_ASBOX
8858	>	## ------------------------------ ##
8859	>	## Report this to gezelter@nd.edu ##
8860	>	## ------------------------------ ##
8861	>	_ASBOX
8862	>	) |
8863	>	sed "s/^/$as_me: WARNING:     /" >&2
8864	>	;;
8865	>	esac
8866	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8867	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8870	>	else
8871	>	eval "$as_ac_Header=\$ac_header_preproc"
8872	>	fi
8873	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875	>
8876	>	fi
8877	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878	>	cat >>confdefs.h <<_ACEOF
8879	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880	>	_ACEOF
8881	>
8882	>	fi
8883	>
8884	>	done
8885	>
8886	>	echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887	>	echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8890	>	else
8891	>	if test "$cross_compiling" = yes; then
8892	>	ac_cv_func_realloc_0_nonnull=no
8893	>	else
8894	>	cat >conftest.$ac_ext <<_ACEOF
8895	>	/* confdefs.h.  */
8896	>	_ACEOF
8897	>	cat confdefs.h >>conftest.$ac_ext
8898	>	cat >>conftest.$ac_ext <<_ACEOF
8899	>	/* end confdefs.h.  */
8900	>	#if STDC_HEADERS || HAVE_STDLIB_H
8901	>	# include <stdlib.h>
8902	>	#else
8903	>	char *realloc ();
8904	>	#endif
8905	>
8906	>	#ifdef FC_DUMMY_MAIN
8907	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8908	>	#  ifdef __cplusplus
8909	>	extern "C"
8910	>	#  endif
8911	>	int FC_DUMMY_MAIN() { return 1; }
8912	>	#endif
8913	>	#endif
8914	>	int
8915	>	main ()
8916	>	{
8917	>	exit (realloc (0, 0) ? 0 : 1);
8918	>	;
8919	>	return 0;
8920	>	}
8921	>	_ACEOF
8922	>	rm -f conftest$ac_exeext
8923	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924	>	(eval $ac_link) 2>&5
8925	>	ac_status=$?
8926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929	>	(eval $ac_try) 2>&5
8930	>	ac_status=$?
8931	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932	>	(exit $ac_status); }; }; then
8933	>	ac_cv_func_realloc_0_nonnull=yes
8934	>	else
8935	>	echo "$as_me: program exited with status $ac_status" >&5
8936	>	echo "$as_me: failed program was:" >&5
8937	>	sed 's/^/| /' conftest.$ac_ext >&5
8938	>
8939	>	( exit $ac_status )
8940	>	ac_cv_func_realloc_0_nonnull=no
8941	>	fi
8942	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943	>	fi
8944	>	fi
8945	>	echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946	>	echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947	>	if test $ac_cv_func_realloc_0_nonnull = yes; then
8948	>
8949	>	cat >>confdefs.h <<\_ACEOF
8950	>	#define HAVE_REALLOC 1
8951	>	_ACEOF
8952	>
8953	>	else
8954	>	cat >>confdefs.h <<\_ACEOF
8955	>	#define HAVE_REALLOC 0
8956	>	_ACEOF
8957	>
8958	>	case $LIBOBJS in
8959	>	"realloc.$ac_objext"   | \
8960	>	*" realloc.$ac_objext"   | \
8961	>	"realloc.$ac_objext "* | \
8962	>	*" realloc.$ac_objext "* ) ;;
8963	>	*) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964	>	esac
8965	>
8966	>
8967	>	cat >>confdefs.h <<\_ACEOF
8968	>	#define realloc rpl_realloc
8969	>	_ACEOF
8970	>
8971	>	fi
8972	>
8973	>
8974	>
8975	>
8976	>
8977	>	for ac_header in sys/select.h sys/socket.h
8978	>	do
8979	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8982	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8985	>	fi
8986	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988	>	else
8989	>	# Is the header compilable?
8990	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992	>	cat >conftest.$ac_ext <<_ACEOF
8993	>	/* confdefs.h.  */
8994	>	_ACEOF
8995	>	cat confdefs.h >>conftest.$ac_ext
8996	>	cat >>conftest.$ac_ext <<_ACEOF
8997	>	/* end confdefs.h.  */
8998	>	$ac_includes_default
8999	>	#include <$ac_header>
9000	>	_ACEOF
9001	>	rm -f conftest.$ac_objext
9002	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003	>	(eval $ac_compile) 2>conftest.er1
9004	>	ac_status=$?
9005	>	grep -v '^ *+' conftest.er1 >conftest.err
9006	>	rm -f conftest.er1
9007	>	cat conftest.err >&5
9008	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009	>	(exit $ac_status); } &&
9010	>	{ ac_try='test -z "$ac_c_werror_flag"
9011	>	|| test ! -s conftest.err'
9012	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013	>	(eval $ac_try) 2>&5
9014	>	ac_status=$?
9015	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016	>	(exit $ac_status); }; } &&
9017	>	{ ac_try='test -s conftest.$ac_objext'
9018	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019	>	(eval $ac_try) 2>&5
9020	>	ac_status=$?
9021	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022	>	(exit $ac_status); }; }; then
9023	>	ac_header_compiler=yes
9024	>	else
9025	>	echo "$as_me: failed program was:" >&5
9026	>	sed 's/^/| /' conftest.$ac_ext >&5
9027	>
9028	>	ac_header_compiler=no
9029	>	fi
9030	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032	>	echo "${ECHO_T}$ac_header_compiler" >&6
9033	>
9034	>	# Is the header present?
9035	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037	>	cat >conftest.$ac_ext <<_ACEOF
9038	>	/* confdefs.h.  */
9039	>	_ACEOF
9040	>	cat confdefs.h >>conftest.$ac_ext
9041	>	cat >>conftest.$ac_ext <<_ACEOF
9042	>	/* end confdefs.h.  */
9043	>	#include <$ac_header>
9044	>	_ACEOF
9045	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047	>	ac_status=$?
9048	>	grep -v '^ *+' conftest.er1 >conftest.err
9049	>	rm -f conftest.er1
9050	>	cat conftest.err >&5
9051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052	>	(exit $ac_status); } >/dev/null; then
9053	>	if test -s conftest.err; then
9054	>	ac_cpp_err=$ac_c_preproc_warn_flag
9055	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056	>	else
9057	>	ac_cpp_err=
9058	>	fi
9059	>	else
9060	>	ac_cpp_err=yes
9061	>	fi
9062	>	if test -z "$ac_cpp_err"; then
9063	>	ac_header_preproc=yes
9064	>	else
9065	>	echo "$as_me: failed program was:" >&5
9066	>	sed 's/^/| /' conftest.$ac_ext >&5
9067	>
9068	>	ac_header_preproc=no
9069	>	fi
9070	>	rm -f conftest.err conftest.$ac_ext
9071	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072	>	echo "${ECHO_T}$ac_header_preproc" >&6
9073	>
9074	>	# So?  What about this header?
9075	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076	>	yes:no: )
9077	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081	>	ac_header_preproc=yes
9082	>	;;
9083	>	no:yes:* )
9084	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096	>	(
9097	>	cat <<\_ASBOX
9098	>	## ------------------------------ ##
9099	>	## Report this to gezelter@nd.edu ##
9100	>	## ------------------------------ ##
9101	>	_ASBOX
9102	>	) |
9103	>	sed "s/^/$as_me: WARNING:     /" >&2
9104	>	;;
9105	>	esac
9106	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9107	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9110	>	else
9111	>	eval "$as_ac_Header=\$ac_header_preproc"
9112	>	fi
9113	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115	>
9116	>	fi
9117	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118	>	cat >>confdefs.h <<_ACEOF
9119	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120	>	_ACEOF
9121	>
9122	>	fi
9123	>
9124	>	done
9125	>
9126	>	echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127	>	echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128	>	if test "${ac_cv_func_select_args+set}" = set; then
9129	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9130	>	else
9131	>	for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132	>	for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133	>	for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134	>	cat >conftest.$ac_ext <<_ACEOF
9135	>	/* confdefs.h.  */
9136	>	_ACEOF
9137	>	cat confdefs.h >>conftest.$ac_ext
9138	>	cat >>conftest.$ac_ext <<_ACEOF
9139	>	/* end confdefs.h.  */
9140	>	$ac_includes_default
9141	>	#if HAVE_SYS_SELECT_H
9142	>	# include <sys/select.h>
9143	>	#endif
9144	>	#if HAVE_SYS_SOCKET_H
9145	>	# include <sys/socket.h>
9146	>	#endif
9147	>
9148	>	#ifdef FC_DUMMY_MAIN
9149	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9150	>	#  ifdef __cplusplus
9151	>	extern "C"
9152	>	#  endif
9153	>	int FC_DUMMY_MAIN() { return 1; }
9154	>	#endif
9155	>	#endif
9156	>	int
9157	>	main ()
9158	>	{
9159	>	extern int select ($ac_arg1,
9160	>	$ac_arg234, $ac_arg234, $ac_arg234,
9161	>	$ac_arg5);
9162	>	;
9163	>	return 0;
9164	>	}
9165	>	_ACEOF
9166	>	rm -f conftest.$ac_objext
9167	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168	>	(eval $ac_compile) 2>conftest.er1
9169	>	ac_status=$?
9170	>	grep -v '^ *+' conftest.er1 >conftest.err
9171	>	rm -f conftest.er1
9172	>	cat conftest.err >&5
9173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174	>	(exit $ac_status); } &&
9175	>	{ ac_try='test -z "$ac_c_werror_flag"
9176	>	|| test ! -s conftest.err'
9177	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178	>	(eval $ac_try) 2>&5
9179	>	ac_status=$?
9180	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181	>	(exit $ac_status); }; } &&
9182	>	{ ac_try='test -s conftest.$ac_objext'
9183	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184	>	(eval $ac_try) 2>&5
9185	>	ac_status=$?
9186	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187	>	(exit $ac_status); }; }; then
9188	>	ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189	>	else
9190	>	echo "$as_me: failed program was:" >&5
9191	>	sed 's/^/| /' conftest.$ac_ext >&5
9192	>
9193	>	fi
9194	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195	>	done
9196	>	done
9197	>	done
9198	>	# Provide a safe default value.
9199	>	: ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200	>
9201	>	fi
9202	>	echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203	>	echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204	>	ac_save_IFS=$IFS; IFS=','
9205	>	set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206	>	IFS=$ac_save_IFS
9207	>	shift
9208	>
9209	>	cat >>confdefs.h <<_ACEOF
9210	>	#define SELECT_TYPE_ARG1 $1
9211	>	_ACEOF
9212	>
9213	>
9214	>	cat >>confdefs.h <<_ACEOF
9215	>	#define SELECT_TYPE_ARG234 ($2)
9216	>	_ACEOF
9217	>
9218	>
9219	>	cat >>confdefs.h <<_ACEOF
9220	>	#define SELECT_TYPE_ARG5 ($3)
9221	>	_ACEOF
9222	>
9223	>	rm -f conftest*
9224	>
9225	>
9226	>	for ac_func in strftime
9227	>	do
9228	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9230	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9232	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9233	>	else
9234	>	cat >conftest.$ac_ext <<_ACEOF
9235	>	/* confdefs.h.  */
9236	>	_ACEOF
9237	>	cat confdefs.h >>conftest.$ac_ext
9238	>	cat >>conftest.$ac_ext <<_ACEOF
9239	>	/* end confdefs.h.  */
9240	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242	>	#define $ac_func innocuous_$ac_func
9243	>
9244	>	/* System header to define __stub macros and hopefully few prototypes,
9245	>	which can conflict with char $ac_func (); below.
9246	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247	>	<limits.h> exists even on freestanding compilers.  */
9248	>
9249	>	#ifdef __STDC__
9250	>	# include <limits.h>
9251	>	#else
9252	>	# include <assert.h>
9253	>	#endif
9254	>
9255	>	#undef $ac_func
9256	>
9257	>	/* Override any gcc2 internal prototype to avoid an error.  */
9258	>	#ifdef __cplusplus
9259	>	extern "C"
9260	>	{
9261	>	#endif
9262	>	/* We use char because int might match the return type of a gcc2
9263	>	builtin and then its argument prototype would still apply.  */
9264	>	char $ac_func ();
9265	>	/* The GNU C library defines this for functions which it implements
9266	>	to always fail with ENOSYS.  Some functions are actually named
9267	>	something starting with __ and the normal name is an alias.  */
9268	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269	>	choke me
9270	>	#else
9271	>	char (*f) () = $ac_func;
9272	>	#endif
9273	>	#ifdef __cplusplus
9274	>	}
9275	>	#endif
9276	>
9277	>	#ifdef FC_DUMMY_MAIN
9278	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9279	>	#  ifdef __cplusplus
9280	>	extern "C"
9281	>	#  endif
9282	>	int FC_DUMMY_MAIN() { return 1; }
9283	>	#endif
9284	>	#endif
9285	>	int
9286	>	main ()
9287	>	{
9288	>	return f != $ac_func;
9289	>	;
9290	>	return 0;
9291	>	}
9292	>	_ACEOF
9293	>	rm -f conftest.$ac_objext conftest$ac_exeext
9294	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295	>	(eval $ac_link) 2>conftest.er1
9296	>	ac_status=$?
9297	>	grep -v '^ *+' conftest.er1 >conftest.err
9298	>	rm -f conftest.er1
9299	>	cat conftest.err >&5
9300	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301	>	(exit $ac_status); } &&
9302	>	{ ac_try='test -z "$ac_c_werror_flag"
9303	>	|| test ! -s conftest.err'
9304	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305	>	(eval $ac_try) 2>&5
9306	>	ac_status=$?
9307	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308	>	(exit $ac_status); }; } &&
9309	>	{ ac_try='test -s conftest$ac_exeext'
9310	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311	>	(eval $ac_try) 2>&5
9312	>	ac_status=$?
9313	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314	>	(exit $ac_status); }; }; then
9315	>	eval "$as_ac_var=yes"
9316	>	else
9317	>	echo "$as_me: failed program was:" >&5
9318	>	sed 's/^/| /' conftest.$ac_ext >&5
9319	>
9320	>	eval "$as_ac_var=no"
9321	>	fi
9322	>	rm -f conftest.err conftest.$ac_objext \
9323	>	conftest$ac_exeext conftest.$ac_ext
9324	>	fi
9325	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9328	>	cat >>confdefs.h <<_ACEOF
9329	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330	>	_ACEOF
9331	>
9332	>	else
9333	>	# strftime is in -lintl on SCO UNIX.
9334	>	echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335	>	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336	>	if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9338	>	else
9339	>	ac_check_lib_save_LIBS=$LIBS
9340	>	LIBS="-lintl  $LIBS"
9341	>	cat >conftest.$ac_ext <<_ACEOF
9342	>	/* confdefs.h.  */
9343	>	_ACEOF
9344	>	cat confdefs.h >>conftest.$ac_ext
9345	>	cat >>conftest.$ac_ext <<_ACEOF
9346	>	/* end confdefs.h.  */
9347	>
9348	>	/* Override any gcc2 internal prototype to avoid an error.  */
9349	>	#ifdef __cplusplus
9350	>	extern "C"
9351	>	#endif
9352	>	/* We use char because int might match the return type of a gcc2
9353	>	builtin and then its argument prototype would still apply.  */
9354	>	char strftime ();
9355	>	#ifdef FC_DUMMY_MAIN
9356	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9357	>	#  ifdef __cplusplus
9358	>	extern "C"
9359	>	#  endif
9360	>	int FC_DUMMY_MAIN() { return 1; }
9361	>	#endif
9362	>	#endif
9363	>	int
9364	>	main ()
9365	>	{
9366	>	strftime ();
9367	>	;
9368	>	return 0;
9369	>	}
9370	>	_ACEOF
9371	>	rm -f conftest.$ac_objext conftest$ac_exeext
9372	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373	>	(eval $ac_link) 2>conftest.er1
9374	>	ac_status=$?
9375	>	grep -v '^ *+' conftest.er1 >conftest.err
9376	>	rm -f conftest.er1
9377	>	cat conftest.err >&5
9378	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379	>	(exit $ac_status); } &&
9380	>	{ ac_try='test -z "$ac_c_werror_flag"
9381	>	|| test ! -s conftest.err'
9382	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383	>	(eval $ac_try) 2>&5
9384	>	ac_status=$?
9385	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386	>	(exit $ac_status); }; } &&
9387	>	{ ac_try='test -s conftest$ac_exeext'
9388	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389	>	(eval $ac_try) 2>&5
9390	>	ac_status=$?
9391	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392	>	(exit $ac_status); }; }; then
9393	>	ac_cv_lib_intl_strftime=yes
9394	>	else
9395	>	echo "$as_me: failed program was:" >&5
9396	>	sed 's/^/| /' conftest.$ac_ext >&5
9397	>
9398	>	ac_cv_lib_intl_strftime=no
9399	>	fi
9400	>	rm -f conftest.err conftest.$ac_objext \
9401	>	conftest$ac_exeext conftest.$ac_ext
9402	>	LIBS=$ac_check_lib_save_LIBS
9403	>	fi
9404	>	echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405	>	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406	>	if test $ac_cv_lib_intl_strftime = yes; then
9407	>	cat >>confdefs.h <<\_ACEOF
9408	>	#define HAVE_STRFTIME 1
9409	>	_ACEOF
9410	>
9411	>	LIBS="-lintl $LIBS"
9412	>	fi
9413	>
9414	>	fi
9415	>	done
9416	>
9417	>	echo "$as_me:$LINENO: checking for working strtod" >&5
9418	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419	>	if test "${ac_cv_func_strtod+set}" = set; then
9420	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9421	>	else
9422	>	if test "$cross_compiling" = yes; then
9423	>	ac_cv_func_strtod=no
9424	>	else
9425	>	cat >conftest.$ac_ext <<_ACEOF
9426	>	/* confdefs.h.  */
9427	>	_ACEOF
9428	>	cat confdefs.h >>conftest.$ac_ext
9429	>	cat >>conftest.$ac_ext <<_ACEOF
9430	>	/* end confdefs.h.  */
9431	>
9432	>	double strtod ();
9433	>	int
9434	>	main()
9435	>	{
9436	>	{
9437	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438	>	char *string = " +69";
9439	>	char *term;
9440	>	double value;
9441	>	value = strtod (string, &term);
9442	>	if (value != 69 || term != (string + 4))
9443	>	exit (1);
9444	>	}
9445	>
9446	>	{
9447	>	/* Under Solaris 2.4, strtod returns the wrong value for the
9448	>	terminating character under some conditions.  */
9449	>	char *string = "NaN";
9450	>	char *term;
9451	>	strtod (string, &term);
9452	>	if (term != string && *(term - 1) == 0)
9453	>	exit (1);
9454	>	}
9455	>	exit (0);
9456	>	}
9457	>
9458	>	_ACEOF
9459	>	rm -f conftest$ac_exeext
9460	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461	>	(eval $ac_link) 2>&5
9462	>	ac_status=$?
9463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466	>	(eval $ac_try) 2>&5
9467	>	ac_status=$?
9468	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469	>	(exit $ac_status); }; }; then
9470	>	ac_cv_func_strtod=yes
9471	>	else
9472	>	echo "$as_me: program exited with status $ac_status" >&5
9473	>	echo "$as_me: failed program was:" >&5
9474	>	sed 's/^/| /' conftest.$ac_ext >&5
9475	>
9476	>	( exit $ac_status )
9477	>	ac_cv_func_strtod=no
9478	>	fi
9479	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480	>	fi
9481	>	fi
9482	>	echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484	>	if test $ac_cv_func_strtod = no; then
9485	>	case $LIBOBJS in
9486	>	"strtod.$ac_objext"   | \
9487	>	*" strtod.$ac_objext"   | \
9488	>	"strtod.$ac_objext "* | \
9489	>	*" strtod.$ac_objext "* ) ;;
9490	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491	>	esac
9492	>
9493	>	echo "$as_me:$LINENO: checking for pow" >&5
9494	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495	>	if test "${ac_cv_func_pow+set}" = set; then
9496	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9497	>	else
9498	>	cat >conftest.$ac_ext <<_ACEOF
9499	>	/* confdefs.h.  */
9500	>	_ACEOF
9501	>	cat confdefs.h >>conftest.$ac_ext
9502	>	cat >>conftest.$ac_ext <<_ACEOF
9503	>	/* end confdefs.h.  */
9504	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506	>	#define pow innocuous_pow
9507	>
9508	>	/* System header to define __stub macros and hopefully few prototypes,
9509	>	which can conflict with char pow (); below.
9510	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511	>	<limits.h> exists even on freestanding compilers.  */
9512	>
9513	>	#ifdef __STDC__
9514	>	# include <limits.h>
9515	>	#else
9516	>	# include <assert.h>
9517	>	#endif
9518	>
9519	>	#undef pow
9520	>
9521	>	/* Override any gcc2 internal prototype to avoid an error.  */
9522	>	#ifdef __cplusplus
9523	>	extern "C"
9524	>	{
9525	>	#endif
9526	>	/* We use char because int might match the return type of a gcc2
9527	>	builtin and then its argument prototype would still apply.  */
9528	>	char pow ();
9529	>	/* The GNU C library defines this for functions which it implements
9530	>	to always fail with ENOSYS.  Some functions are actually named
9531	>	something starting with __ and the normal name is an alias.  */
9532	>	#if defined (__stub_pow) || defined (__stub___pow)
9533	>	choke me
9534	>	#else
9535	>	char (*f) () = pow;
9536	>	#endif
9537	>	#ifdef __cplusplus
9538	>	}
9539	>	#endif
9540	>
9541	>	#ifdef FC_DUMMY_MAIN
9542	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9543	>	#  ifdef __cplusplus
9544	>	extern "C"
9545	>	#  endif
9546	>	int FC_DUMMY_MAIN() { return 1; }
9547	>	#endif
9548	>	#endif
9549	>	int
9550	>	main ()
9551	>	{
9552	>	return f != pow;
9553	>	;
9554	>	return 0;
9555	>	}
9556	>	_ACEOF
9557	>	rm -f conftest.$ac_objext conftest$ac_exeext
9558	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559	>	(eval $ac_link) 2>conftest.er1
9560	>	ac_status=$?
9561	>	grep -v '^ *+' conftest.er1 >conftest.err
9562	>	rm -f conftest.er1
9563	>	cat conftest.err >&5
9564	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565	>	(exit $ac_status); } &&
9566	>	{ ac_try='test -z "$ac_c_werror_flag"
9567	>	|| test ! -s conftest.err'
9568	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569	>	(eval $ac_try) 2>&5
9570	>	ac_status=$?
9571	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572	>	(exit $ac_status); }; } &&
9573	>	{ ac_try='test -s conftest$ac_exeext'
9574	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575	>	(eval $ac_try) 2>&5
9576	>	ac_status=$?
9577	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578	>	(exit $ac_status); }; }; then
9579	>	ac_cv_func_pow=yes
9580	>	else
9581	>	echo "$as_me: failed program was:" >&5
9582	>	sed 's/^/| /' conftest.$ac_ext >&5
9583	>
9584	>	ac_cv_func_pow=no
9585	>	fi
9586	>	rm -f conftest.err conftest.$ac_objext \
9587	>	conftest$ac_exeext conftest.$ac_ext
9588	>	fi
9589	>	echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590	>	echo "${ECHO_T}$ac_cv_func_pow" >&6
9591	>
9592	>	if test $ac_cv_func_pow = no; then
9593	>	echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595	>	if test "${ac_cv_lib_m_pow+set}" = set; then
9596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9597	>	else
9598	>	ac_check_lib_save_LIBS=$LIBS
9599	>	LIBS="-lm  $LIBS"
9600	>	cat >conftest.$ac_ext <<_ACEOF
9601	>	/* confdefs.h.  */
9602	>	_ACEOF
9603	>	cat confdefs.h >>conftest.$ac_ext
9604	>	cat >>conftest.$ac_ext <<_ACEOF
9605	>	/* end confdefs.h.  */
9606	>
9607	>	/* Override any gcc2 internal prototype to avoid an error.  */
9608	>	#ifdef __cplusplus
9609	>	extern "C"
9610	>	#endif
9611	>	/* We use char because int might match the return type of a gcc2
9612	>	builtin and then its argument prototype would still apply.  */
9613	>	char pow ();
9614	>	#ifdef FC_DUMMY_MAIN
9615	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9616	>	#  ifdef __cplusplus
9617	>	extern "C"
9618	>	#  endif
9619	>	int FC_DUMMY_MAIN() { return 1; }
9620	>	#endif
9621	>	#endif
9622	>	int
9623	>	main ()
9624	>	{
9625	>	pow ();
9626	>	;
9627	>	return 0;
9628	>	}
9629	>	_ACEOF
9630	>	rm -f conftest.$ac_objext conftest$ac_exeext
9631	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632	>	(eval $ac_link) 2>conftest.er1
9633	>	ac_status=$?
9634	>	grep -v '^ *+' conftest.er1 >conftest.err
9635	>	rm -f conftest.er1
9636	>	cat conftest.err >&5
9637	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638	>	(exit $ac_status); } &&
9639	>	{ ac_try='test -z "$ac_c_werror_flag"
9640	>	|| test ! -s conftest.err'
9641	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642	>	(eval $ac_try) 2>&5
9643	>	ac_status=$?
9644	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645	>	(exit $ac_status); }; } &&
9646	>	{ ac_try='test -s conftest$ac_exeext'
9647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648	>	(eval $ac_try) 2>&5
9649	>	ac_status=$?
9650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651	>	(exit $ac_status); }; }; then
9652	>	ac_cv_lib_m_pow=yes
9653	>	else
9654	>	echo "$as_me: failed program was:" >&5
9655	>	sed 's/^/| /' conftest.$ac_ext >&5
9656	>
9657	>	ac_cv_lib_m_pow=no
9658	>	fi
9659	>	rm -f conftest.err conftest.$ac_objext \
9660	>	conftest$ac_exeext conftest.$ac_ext
9661	>	LIBS=$ac_check_lib_save_LIBS
9662	>	fi
9663	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665	>	if test $ac_cv_lib_m_pow = yes; then
9666	>	POW_LIB=-lm
9667	>	else
9668	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670	>	fi
9671	>
9672	>	fi
9673	>
9674	>	fi
9675	>
9676	>
9677	>
9678	>
9679	>
9680	>
9681	>
9682	>
9683	>
9684	>
9685	>
9686	>
9687	>
9688	>
9689	>
9690	>
9691	>
9692	>
9693	>
9694	>
9695	>
9696	>
9697	>
9698	>
9699	>
9700	>
9701	>
9702	>
9703	>	for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9704	>	do
9705	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9707	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9709	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9710	>	else
9711	>	cat >conftest.$ac_ext <<_ACEOF
9712	>	/* confdefs.h.  */
9713	>	_ACEOF
9714	>	cat confdefs.h >>conftest.$ac_ext
9715	>	cat >>conftest.$ac_ext <<_ACEOF
9716	>	/* end confdefs.h.  */
9717	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719	>	#define $ac_func innocuous_$ac_func
9720	>
9721	>	/* System header to define __stub macros and hopefully few prototypes,
9722	>	which can conflict with char $ac_func (); below.
9723	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724	>	<limits.h> exists even on freestanding compilers.  */
9725	>
9726	>	#ifdef __STDC__
9727	>	# include <limits.h>
9728	>	#else
9729	>	# include <assert.h>
9730	>	#endif
9731	>
9732	>	#undef $ac_func
9733	>
9734	>	/* Override any gcc2 internal prototype to avoid an error.  */
9735	>	#ifdef __cplusplus
9736	>	extern "C"
9737	>	{
9738	>	#endif
9739	>	/* We use char because int might match the return type of a gcc2
9740	>	builtin and then its argument prototype would still apply.  */
9741	>	char $ac_func ();
9742	>	/* The GNU C library defines this for functions which it implements
9743	>	to always fail with ENOSYS.  Some functions are actually named
9744	>	something starting with __ and the normal name is an alias.  */
9745	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746	>	choke me
9747	>	#else
9748	>	char (*f) () = $ac_func;
9749	>	#endif
9750	>	#ifdef __cplusplus
9751	>	}
9752	>	#endif
9753	>
9754	>	#ifdef FC_DUMMY_MAIN
9755	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9756	>	#  ifdef __cplusplus
9757	>	extern "C"
9758	>	#  endif
9759	>	int FC_DUMMY_MAIN() { return 1; }
9760	>	#endif
9761	>	#endif
9762	>	int
9763	>	main ()
9764	>	{
9765	>	return f != $ac_func;
9766	>	;
9767	>	return 0;
9768	>	}
9769	>	_ACEOF
9770	>	rm -f conftest.$ac_objext conftest$ac_exeext
9771	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772	>	(eval $ac_link) 2>conftest.er1
9773	>	ac_status=$?
9774	>	grep -v '^ *+' conftest.er1 >conftest.err
9775	>	rm -f conftest.er1
9776	>	cat conftest.err >&5
9777	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778	>	(exit $ac_status); } &&
9779	>	{ ac_try='test -z "$ac_c_werror_flag"
9780	>	|| test ! -s conftest.err'
9781	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782	>	(eval $ac_try) 2>&5
9783	>	ac_status=$?
9784	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785	>	(exit $ac_status); }; } &&
9786	>	{ ac_try='test -s conftest$ac_exeext'
9787	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788	>	(eval $ac_try) 2>&5
9789	>	ac_status=$?
9790	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791	>	(exit $ac_status); }; }; then
9792	>	eval "$as_ac_var=yes"
9793	>	else
9794	>	echo "$as_me: failed program was:" >&5
9795	>	sed 's/^/| /' conftest.$ac_ext >&5
9796	>
9797	>	eval "$as_ac_var=no"
9798	>	fi
9799	>	rm -f conftest.err conftest.$ac_objext \
9800	>	conftest$ac_exeext conftest.$ac_ext
9801	>	fi
9802	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9805	>	cat >>confdefs.h <<_ACEOF
9806	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807	>	_ACEOF
9808	>
9809	>	fi
9810	>	done
9811	>
9812	>
9813	>	# special check for _system_configuration because AIX <4.3.2 do not
9814	>	# contain the `physmem' member.
9815	>	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817	>	cat >conftest.$ac_ext <<_ACEOF
9818	>	/* confdefs.h.  */
9819	>	_ACEOF
9820	>	cat confdefs.h >>conftest.$ac_ext
9821	>	cat >>conftest.$ac_ext <<_ACEOF
9822	>	/* end confdefs.h.  */
9823	>	#include <sys/systemcfg.h>
9824	>	#ifdef FC_DUMMY_MAIN
9825	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9826	>	#  ifdef __cplusplus
9827	>	extern "C"
9828	>	#  endif
9829	>	int FC_DUMMY_MAIN() { return 1; }
9830	>	#endif
9831	>	#endif
9832	>	int
9833	>	main ()
9834	>	{
9835	>	double x = _system_configuration.physmem;
9836	>	;
9837	>	return 0;
9838	>	}
9839	>	_ACEOF
9840	>	rm -f conftest.$ac_objext
9841	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842	>	(eval $ac_compile) 2>conftest.er1
9843	>	ac_status=$?
9844	>	grep -v '^ *+' conftest.er1 >conftest.err
9845	>	rm -f conftest.er1
9846	>	cat conftest.err >&5
9847	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848	>	(exit $ac_status); } &&
9849	>	{ ac_try='test -z "$ac_c_werror_flag"
9850	>	|| test ! -s conftest.err'
9851	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852	>	(eval $ac_try) 2>&5
9853	>	ac_status=$?
9854	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855	>	(exit $ac_status); }; } &&
9856	>	{ ac_try='test -s conftest.$ac_objext'
9857	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858	>	(eval $ac_try) 2>&5
9859	>	ac_status=$?
9860	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861	>	(exit $ac_status); }; }; then
9862	>	echo "$as_me:$LINENO: result: yes" >&5
9863	>	echo "${ECHO_T}yes" >&6
9864	>
9865	>	cat >>confdefs.h <<\_ACEOF
9866	>	#define HAVE__SYSTEM_CONFIGURATION 1
9867	>	_ACEOF
9868	>
9869	>	else
9870	>	echo "$as_me: failed program was:" >&5
9871	>	sed 's/^/| /' conftest.$ac_ext >&5
9872	>
9873	>	echo "$as_me:$LINENO: result: no" >&5
9874	>	echo "${ECHO_T}no" >&6
9875	>	fi
9876	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877	>
9878	>	# clean out junk possibly left behind by a previous configuration
9879	>	rm -f src/getopt.h
9880	>	# Check for getopt_long support
9881	>
9882	>	for ac_header in getopt.h
9883	>	do
9884	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9887	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9890	>	fi
9891	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893	>	else
9894	>	# Is the header compilable?
9895	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897	>	cat >conftest.$ac_ext <<_ACEOF
9898	>	/* confdefs.h.  */
9899	>	_ACEOF
9900	>	cat confdefs.h >>conftest.$ac_ext
9901	>	cat >>conftest.$ac_ext <<_ACEOF
9902	>	/* end confdefs.h.  */
9903	>	$ac_includes_default
9904	>	#include <$ac_header>
9905	>	_ACEOF
9906	>	rm -f conftest.$ac_objext
9907	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908	>	(eval $ac_compile) 2>conftest.er1
9909	>	ac_status=$?
9910	>	grep -v '^ *+' conftest.er1 >conftest.err
9911	>	rm -f conftest.er1
9912	>	cat conftest.err >&5
9913	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914	>	(exit $ac_status); } &&
9915	>	{ ac_try='test -z "$ac_c_werror_flag"
9916	>	|| test ! -s conftest.err'
9917	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918	>	(eval $ac_try) 2>&5
9919	>	ac_status=$?
9920	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921	>	(exit $ac_status); }; } &&
9922	>	{ ac_try='test -s conftest.$ac_objext'
9923	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924	>	(eval $ac_try) 2>&5
9925	>	ac_status=$?
9926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927	>	(exit $ac_status); }; }; then
9928	>	ac_header_compiler=yes
9929	>	else
9930	>	echo "$as_me: failed program was:" >&5
9931	>	sed 's/^/| /' conftest.$ac_ext >&5
9932	>
9933	>	ac_header_compiler=no
9934	>	fi
9935	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937	>	echo "${ECHO_T}$ac_header_compiler" >&6
9938	>
9939	>	# Is the header present?
9940	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942	>	cat >conftest.$ac_ext <<_ACEOF
9943	>	/* confdefs.h.  */
9944	>	_ACEOF
9945	>	cat confdefs.h >>conftest.$ac_ext
9946	>	cat >>conftest.$ac_ext <<_ACEOF
9947	>	/* end confdefs.h.  */
9948	>	#include <$ac_header>
9949	>	_ACEOF
9950	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952	>	ac_status=$?
9953	>	grep -v '^ *+' conftest.er1 >conftest.err
9954	>	rm -f conftest.er1
9955	>	cat conftest.err >&5
9956	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957	>	(exit $ac_status); } >/dev/null; then
9958	>	if test -s conftest.err; then
9959	>	ac_cpp_err=$ac_c_preproc_warn_flag
9960	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961	>	else
9962	>	ac_cpp_err=
9963	>	fi
9964	>	else
9965	>	ac_cpp_err=yes
9966	>	fi
9967	>	if test -z "$ac_cpp_err"; then
9968	>	ac_header_preproc=yes
9969	>	else
9970	>	echo "$as_me: failed program was:" >&5
9971	>	sed 's/^/| /' conftest.$ac_ext >&5
9972	>
9973	>	ac_header_preproc=no
9974	>	fi
9975	>	rm -f conftest.err conftest.$ac_ext
9976	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977	>	echo "${ECHO_T}$ac_header_preproc" >&6
9978	>
9979	>	# So?  What about this header?
9980	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981	>	yes:no: )
9982	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986	>	ac_header_preproc=yes
9987	>	;;
9988	>	no:yes:* )
9989	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001	>	(
10002	>	cat <<\_ASBOX
10003	>	## ------------------------------ ##
10004	>	## Report this to gezelter@nd.edu ##
10005	>	## ------------------------------ ##
10006	>	_ASBOX
10007	>	) |
10008	>	sed "s/^/$as_me: WARNING:     /" >&2
10009	>	;;
10010	>	esac
10011	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10012	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10015	>	else
10016	>	eval "$as_ac_Header=\$ac_header_preproc"
10017	>	fi
10018	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020	>
10021	>	fi
10022	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023	>	cat >>confdefs.h <<_ACEOF
10024	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025	>	_ACEOF
10026	>
10027	>	fi
10028	>
10029	>	done
10030	>
10031	>
10032	>	for ac_func in getopt_long
10033	>	do
10034	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
10036	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
10038	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10039	>	else
10040	>	cat >conftest.$ac_ext <<_ACEOF
10041	>	/* confdefs.h.  */
10042	>	_ACEOF
10043	>	cat confdefs.h >>conftest.$ac_ext
10044	>	cat >>conftest.$ac_ext <<_ACEOF
10045	>	/* end confdefs.h.  */
10046	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048	>	#define $ac_func innocuous_$ac_func
10049	>
10050	>	/* System header to define __stub macros and hopefully few prototypes,
10051	>	which can conflict with char $ac_func (); below.
10052	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053	>	<limits.h> exists even on freestanding compilers.  */
10054	>
10055	>	#ifdef __STDC__
10056	>	# include <limits.h>
10057	>	#else
10058	>	# include <assert.h>
10059	>	#endif
10060	>
10061	>	#undef $ac_func
10062	>
10063	>	/* Override any gcc2 internal prototype to avoid an error.  */
10064	>	#ifdef __cplusplus
10065	>	extern "C"
10066	>	{
10067	>	#endif
10068	>	/* We use char because int might match the return type of a gcc2
10069	>	builtin and then its argument prototype would still apply.  */
10070	>	char $ac_func ();
10071	>	/* The GNU C library defines this for functions which it implements
10072	>	to always fail with ENOSYS.  Some functions are actually named
10073	>	something starting with __ and the normal name is an alias.  */
10074	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075	>	choke me
10076	>	#else
10077	>	char (*f) () = $ac_func;
10078	>	#endif
10079	>	#ifdef __cplusplus
10080	>	}
10081	>	#endif
10082	>
10083	>	#ifdef FC_DUMMY_MAIN
10084	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10085	>	#  ifdef __cplusplus
10086	>	extern "C"
10087	>	#  endif
10088	>	int FC_DUMMY_MAIN() { return 1; }
10089	>	#endif
10090	>	#endif
10091	>	int
10092	>	main ()
10093	>	{
10094	>	return f != $ac_func;
10095	>	;
10096	>	return 0;
10097	>	}
10098	>	_ACEOF
10099	>	rm -f conftest.$ac_objext conftest$ac_exeext
10100	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10101	>	(eval $ac_link) 2>conftest.er1
10102	>	ac_status=$?
10103	>	grep -v '^ *+' conftest.er1 >conftest.err
10104	>	rm -f conftest.er1
10105	>	cat conftest.err >&5
10106	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10107	>	(exit $ac_status); } &&
10108	>	{ ac_try='test -z "$ac_c_werror_flag"
10109	>	|| test ! -s conftest.err'
10110	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10111	>	(eval $ac_try) 2>&5
10112	>	ac_status=$?
10113	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10114	>	(exit $ac_status); }; } &&
10115	>	{ ac_try='test -s conftest$ac_exeext'
10116	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10117	>	(eval $ac_try) 2>&5
10118	>	ac_status=$?
10119	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120	>	(exit $ac_status); }; }; then
10121	>	eval "$as_ac_var=yes"
10122	>	else
10123	>	echo "$as_me: failed program was:" >&5
10124	>	sed 's/^/| /' conftest.$ac_ext >&5
10125	>
10126	>	eval "$as_ac_var=no"
10127	>	fi
10128	>	rm -f conftest.err conftest.$ac_objext \
10129	>	conftest$ac_exeext conftest.$ac_ext
10130	>	fi
10131	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
10134	>	cat >>confdefs.h <<_ACEOF
10135	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136	>	_ACEOF
10137	>
10138	>	else
10139	>	# FreeBSD has a gnugetopt library for this
10140	>	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141	>	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142	>	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10144	>	else
10145	>	ac_check_lib_save_LIBS=$LIBS
10146	>	LIBS="-lgnugetopt  $LIBS"
10147	>	cat >conftest.$ac_ext <<_ACEOF
10148	>	/* confdefs.h.  */
10149	>	_ACEOF
10150	>	cat confdefs.h >>conftest.$ac_ext
10151	>	cat >>conftest.$ac_ext <<_ACEOF
10152	>	/* end confdefs.h.  */
10153	>
10154	>	/* Override any gcc2 internal prototype to avoid an error.  */
10155	>	#ifdef __cplusplus
10156	>	extern "C"
10157	>	#endif
10158	>	/* We use char because int might match the return type of a gcc2
10159	>	builtin and then its argument prototype would still apply.  */
10160	>	char getopt_long ();
10161	>	#ifdef FC_DUMMY_MAIN
10162	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10163	>	#  ifdef __cplusplus
10164	>	extern "C"
10165	>	#  endif
10166	>	int FC_DUMMY_MAIN() { return 1; }
10167	>	#endif
10168	>	#endif
10169	>	int
10170	>	main ()
10171	>	{
10172	>	getopt_long ();
10173	>	;
10174	>	return 0;
10175	>	}
10176	>	_ACEOF
10177	>	rm -f conftest.$ac_objext conftest$ac_exeext
10178	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179	>	(eval $ac_link) 2>conftest.er1
10180	>	ac_status=$?
10181	>	grep -v '^ *+' conftest.er1 >conftest.err
10182	>	rm -f conftest.er1
10183	>	cat conftest.err >&5
10184	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10185	>	(exit $ac_status); } &&
10186	>	{ ac_try='test -z "$ac_c_werror_flag"
10187	>	|| test ! -s conftest.err'
10188	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10189	>	(eval $ac_try) 2>&5
10190	>	ac_status=$?
10191	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192	>	(exit $ac_status); }; } &&
10193	>	{ ac_try='test -s conftest$ac_exeext'
10194	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195	>	(eval $ac_try) 2>&5
10196	>	ac_status=$?
10197	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198	>	(exit $ac_status); }; }; then
10199	>	ac_cv_lib_gnugetopt_getopt_long=yes
10200	>	else
10201	>	echo "$as_me: failed program was:" >&5
10202	>	sed 's/^/| /' conftest.$ac_ext >&5
10203	>
10204	>	ac_cv_lib_gnugetopt_getopt_long=no
10205	>	fi
10206	>	rm -f conftest.err conftest.$ac_objext \
10207	>	conftest$ac_exeext conftest.$ac_ext
10208	>	LIBS=$ac_check_lib_save_LIBS
10209	>	fi
10210	>	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211	>	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212	>	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213	>	cat >>confdefs.h <<\_ACEOF
10214	>	#define HAVE_GETOPT_LONG 1
10215	>	_ACEOF
10216	>
10217	>	else
10218	>	# use the GNU replacement
10219	>	case $LIBOBJS in
10220	>	"getopt.$ac_objext"   | \
10221	>	*" getopt.$ac_objext"   | \
10222	>	"getopt.$ac_objext "* | \
10223	>	*" getopt.$ac_objext "* ) ;;
10224	>	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225	>	esac
10226	>
10227	>	case $LIBOBJS in
10228	>	"getopt1.$ac_objext"   | \
10229	>	*" getopt1.$ac_objext"   | \
10230	>	"getopt1.$ac_objext "* | \
10231	>	*" getopt1.$ac_objext "* ) ;;
10232	>	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233	>	esac
10234	>
10235	>	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236
10237		fi
5561	–	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5562	–	cat >>confdefs.h <<_ACEOF
5563	–	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5564	–	_ACEOF
10238
10239		fi
5567	–
10240		done
10241
10242
10243	+	ac_ext=cc
10244	+	ac_cpp='$CXXCPP $CPPFLAGS'
10245	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248
10249
10250	<
10251	<
10252	<	for ac_header in strstream.h iostream.h fstream.h math.h time.h
5576	<	do
5577	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5578	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5579	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
5580	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5581	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10250	>	echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10251	>	echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10252	>	if test "${ac_cv_cxx_namespaces+set}" = set; then
10253		echo $ECHO_N "(cached) $ECHO_C" >&6
5583	–	fi
5584	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5585	–	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10254		else
10255	<	# Is the header compilable?
10256	<	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10257	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10258	<	cat >conftest.$ac_ext <<_ACEOF
10255	>
10256	>
10257	>	ac_ext=cc
10258	>	ac_cpp='$CXXCPP $CPPFLAGS'
10259	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262	>
10263	>	cat >conftest.$ac_ext <<_ACEOF
10264		/* confdefs.h.  */
10265		_ACEOF
10266		cat confdefs.h >>conftest.$ac_ext
10267		cat >>conftest.$ac_ext <<_ACEOF
10268		/* end confdefs.h.  */
10269	<	$ac_includes_default
10270	<	#include <$ac_header>
10269	>	namespace Outer { namespace Inner { int i = 0; }}
10270	>	#ifdef FC_DUMMY_MAIN
10271	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10272	>	#  ifdef __cplusplus
10273	>	extern "C"
10274	>	#  endif
10275	>	int FC_DUMMY_MAIN() { return 1; }
10276	>	#endif
10277	>	#endif
10278	>	int
10279	>	main ()
10280	>	{
10281	>	using namespace Outer::Inner; return i;
10282	>	;
10283	>	return 0;
10284	>	}
10285		_ACEOF
10286		rm -f conftest.$ac_objext
10287		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 5605 | Line 10292 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10292		cat conftest.err >&5
10293		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294		(exit $ac_status); } &&
10295	<	{ ac_try='test -z "$ac_c_werror_flag"
10295	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10296		|| test ! -s conftest.err'
10297		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298		(eval $ac_try) 2>&5
#	Line 5618 | Line 10305 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10305		ac_status=$?
10306		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307		(exit $ac_status); }; }; then
10308	<	ac_header_compiler=yes
10308	>	ac_cv_cxx_namespaces=yes
10309		else
10310		echo "$as_me: failed program was:" >&5
10311		sed 's/^/| /' conftest.$ac_ext >&5
10312
10313	<	ac_header_compiler=no
10313	>	ac_cv_cxx_namespaces=no
10314		fi
10315		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316	<	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10317	<	echo "${ECHO_T}$ac_header_compiler" >&6
10316	>	ac_ext=cc
10317	>	ac_cpp='$CXXCPP $CPPFLAGS'
10318	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10319	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10320	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10321
5632	–	# Is the header present?
5633	–	echo "$as_me:$LINENO: checking $ac_header presence" >&5
5634	–	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5635	–	cat >conftest.$ac_ext <<_ACEOF
5636	–	/* confdefs.h.  */
5637	–	_ACEOF
5638	–	cat confdefs.h >>conftest.$ac_ext
5639	–	cat >>conftest.$ac_ext <<_ACEOF
5640	–	/* end confdefs.h.  */
5641	–	#include <$ac_header>
5642	–	_ACEOF
5643	–	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5644	–	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5645	–	ac_status=$?
5646	–	grep -v '^ *+' conftest.er1 >conftest.err
5647	–	rm -f conftest.er1
5648	–	cat conftest.err >&5
5649	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5650	–	(exit $ac_status); } >/dev/null; then
5651	–	if test -s conftest.err; then
5652	–	ac_cpp_err=$ac_c_preproc_warn_flag
5653	–	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5654	–	else
5655	–	ac_cpp_err=
5656	–	fi
5657	–	else
5658	–	ac_cpp_err=yes
5659	–	fi
5660	–	if test -z "$ac_cpp_err"; then
5661	–	ac_header_preproc=yes
5662	–	else
5663	–	echo "$as_me: failed program was:" >&5
5664	–	sed 's/^/| /' conftest.$ac_ext >&5
10322
5666	–	ac_header_preproc=no
10323		fi
10324	<	rm -f conftest.err conftest.$ac_ext
10325	<	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10326	<	echo "${ECHO_T}$ac_header_preproc" >&6
10324	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325	>	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326	>	if test "$ac_cv_cxx_namespaces" = yes; then
10327
10328	<	# So?  What about this header?
10329	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5674	<	yes:no: )
5675	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5676	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5677	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5678	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5679	<	ac_header_preproc=yes
5680	<	;;
5681	<	no:yes:* )
5682	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5683	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5684	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5685	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5686	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5687	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5688	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5689	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5690	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5691	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5692	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5693	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5694	<	(
5695	<	cat <<\_ASBOX
5696	<	## ------------------------------ ##
5697	<	## Report this to gezelter@nd.edu ##
5698	<	## ------------------------------ ##
5699	<	_ASBOX
5700	<	) |
5701	<	sed "s/^/$as_me: WARNING:     /" >&2
5702	<	;;
5703	<	esac
5704	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
5705	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5706	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5707	<	echo $ECHO_N "(cached) $ECHO_C" >&6
5708	<	else
5709	<	eval "$as_ac_Header=\$ac_header_preproc"
5710	<	fi
5711	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5712	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5713	<
5714	<	fi
5715	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5716	<	cat >>confdefs.h <<_ACEOF
5717	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10328	>	cat >>confdefs.h <<\_ACEOF
10329	>	#define HAVE_NAMESPACES
10330		_ACEOF
10331
10332		fi
10333
5722	–	done
5723	–
10334		ac_ext=cc
10335		ac_cpp='$CXXCPP $CPPFLAGS'
10336		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5729	–
5730	–	ac_ext=cc
5731	–	ac_cpp='$CXXCPP $CPPFLAGS'
5732	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5733	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5734	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339		echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340		echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341		if test -z "$CXXCPP"; then
#	Line 5958 | Line 10562 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10562		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563
10564
10565	+	echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566	+	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567	+	if test "${ac_cv_cxx_have_stl+set}" = set; then
10568	+	echo $ECHO_N "(cached) $ECHO_C" >&6
10569	+	else
10570
10571
10572	+
10573	+	ac_ext=cc
10574	+	ac_cpp='$CXXCPP $CPPFLAGS'
10575	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578	+
10579	+	cat >conftest.$ac_ext <<_ACEOF
10580	+	/* confdefs.h.  */
10581	+	_ACEOF
10582	+	cat confdefs.h >>conftest.$ac_ext
10583	+	cat >>conftest.$ac_ext <<_ACEOF
10584	+	/* end confdefs.h.  */
10585	+	#include <list>
10586	+	#include <deque>
10587	+	#ifdef HAVE_NAMESPACES
10588	+	using namespace std;
10589	+	#endif
10590	+	#ifdef FC_DUMMY_MAIN
10591	+	#ifndef FC_DUMMY_MAIN_EQ_F77
10592	+	#  ifdef __cplusplus
10593	+	extern "C"
10594	+	#  endif
10595	+	int FC_DUMMY_MAIN() { return 1; }
10596	+	#endif
10597	+	#endif
10598	+	int
10599	+	main ()
10600	+	{
10601	+	list<int> x; x.push_back(5);
10602	+	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603	+	;
10604	+	return 0;
10605	+	}
10606	+	_ACEOF
10607	+	rm -f conftest.$ac_objext
10608	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10609	+	(eval $ac_compile) 2>conftest.er1
10610	+	ac_status=$?
10611	+	grep -v '^ *+' conftest.er1 >conftest.err
10612	+	rm -f conftest.er1
10613	+	cat conftest.err >&5
10614	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615	+	(exit $ac_status); } &&
10616	+	{ ac_try='test -z "$ac_cxx_werror_flag"
10617	+	|| test ! -s conftest.err'
10618	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10619	+	(eval $ac_try) 2>&5
10620	+	ac_status=$?
10621	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10622	+	(exit $ac_status); }; } &&
10623	+	{ ac_try='test -s conftest.$ac_objext'
10624	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10625	+	(eval $ac_try) 2>&5
10626	+	ac_status=$?
10627	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628	+	(exit $ac_status); }; }; then
10629	+	ac_cv_cxx_have_stl=yes
10630	+	else
10631	+	echo "$as_me: failed program was:" >&5
10632	+	sed 's/^/| /' conftest.$ac_ext >&5
10633
10634	+	ac_cv_cxx_have_stl=no
10635	+	fi
10636	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637	+	ac_ext=cc
10638	+	ac_cpp='$CXXCPP $CPPFLAGS'
10639	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10641	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10642
10643
10644	<	for ac_header in ctype.h iostream fstream sstream strstream
10645	<	do
10646	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10647	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10648	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
10649	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10650	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10644	>	fi
10645	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646	>	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647	>	if test "$ac_cv_cxx_have_stl" = yes; then
10648	>
10649	>	cat >>confdefs.h <<\_ACEOF
10650	>	#define HAVE_STL
10651	>	_ACEOF
10652	>
10653	>	fi
10654	>
10655	>
10656	>
10657	>	if test "${ac_cv_header_iostream+set}" = set; then
10658	>	echo "$as_me:$LINENO: checking for iostream" >&5
10659	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660	>	if test "${ac_cv_header_iostream+set}" = set; then
10661		echo $ECHO_N "(cached) $ECHO_C" >&6
10662		fi
10663	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10664	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10663	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665		else
10666		# Is the header compilable?
10667	<	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10668	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10667	>	echo "$as_me:$LINENO: checking iostream usability" >&5
10668	>	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669		cat >conftest.$ac_ext <<_ACEOF
10670		/* confdefs.h.  */
10671		_ACEOF
#	Line 5985 | Line 10673 | $ac_includes_default
10673		cat >>conftest.$ac_ext <<_ACEOF
10674		/* end confdefs.h.  */
10675		$ac_includes_default
10676	<	#include <$ac_header>
10676	>	#include <iostream>
10677		_ACEOF
10678		rm -f conftest.$ac_objext
10679		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 6021 | Line 10709 | echo "${ECHO_T}$ac_header_compiler" >&6
10709		echo "${ECHO_T}$ac_header_compiler" >&6
10710
10711		# Is the header present?
10712	<	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10713	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10712	>	echo "$as_me:$LINENO: checking iostream presence" >&5
10713	>	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714		cat >conftest.$ac_ext <<_ACEOF
10715		/* confdefs.h.  */
10716		_ACEOF
10717		cat confdefs.h >>conftest.$ac_ext
10718		cat >>conftest.$ac_ext <<_ACEOF
10719		/* end confdefs.h.  */
10720	<	#include <$ac_header>
10720	>	#include <iostream>
10721		_ACEOF
10722		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 6063 | Line 10751 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
10751		# So?  What about this header?
10752		case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753		yes:no: )
10754	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10755	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10757	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10754	>	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755	>	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757	>	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758		ac_header_preproc=yes
10759		;;
10760		no:yes:* )
10761	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10762	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10763	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10764	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10765	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10766	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10767	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10768	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10769	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10770	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10771	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10772	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10761	>	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762	>	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763	>	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764	>	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765	>	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766	>	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767	>	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768	>	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770	>	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771	>	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772	>	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773		(
10774		cat <<\_ASBOX
10775		## ------------------------------ ##
#	Line 6092 | Line 10780 | esac
10780		sed "s/^/$as_me: WARNING:     /" >&2
10781		;;
10782		esac
10783	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
10784	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10785	<	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10783	>	echo "$as_me:$LINENO: checking for iostream" >&5
10784	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785	>	if test "${ac_cv_header_iostream+set}" = set; then
10786		echo $ECHO_N "(cached) $ECHO_C" >&6
10787		else
10788	<	eval "$as_ac_Header=\$ac_header_preproc"
10788	>	ac_cv_header_iostream=$ac_header_preproc
10789		fi
10790	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10791	<	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10790	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792
10793		fi
10794	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
6107	<	cat >>confdefs.h <<_ACEOF
6108	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6109	<	_ACEOF
10794	>	if test $ac_cv_header_iostream = yes; then
10795
6111	–	fi
10796
10797	<	done
10797	>	cat >>confdefs.h <<\_ACEOF
10798	>	#define HAVE_IOSTREAM 1
10799	>	_ACEOF
10800
6115	–	ac_ext=c
6116	–	ac_cpp='$CPP $CPPFLAGS'
6117	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6118	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6119	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
10801
10802	+	else
10803
10804
10805	<
6124	<	for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10805	>	for ac_header in iostream.h
10806		do
10807		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6154 | Line 10835 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10835		cat conftest.err >&5
10836		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837		(exit $ac_status); } &&
10838	<	{ ac_try='test -z "$ac_c_werror_flag"
10838	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10839		|| test ! -s conftest.err'
10840		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841		(eval $ac_try) 2>&5
#	Line 6198 | Line 10879 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10879		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880		(exit $ac_status); } >/dev/null; then
10881		if test -s conftest.err; then
10882	<	ac_cpp_err=$ac_c_preproc_warn_flag
10883	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10882	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10883	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10884		else
10885		ac_cpp_err=
10886		fi
#	Line 6219 | Line 10900 | echo "${ECHO_T}$ac_header_preproc" >&6
10900		echo "${ECHO_T}$ac_header_preproc" >&6
10901
10902		# So?  What about this header?
10903	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10903	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904		yes:no: )
10905		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6271 | Line 10952 | done
10952		done
10953
10954
10955	+	fi
10956
10957
10958
10959	<	for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10959	>
10960	>	if test "${ac_cv_header_iomanip+set}" = set; then
10961	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10962	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963	>	if test "${ac_cv_header_iomanip+set}" = set; then
10964	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10965	>	fi
10966	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968	>	else
10969	>	# Is the header compilable?
10970	>	echo "$as_me:$LINENO: checking iomanip usability" >&5
10971	>	echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10972	>	cat >conftest.$ac_ext <<_ACEOF
10973	>	/* confdefs.h.  */
10974	>	_ACEOF
10975	>	cat confdefs.h >>conftest.$ac_ext
10976	>	cat >>conftest.$ac_ext <<_ACEOF
10977	>	/* end confdefs.h.  */
10978	>	$ac_includes_default
10979	>	#include <iomanip>
10980	>	_ACEOF
10981	>	rm -f conftest.$ac_objext
10982	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10983	>	(eval $ac_compile) 2>conftest.er1
10984	>	ac_status=$?
10985	>	grep -v '^ *+' conftest.er1 >conftest.err
10986	>	rm -f conftest.er1
10987	>	cat conftest.err >&5
10988	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989	>	(exit $ac_status); } &&
10990	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10991	>	|| test ! -s conftest.err'
10992	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993	>	(eval $ac_try) 2>&5
10994	>	ac_status=$?
10995	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10996	>	(exit $ac_status); }; } &&
10997	>	{ ac_try='test -s conftest.$ac_objext'
10998	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10999	>	(eval $ac_try) 2>&5
11000	>	ac_status=$?
11001	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002	>	(exit $ac_status); }; }; then
11003	>	ac_header_compiler=yes
11004	>	else
11005	>	echo "$as_me: failed program was:" >&5
11006	>	sed 's/^/| /' conftest.$ac_ext >&5
11007	>
11008	>	ac_header_compiler=no
11009	>	fi
11010	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11011	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11012	>	echo "${ECHO_T}$ac_header_compiler" >&6
11013	>
11014	>	# Is the header present?
11015	>	echo "$as_me:$LINENO: checking iomanip presence" >&5
11016	>	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017	>	cat >conftest.$ac_ext <<_ACEOF
11018	>	/* confdefs.h.  */
11019	>	_ACEOF
11020	>	cat confdefs.h >>conftest.$ac_ext
11021	>	cat >>conftest.$ac_ext <<_ACEOF
11022	>	/* end confdefs.h.  */
11023	>	#include <iomanip>
11024	>	_ACEOF
11025	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11027	>	ac_status=$?
11028	>	grep -v '^ *+' conftest.er1 >conftest.err
11029	>	rm -f conftest.er1
11030	>	cat conftest.err >&5
11031	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032	>	(exit $ac_status); } >/dev/null; then
11033	>	if test -s conftest.err; then
11034	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11035	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036	>	else
11037	>	ac_cpp_err=
11038	>	fi
11039	>	else
11040	>	ac_cpp_err=yes
11041	>	fi
11042	>	if test -z "$ac_cpp_err"; then
11043	>	ac_header_preproc=yes
11044	>	else
11045	>	echo "$as_me: failed program was:" >&5
11046	>	sed 's/^/| /' conftest.$ac_ext >&5
11047	>
11048	>	ac_header_preproc=no
11049	>	fi
11050	>	rm -f conftest.err conftest.$ac_ext
11051	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11052	>	echo "${ECHO_T}$ac_header_preproc" >&6
11053	>
11054	>	# So?  What about this header?
11055	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056	>	yes:no: )
11057	>	{ echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058	>	echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060	>	echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061	>	ac_header_preproc=yes
11062	>	;;
11063	>	no:yes:* )
11064	>	{ echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065	>	echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067	>	echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068	>	{ echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069	>	echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070	>	{ echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071	>	echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072	>	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073	>	echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074	>	{ echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075	>	echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076	>	(
11077	>	cat <<\_ASBOX
11078	>	## ------------------------------ ##
11079	>	## Report this to gezelter@nd.edu ##
11080	>	## ------------------------------ ##
11081	>	_ASBOX
11082	>	) |
11083	>	sed "s/^/$as_me: WARNING:     /" >&2
11084	>	;;
11085	>	esac
11086	>	echo "$as_me:$LINENO: checking for iomanip" >&5
11087	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088	>	if test "${ac_cv_header_iomanip+set}" = set; then
11089	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11090	>	else
11091	>	ac_cv_header_iomanip=$ac_header_preproc
11092	>	fi
11093	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095	>
11096	>	fi
11097	>	if test $ac_cv_header_iomanip = yes; then
11098	>
11099	>
11100	>	cat >>confdefs.h <<\_ACEOF
11101	>	#define HAVE_IOMANIP 1
11102	>	_ACEOF
11103	>
11104	>
11105	>	else
11106	>
11107	>
11108	>	for ac_header in iomanip.h
11109		do
11110		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6307 | Line 11138 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11138		cat conftest.err >&5
11139		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11140		(exit $ac_status); } &&
11141	<	{ ac_try='test -z "$ac_c_werror_flag"
11141	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11142		|| test ! -s conftest.err'
11143		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11144		(eval $ac_try) 2>&5
#	Line 6351 | Line 11182 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11182		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11183		(exit $ac_status); } >/dev/null; then
11184		if test -s conftest.err; then
11185	<	ac_cpp_err=$ac_c_preproc_warn_flag
11186	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11185	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11186	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187		else
11188		ac_cpp_err=
11189		fi
#	Line 6372 | Line 11203 | echo "${ECHO_T}$ac_header_preproc" >&6
11203		echo "${ECHO_T}$ac_header_preproc" >&6
11204
11205		# So?  What about this header?
11206	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11206	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207		yes:no: )
11208		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6424 | Line 11255 | done
11255		done
11256
11257
11258	<	for ac_header in machine/hal_sysinfo.h
11258	>	fi
11259	>
11260	>
11261	>
11262	>
11263	>	for ac_header in cmath
11264		do
11265		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11266		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 6457 | Line 11293 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11293		cat conftest.err >&5
11294		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295		(exit $ac_status); } &&
11296	<	{ ac_try='test -z "$ac_c_werror_flag"
11296	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11297		|| test ! -s conftest.err'
11298		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11299		(eval $ac_try) 2>&5
#	Line 6501 | Line 11337 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11337		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11338		(exit $ac_status); } >/dev/null; then
11339		if test -s conftest.err; then
11340	<	ac_cpp_err=$ac_c_preproc_warn_flag
11341	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11340	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
11341	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11342		else
11343		ac_cpp_err=
11344		fi
#	Line 6522 | Line 11358 | echo "${ECHO_T}$ac_header_preproc" >&6
11358		echo "${ECHO_T}$ac_header_preproc" >&6
11359
11360		# So?  What about this header?
11361	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11361	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11362		yes:no: )
11363		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11364		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 6576 | Line 11412 | done
11412
11413
11414
11415	<
11416	<	for ac_func in rint snprintf sranddev strncasecmp
11417	<	do
6582	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6583	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
6584	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6585	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
11415	>	echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11416	>	echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11417	>	if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11418		echo $ECHO_N "(cached) $ECHO_C" >&6
11419		else
6588	–	cat >conftest.$ac_ext <<_ACEOF
6589	–	/* confdefs.h.  */
6590	–	_ACEOF
6591	–	cat confdefs.h >>conftest.$ac_ext
6592	–	cat >>conftest.$ac_ext <<_ACEOF
6593	–	/* end confdefs.h.  */
6594	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6595	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6596	–	#define $ac_func innocuous_$ac_func
11420
11421	<	/* System header to define __stub macros and hopefully few prototypes,
11422	<	which can conflict with char $ac_func (); below.
11423	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6601	<	<limits.h> exists even on freestanding compilers.  */
6602	<
6603	<	#ifdef __STDC__
6604	<	# include <limits.h>
6605	<	#else
6606	<	# include <assert.h>
6607	<	#endif
6608	<
6609	<	#undef $ac_func
6610	<
6611	<	/* Override any gcc2 internal prototype to avoid an error.  */
6612	<	#ifdef __cplusplus
6613	<	extern "C"
6614	<	{
6615	<	#endif
6616	<	/* We use char because int might match the return type of a gcc2
6617	<	builtin and then its argument prototype would still apply.  */
6618	<	char $ac_func ();
6619	<	/* The GNU C library defines this for functions which it implements
6620	<	to always fail with ENOSYS.  Some functions are actually named
6621	<	something starting with __ and the normal name is an alias.  */
6622	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6623	<	choke me
6624	<	#else
6625	<	char (*f) () = $ac_func;
6626	<	#endif
6627	<	#ifdef __cplusplus
6628	<	}
6629	<	#endif
6630	<
6631	<	int
6632	<	main ()
6633	<	{
6634	<	return f != $ac_func;
6635	<	;
6636	<	return 0;
6637	<	}
6638	<	_ACEOF
6639	<	rm -f conftest.$ac_objext conftest$ac_exeext
6640	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6641	<	(eval $ac_link) 2>conftest.er1
6642	<	ac_status=$?
6643	<	grep -v '^ *+' conftest.er1 >conftest.err
6644	<	rm -f conftest.er1
6645	<	cat conftest.err >&5
6646	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647	<	(exit $ac_status); } &&
6648	<	{ ac_try='test -z "$ac_c_werror_flag"
6649	<	|| test ! -s conftest.err'
6650	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6651	<	(eval $ac_try) 2>&5
6652	<	ac_status=$?
6653	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6654	<	(exit $ac_status); }; } &&
6655	<	{ ac_try='test -s conftest$ac_exeext'
6656	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6657	<	(eval $ac_try) 2>&5
6658	<	ac_status=$?
6659	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6660	<	(exit $ac_status); }; }; then
6661	<	eval "$as_ac_var=yes"
6662	<	else
6663	<	echo "$as_me: failed program was:" >&5
6664	<	sed 's/^/| /' conftest.$ac_ext >&5
6665	<
6666	<	eval "$as_ac_var=no"
6667	<	fi
6668	<	rm -f conftest.err conftest.$ac_objext \
6669	<	conftest$ac_exeext conftest.$ac_ext
6670	<	fi
6671	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6672	<	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6673	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
6674	<	cat >>confdefs.h <<_ACEOF
6675	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6676	<	_ACEOF
6677	<
6678	<	fi
6679	<	done
11421	>	ac_cv_cxx_have_std_iostream=no
11422	>	ac_cv_cxx_need_use_std_iostream=no
11423	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11424
11425
11426	+	ac_ext=cc
11427	+	ac_cpp='$CXXCPP $CPPFLAGS'
11428	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431
11432	<
6684	<
6685	<
6686	<	for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6687	<	do
6688	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6689	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
6690	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6691	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
6692	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6693	<	else
6694	<	cat >conftest.$ac_ext <<_ACEOF
11432	>	cat >conftest.$ac_ext <<_ACEOF
11433		/* confdefs.h.  */
11434		_ACEOF
11435		cat confdefs.h >>conftest.$ac_ext
11436		cat >>conftest.$ac_ext <<_ACEOF
11437		/* end confdefs.h.  */
6700	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6701	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6702	–	#define $ac_func innocuous_$ac_func
11438
11439	<	/* System header to define __stub macros and hopefully few prototypes,
11440	<	which can conflict with char $ac_func (); below.
6706	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6707	<	<limits.h> exists even on freestanding compilers.  */
6708	<
6709	<	#ifdef __STDC__
6710	<	# include <limits.h>
11439	>	#ifdef HAVE_IOSTREAM
11440	>	#include <iostream>
11441		#else
11442	<	# include <assert.h>
11442	>	#include <iostream.h>
11443		#endif
11444
11445	<	#undef $ac_func
11446	<
11447	<	/* Override any gcc2 internal prototype to avoid an error.  */
11448	<	#ifdef __cplusplus
11449	<	extern "C"
11450	<	{
11445	>	#ifdef FC_DUMMY_MAIN
11446	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11447	>	#  ifdef __cplusplus
11448	>	extern "C"
11449	>	#  endif
11450	>	int FC_DUMMY_MAIN() { return 1; }
11451		#endif
6722	–	/* We use char because int might match the return type of a gcc2
6723	–	builtin and then its argument prototype would still apply.  */
6724	–	char $ac_func ();
6725	–	/* The GNU C library defines this for functions which it implements
6726	–	to always fail with ENOSYS.  Some functions are actually named
6727	–	something starting with __ and the normal name is an alias.  */
6728	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6729	–	choke me
6730	–	#else
6731	–	char (*f) () = $ac_func;
11452		#endif
6733	–	#ifdef __cplusplus
6734	–	}
6735	–	#endif
6736	–
11453		int
11454		main ()
11455		{
11456	<	return f != $ac_func;
6741	<	;
6742	<	return 0;
6743	<	}
6744	<	_ACEOF
6745	<	rm -f conftest.$ac_objext conftest$ac_exeext
6746	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6747	<	(eval $ac_link) 2>conftest.er1
6748	<	ac_status=$?
6749	<	grep -v '^ *+' conftest.er1 >conftest.err
6750	<	rm -f conftest.er1
6751	<	cat conftest.err >&5
6752	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6753	<	(exit $ac_status); } &&
6754	<	{ ac_try='test -z "$ac_c_werror_flag"
6755	<	|| test ! -s conftest.err'
6756	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6757	<	(eval $ac_try) 2>&5
6758	<	ac_status=$?
6759	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6760	<	(exit $ac_status); }; } &&
6761	<	{ ac_try='test -s conftest$ac_exeext'
6762	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6763	<	(eval $ac_try) 2>&5
6764	<	ac_status=$?
6765	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6766	<	(exit $ac_status); }; }; then
6767	<	eval "$as_ac_var=yes"
6768	<	else
6769	<	echo "$as_me: failed program was:" >&5
6770	<	sed 's/^/| /' conftest.$ac_ext >&5
6771	<
6772	<	eval "$as_ac_var=no"
6773	<	fi
6774	<	rm -f conftest.err conftest.$ac_objext \
6775	<	conftest$ac_exeext conftest.$ac_ext
6776	<	fi
6777	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6778	<	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6779	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
6780	<	cat >>confdefs.h <<_ACEOF
6781	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6782	<	_ACEOF
6783	<
6784	<	fi
6785	<	done
6786	<
6787	<	# special check for _system_configuration because AIX <4.3.2 do not
6788	<	# contain the `physmem' member.
6789	<	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6790	<	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6791	<	cat >conftest.$ac_ext <<_ACEOF
6792	<	/* confdefs.h.  */
6793	<	_ACEOF
6794	<	cat confdefs.h >>conftest.$ac_ext
6795	<	cat >>conftest.$ac_ext <<_ACEOF
6796	<	/* end confdefs.h.  */
6797	<	#include <sys/systemcfg.h>
6798	<	int
6799	<	main ()
6800	<	{
6801	<	double x = _system_configuration.physmem;
11456	>	std::cout<<"Hello World"<<std::endl;return 0;
11457		;
11458		return 0;
11459		}
#	Line 6812 | Line 11467 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11467		cat conftest.err >&5
11468		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469		(exit $ac_status); } &&
11470	<	{ ac_try='test -z "$ac_c_werror_flag"
11470	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11471		|| test ! -s conftest.err'
11472		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473		(eval $ac_try) 2>&5
#	Line 6825 | Line 11480 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11480		ac_status=$?
11481		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482		(exit $ac_status); }; }; then
11483	<	echo "$as_me:$LINENO: result: yes" >&5
6829	<	echo "${ECHO_T}yes" >&6
6830	<
6831	<	cat >>confdefs.h <<\_ACEOF
6832	<	#define HAVE__SYSTEM_CONFIGURATION 1
6833	<	_ACEOF
6834	<
11483	>	ac_cv_cxx_have_std_iostream=yes
11484		else
11485		echo "$as_me: failed program was:" >&5
11486		sed 's/^/| /' conftest.$ac_ext >&5
11487
6839	–	echo "$as_me:$LINENO: result: no" >&5
6840	–	echo "${ECHO_T}no" >&6
11488		fi
11489		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490	<	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6844	<	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6845	<	if test "${ac_cv_header_time+set}" = set; then
6846	<	echo $ECHO_N "(cached) $ECHO_C" >&6
6847	<	else
6848	<	cat >conftest.$ac_ext <<_ACEOF
11490	>	cat >conftest.$ac_ext <<_ACEOF
11491		/* confdefs.h.  */
11492		_ACEOF
11493		cat confdefs.h >>conftest.$ac_ext
11494		cat >>conftest.$ac_ext <<_ACEOF
11495		/* end confdefs.h.  */
6854	–	#include <sys/types.h>
6855	–	#include <sys/time.h>
6856	–	#include <time.h>
11496
11497	+	#define __USE_STD_IOSTREAM 1
11498	+	#ifdef HAVE_IOSTREAM
11499	+	#include <iostream>
11500	+	#else
11501	+	#include <iostream.h>
11502	+	#endif
11503	+
11504	+	#ifdef FC_DUMMY_MAIN
11505	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11506	+	#  ifdef __cplusplus
11507	+	extern "C"
11508	+	#  endif
11509	+	int FC_DUMMY_MAIN() { return 1; }
11510	+	#endif
11511	+	#endif
11512		int
11513		main ()
11514		{
11515	<	if ((struct tm *) 0)
6862	<	return 0;
11515	>	std::cout<<"Hello World"<<std::endl;return 0;
11516		;
11517		return 0;
11518		}
#	Line 6873 | Line 11526 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11526		cat conftest.err >&5
11527		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528		(exit $ac_status); } &&
11529	<	{ ac_try='test -z "$ac_c_werror_flag"
11529	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11530		|| test ! -s conftest.err'
11531		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532		(eval $ac_try) 2>&5
#	Line 6886 | Line 11539 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11539		ac_status=$?
11540		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541		(exit $ac_status); }; }; then
11542	<	ac_cv_header_time=yes
11542	>	ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11543		else
11544		echo "$as_me: failed program was:" >&5
11545		sed 's/^/| /' conftest.$ac_ext >&5
11546
6894	–	ac_cv_header_time=no
11547		fi
11548		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549	+	ac_ext=cc
11550	+	ac_cpp='$CXXCPP $CPPFLAGS'
11551	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554	+
11555	+	fi
11556	+
11557		fi
11558	<	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11559	<	echo "${ECHO_T}$ac_cv_header_time" >&6
11560	<	if test $ac_cv_header_time = yes; then
11558	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559	>	echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560	>	if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561
11562		cat >>confdefs.h <<\_ACEOF
11563	<	#define TIME_WITH_SYS_TIME 1
11563	>	#define HAVE_STD_IOSTREAM 1
11564		_ACEOF
11565
11566	<	fi
11566	>	fi
11567	>	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568
11569	+	cat >>confdefs.h <<\_ACEOF
11570	+	#define __USE_STD_IOSTREAM 1
11571	+	_ACEOF
11572
11573	<	echo "$as_me:$LINENO: checking for clock_t" >&5
11574	<	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11575	<	if test "${ac_cv_type_clock_t+set}" = set; then
11573	>	fi
11574	>
11575	>
11576	>
11577	>
11578	>	echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579	>	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580	>	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581		echo $ECHO_N "(cached) $ECHO_C" >&6
11582		else
11583	<	cat >conftest.$ac_ext <<_ACEOF
11583	>
11584	>	ac_cv_cxx_have_std_stl=no
11585	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11586	>
11587	>
11588	>	ac_ext=cc
11589	>	ac_cpp='$CXXCPP $CPPFLAGS'
11590	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593	>
11594	>	cat >conftest.$ac_ext <<_ACEOF
11595		/* confdefs.h.  */
11596		_ACEOF
11597		cat confdefs.h >>conftest.$ac_ext
11598		cat >>conftest.$ac_ext <<_ACEOF
11599		/* end confdefs.h.  */
11600	<	$ac_includes_default
11600	>	#include <list>
11601	>
11602	>	#ifdef FC_DUMMY_MAIN
11603	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11604	>	#  ifdef __cplusplus
11605	>	extern "C"
11606	>	#  endif
11607	>	int FC_DUMMY_MAIN() { return 1; }
11608	>	#endif
11609	>	#endif
11610		int
11611		main ()
11612		{
11613	<	if ((clock_t *) 0)
6925	<	return 0;
6926	<	if (sizeof (clock_t))
6927	<	return 0;
11613	>	std::list<int> foo;return 0;
11614		;
11615		return 0;
11616		}
#	Line 6938 | Line 11624 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11624		cat conftest.err >&5
11625		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626		(exit $ac_status); } &&
11627	<	{ ac_try='test -z "$ac_c_werror_flag"
11627	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11628		|| test ! -s conftest.err'
11629		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11630		(eval $ac_try) 2>&5
#	Line 6951 | Line 11637 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11637		ac_status=$?
11638		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639		(exit $ac_status); }; }; then
11640	<	ac_cv_type_clock_t=yes
11640	>	ac_cv_cxx_have_std_stl=yes
11641		else
11642		echo "$as_me: failed program was:" >&5
11643		sed 's/^/| /' conftest.$ac_ext >&5
11644
6959	–	ac_cv_type_clock_t=no
11645		fi
11646		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647	<	fi
11648	<	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11649	<	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11650	<	if test $ac_cv_type_clock_t = yes; then
11647	>	ac_ext=cc
11648	>	ac_cpp='$CXXCPP $CPPFLAGS'
11649	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652
11653	<	cat >>confdefs.h <<_ACEOF
11654	<	#define HAVE_CLOCK_T 1
11653	>	fi
11654	>
11655	>	fi
11656	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657	>	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658	>	if test "$ac_cv_cxx_have_std_stl" = yes; then
11659	>
11660	>	cat >>confdefs.h <<\_ACEOF
11661	>	#define HAVE_STD_STL 1
11662		_ACEOF
11663
11664	+	fi
11665
6972	–	fi
11666
11667	<	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11668	<	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11669	<	if test "${ac_cv_c_const+set}" = set; then
11667	>
11668	>	echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669	>	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670	>	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671		echo $ECHO_N "(cached) $ECHO_C" >&6
11672		else
11673	<	cat >conftest.$ac_ext <<_ACEOF
11673	>
11674	>	ac_cv_cxx_have_fstream_attach=no
11675	>
11676	>
11677	>	ac_ext=cc
11678	>	ac_cpp='$CXXCPP $CPPFLAGS'
11679	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682	>
11683	>	cat >conftest.$ac_ext <<_ACEOF
11684		/* confdefs.h.  */
11685		_ACEOF
11686		cat confdefs.h >>conftest.$ac_ext
11687		cat >>conftest.$ac_ext <<_ACEOF
11688		/* end confdefs.h.  */
11689
11690	+	#ifdef HAVE_IOSTREAM
11691	+	#include <fstream>
11692	+	#else
11693	+	#include <fstream.h>
11694	+	#endif
11695	+	#ifdef HAVE_STD_IOSTREAM
11696	+	using namespace std;
11697	+	#endif
11698	+
11699	+	#ifdef FC_DUMMY_MAIN
11700	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11701	+	#  ifdef __cplusplus
11702	+	extern "C"
11703	+	#  endif
11704	+	int FC_DUMMY_MAIN() { return 1; }
11705	+	#endif
11706	+	#endif
11707		int
11708		main ()
11709		{
11710	<	/* FIXME: Include the comments suggested by Paul. */
6990	<	#ifndef __cplusplus
6991	<	/* Ultrix mips cc rejects this.  */
6992	<	typedef int charset[2];
6993	<	const charset x;
6994	<	/* SunOS 4.1.1 cc rejects this.  */
6995	<	char const *const *ccp;
6996	<	char **p;
6997	<	/* NEC SVR4.0.2 mips cc rejects this.  */
6998	<	struct point {int x, y;};
6999	<	static struct point const zero = {0,0};
7000	<	/* AIX XL C 1.02.0.0 rejects this.
7001	<	It does not let you subtract one const X* pointer from another in
7002	<	an arm of an if-expression whose if-part is not a constant
7003	<	expression */
7004	<	const char *g = "string";
7005	<	ccp = &g + (g ? g-g : 0);
7006	<	/* HPUX 7.0 cc rejects these. */
7007	<	++ccp;
7008	<	p = (char**) ccp;
7009	<	ccp = (char const *const *) p;
7010	<	{ /* SCO 3.2v4 cc rejects this.  */
7011	<	char *t;
7012	<	char const *s = 0 ? (char *) 0 : (char const *) 0;
7013	<
7014	<	*t++ = 0;
7015	<	}
7016	<	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7017	<	int x[] = {25, 17};
7018	<	const int *foo = &x[0];
7019	<	++foo;
7020	<	}
7021	<	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7022	<	typedef const int *iptr;
7023	<	iptr p = 0;
7024	<	++p;
7025	<	}
7026	<	{ /* AIX XL C 1.02.0.0 rejects this saying
7027	<	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7028	<	struct s { int j; const int *ap[3]; };
7029	<	struct s *b; b->j = 5;
7030	<	}
7031	<	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7032	<	const int foo = 10;
7033	<	}
7034	<	#endif
7035	<
11710	>	int fd=0;ofstream s;s.attach(fd);
11711		;
11712		return 0;
11713		}
#	Line 7046 | Line 11721 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11721		cat conftest.err >&5
11722		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723		(exit $ac_status); } &&
11724	<	{ ac_try='test -z "$ac_c_werror_flag"
11724	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11725		|| test ! -s conftest.err'
11726		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727		(eval $ac_try) 2>&5
#	Line 7059 | Line 11734 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11734		ac_status=$?
11735		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736		(exit $ac_status); }; }; then
11737	<	ac_cv_c_const=yes
11737	>	ac_cv_cxx_have_fstream_attach=yes
11738		else
11739		echo "$as_me: failed program was:" >&5
11740		sed 's/^/| /' conftest.$ac_ext >&5
11741
7067	–	ac_cv_c_const=no
11742		fi
11743		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744	<	fi
11745	<	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
11746	<	echo "${ECHO_T}$ac_cv_c_const" >&6
11747	<	if test $ac_cv_c_const = no; then
11744	>	ac_ext=cc
11745	>	ac_cpp='$CXXCPP $CPPFLAGS'
11746	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749
11750	+
11751	+	fi
11752	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11753	+	echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11754	+	if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11755	+
11756		cat >>confdefs.h <<\_ACEOF
11757	<	#define const
11757	>	#define HAVE_FSTREAM_ATTACH 1
11758		_ACEOF
11759
11760	<	fi
11760	>	fi
11761
11762	<	echo "$as_me:$LINENO: checking for inline" >&5
11763	<	echo $ECHO_N "checking for inline... $ECHO_C" >&6
11764	<	if test "${ac_cv_c_inline+set}" = set; then
11762	>
11763	>
11764	>	echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765	>	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766	>	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767		echo $ECHO_N "(cached) $ECHO_C" >&6
11768		else
11769	<	ac_cv_c_inline=no
11770	<	for ac_kw in inline __inline__ __inline; do
11771	<	cat >conftest.$ac_ext <<_ACEOF
11769	>
11770	>	ac_cv_cxx_have_fstream_open=no
11771	>	ac_cv_cxx_fstream_open_prot=no
11772	>
11773	>
11774	>	ac_ext=cc
11775	>	ac_cpp='$CXXCPP $CPPFLAGS'
11776	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779	>
11780	>	# Try with 2 parameters
11781	>	cat >conftest.$ac_ext <<_ACEOF
11782		/* confdefs.h.  */
11783		_ACEOF
11784		cat confdefs.h >>conftest.$ac_ext
11785		cat >>conftest.$ac_ext <<_ACEOF
11786		/* end confdefs.h.  */
11787	<	#ifndef __cplusplus
11788	<	typedef int foo_t;
11789	<	static $ac_kw foo_t static_foo () {return 0; }
11790	<	$ac_kw foo_t foo () {return 0; }
11787	>
11788	>	#ifdef HAVE_IOSTREAM
11789	>	#include <fstream>
11790	>	#else
11791	>	#include <fstream.h>
11792		#endif
11793	+	#ifdef HAVE_STD_IOSTREAM
11794	+	using namespace std;
11795	+	#endif
11796
11797	+	#ifdef FC_DUMMY_MAIN
11798	+	#ifndef FC_DUMMY_MAIN_EQ_F77
11799	+	#  ifdef __cplusplus
11800	+	extern "C"
11801	+	#  endif
11802	+	int FC_DUMMY_MAIN() { return 1; }
11803	+	#endif
11804	+	#endif
11805	+	int
11806	+	main ()
11807	+	{
11808	+	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809	+	;
11810	+	return 0;
11811	+	}
11812		_ACEOF
11813		rm -f conftest.$ac_objext
11814		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 7107 | Line 11819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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"
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
#	Line 7120 | Line 11832 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11832		ac_status=$?
11833		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834		(exit $ac_status); }; }; then
11835	<	ac_cv_c_inline=$ac_kw; break
11835	>	ac_cv_cxx_have_fstream_open=yes
11836		else
11837		echo "$as_me: failed program was:" >&5
11838		sed 's/^/| /' conftest.$ac_ext >&5
11839
11840		fi
11841		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842	<	done
11843	<
7132	<	fi
7133	<	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7134	<	echo "${ECHO_T}$ac_cv_c_inline" >&6
7135	<
7136	<
7137	<	case $ac_cv_c_inline in
7138	<	inline | yes) ;;
7139	<	*)
7140	<	case $ac_cv_c_inline in
7141	<	no) ac_val=;;
7142	<	*) ac_val=$ac_cv_c_inline;;
7143	<	esac
7144	<	cat >>confdefs.h <<_ACEOF
7145	<	#ifndef __cplusplus
7146	<	#define inline $ac_val
7147	<	#endif
7148	<	_ACEOF
7149	<	;;
7150	<	esac
7151	<
7152	<
7153	<
7154	<
7155	<	for ac_func in rint sranddev
7156	<	do
7157	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7158	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
7159	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7160	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
7161	<	echo $ECHO_N "(cached) $ECHO_C" >&6
7162	<	else
7163	<	cat >conftest.$ac_ext <<_ACEOF
11842	>	# Try with mode parameter
11843	>	cat >conftest.$ac_ext <<_ACEOF
11844		/* confdefs.h.  */
11845		_ACEOF
11846		cat confdefs.h >>conftest.$ac_ext
11847		cat >>conftest.$ac_ext <<_ACEOF
11848		/* end confdefs.h.  */
7169	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7170	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7171	–	#define $ac_func innocuous_$ac_func
11849
11850	<	/* System header to define __stub macros and hopefully few prototypes,
11851	<	which can conflict with char $ac_func (); below.
7175	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7176	<	<limits.h> exists even on freestanding compilers.  */
7177	<
7178	<	#ifdef __STDC__
7179	<	# include <limits.h>
11850	>	#ifdef HAVE_IOSTREAM
11851	>	#include <fstream>
11852		#else
11853	<	# include <assert.h>
11853	>	#include <fstream.h>
11854		#endif
11855	<
11856	<	#undef $ac_func
7185	<
7186	<	/* Override any gcc2 internal prototype to avoid an error.  */
7187	<	#ifdef __cplusplus
7188	<	extern "C"
7189	<	{
11855	>	#ifdef HAVE_STD_IOSTREAM
11856	>	using namespace std;
11857		#endif
11858	<	/* We use char because int might match the return type of a gcc2
11859	<	builtin and then its argument prototype would still apply.  */
11860	<	char $ac_func ();
11861	<	/* The GNU C library defines this for functions which it implements
11862	<	to always fail with ENOSYS.  Some functions are actually named
11863	<	something starting with __ and the normal name is an alias.  */
11864	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7198	<	choke me
7199	<	#else
7200	<	char (*f) () = $ac_func;
11858	>
11859	>	#ifdef FC_DUMMY_MAIN
11860	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11861	>	#  ifdef __cplusplus
11862	>	extern "C"
11863	>	#  endif
11864	>	int FC_DUMMY_MAIN() { return 1; }
11865		#endif
7202	–	#ifdef __cplusplus
7203	–	}
11866		#endif
7205	–
11867		int
11868		main ()
11869		{
11870	<	return f != $ac_func;
11870	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871		;
11872		return 0;
11873		}
11874		_ACEOF
11875	<	rm -f conftest.$ac_objext conftest$ac_exeext
11876	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11877	<	(eval $ac_link) 2>conftest.er1
11875	>	rm -f conftest.$ac_objext
11876	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11877	>	(eval $ac_compile) 2>conftest.er1
11878		ac_status=$?
11879		grep -v '^ *+' conftest.er1 >conftest.err
11880		rm -f conftest.er1
11881		cat conftest.err >&5
11882		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883		(exit $ac_status); } &&
11884	<	{ ac_try='test -z "$ac_c_werror_flag"
11884	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11885		|| test ! -s conftest.err'
11886		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887		(eval $ac_try) 2>&5
11888		ac_status=$?
11889		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11890		(exit $ac_status); }; } &&
11891	<	{ ac_try='test -s conftest$ac_exeext'
11891	>	{ ac_try='test -s conftest.$ac_objext'
11892		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11893		(eval $ac_try) 2>&5
11894		ac_status=$?
11895		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896		(exit $ac_status); }; }; then
11897	<	eval "$as_ac_var=yes"
11897	>	ac_cv_cxx_fstream_open_prot=yes
11898		else
11899		echo "$as_me: failed program was:" >&5
11900		sed 's/^/| /' conftest.$ac_ext >&5
11901
7241	–	eval "$as_ac_var=no"
11902		fi
11903	<	rm -f conftest.err conftest.$ac_objext \
11904	<	conftest$ac_exeext conftest.$ac_ext
11903	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904	>	ac_ext=cc
11905	>	ac_cpp='$CXXCPP $CPPFLAGS'
11906	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909	>
11910	>
11911		fi
11912	<	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11913	<	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11914	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
11915	<	cat >>confdefs.h <<_ACEOF
11916	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11912	>	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11913	>	echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11914	>	if test "$ac_cv_cxx_have_fstream_open" = yes; then
11915	>
11916	>	cat >>confdefs.h <<\_ACEOF
11917	>	#define HAVE_FSTREAM_OPEN 1
11918		_ACEOF
11919
11920	<	fi
11921	<	done
11920	>	fi
11921	>	if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11922
11923	+	cat >>confdefs.h <<\_ACEOF
11924	+	#define FSTREAM_OPEN_PROT 1
11925	+	_ACEOF
11926
11927	<	# clean out junk possibly left behind by a previous configuration
7258	<	rm -f src/getopt.h
7259	<	# Check for getopt_long support
11927	>	fi
11928
11929	<	for ac_header in getopt.h
11929	>
11930	>
11931	>
11932	>
11933	>
11934	>
11935	>	for ac_header in ctype.h iostream fstream sstream strstream
11936		do
11937		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11938		if eval "test \"\${$as_ac_Header+set}\" = set"; then
#	Line 7291 | Line 11965 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11965		cat conftest.err >&5
11966		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11967		(exit $ac_status); } &&
11968	<	{ ac_try='test -z "$ac_c_werror_flag"
11968	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11969		|| test ! -s conftest.err'
11970		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11971		(eval $ac_try) 2>&5
#	Line 7335 | Line 12009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12009		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010		(exit $ac_status); } >/dev/null; then
12011		if test -s conftest.err; then
12012	<	ac_cpp_err=$ac_c_preproc_warn_flag
12013	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
12012	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
12013	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12014		else
12015		ac_cpp_err=
12016		fi
#	Line 7356 | Line 12030 | echo "${ECHO_T}$ac_header_preproc" >&6
12030		echo "${ECHO_T}$ac_header_preproc" >&6
12031
12032		# So?  What about this header?
12033	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12033	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034		yes:no: )
12035		{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036		echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 7407 | Line 12081 | done
12081
12082		done
12083
12084	+	# AC_CPP_FUNC
12085	+	# ------------------ #
12086	+	# Checks to see if ANSI C99 CPP variable __func__ works.
12087	+	# If not, perhaps __FUNCTION__ works instead.
12088	+	# If not, we'll just define __func__ to "".
12089	+	# AC_CPP_FUNC
12090
12091	<	for ac_func in getopt_long
12092	<	do
12093	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12094	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
7415	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7416	<	if eval "test \"\${$as_ac_var+set}\" = set"; then
12091	>
12092	>	echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093	>	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094	>	if test "${ac_cv_cpp_func+set}" = set; then
12095		echo $ECHO_N "(cached) $ECHO_C" >&6
12096		else
12097		cat >conftest.$ac_ext <<_ACEOF
#	Line 7422 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100		cat confdefs.h >>conftest.$ac_ext
12101		cat >>conftest.$ac_ext <<_ACEOF
12102		/* end confdefs.h.  */
7425	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7426	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7427	–	#define $ac_func innocuous_$ac_func
12103
12104	<	/* System header to define __stub macros and hopefully few prototypes,
12105	<	which can conflict with char $ac_func (); below.
12106	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12107	<	<limits.h> exists even on freestanding compilers.  */
12108	<
12109	<	#ifdef __STDC__
7435	<	# include <limits.h>
7436	<	#else
7437	<	# include <assert.h>
7438	<	#endif
7439	<
7440	<	#undef $ac_func
7441	<
7442	<	/* Override any gcc2 internal prototype to avoid an error.  */
7443	<	#ifdef __cplusplus
7444	<	extern "C"
7445	<	{
7446	<	#endif
7447	<	/* We use char because int might match the return type of a gcc2
7448	<	builtin and then its argument prototype would still apply.  */
7449	<	char $ac_func ();
7450	<	/* The GNU C library defines this for functions which it implements
7451	<	to always fail with ENOSYS.  Some functions are actually named
7452	<	something starting with __ and the normal name is an alias.  */
7453	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7454	<	choke me
7455	<	#else
7456	<	char (*f) () = $ac_func;
12104	>	#ifdef FC_DUMMY_MAIN
12105	>	#ifndef FC_DUMMY_MAIN_EQ_F77
12106	>	#  ifdef __cplusplus
12107	>	extern "C"
12108	>	#  endif
12109	>	int FC_DUMMY_MAIN() { return 1; }
12110		#endif
7458	–	#ifdef __cplusplus
7459	–	}
12111		#endif
7461	–
12112		int
12113		main ()
12114		{
12115	<	return f != $ac_func;
12115	>	const char *foo = __func__;
12116		;
12117		return 0;
12118		}
12119		_ACEOF
12120	<	rm -f conftest.$ac_objext conftest$ac_exeext
12121	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12122	<	(eval $ac_link) 2>conftest.er1
12120	>	rm -f conftest.$ac_objext
12121	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12122	>	(eval $ac_compile) 2>conftest.er1
12123		ac_status=$?
12124		grep -v '^ *+' conftest.er1 >conftest.err
12125		rm -f conftest.er1
12126		cat conftest.err >&5
12127		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128		(exit $ac_status); } &&
12129	<	{ ac_try='test -z "$ac_c_werror_flag"
12129	>	{ ac_try='test -z "$ac_cxx_werror_flag"
12130		|| test ! -s conftest.err'
12131		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12132		(eval $ac_try) 2>&5
12133		ac_status=$?
12134		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12135		(exit $ac_status); }; } &&
12136	<	{ ac_try='test -s conftest$ac_exeext'
12136	>	{ ac_try='test -s conftest.$ac_objext'
12137		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12138		(eval $ac_try) 2>&5
12139		ac_status=$?
12140		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12141		(exit $ac_status); }; }; then
12142	<	eval "$as_ac_var=yes"
12142	>	ac_cv_cpp_func=yes
12143		else
12144		echo "$as_me: failed program was:" >&5
12145		sed 's/^/| /' conftest.$ac_ext >&5
12146
7497	–	eval "$as_ac_var=no"
7498	–	fi
7499	–	rm -f conftest.err conftest.$ac_objext \
7500	–	conftest$ac_exeext conftest.$ac_ext
7501	–	fi
7502	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7503	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7504	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
7505	–	cat >>confdefs.h <<_ACEOF
7506	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7507	–	_ACEOF
7508	–
7509	–	else
7510	–	# FreeBSD has a gnugetopt library for this
7511	–	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7512	–	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7513	–	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7514	–	echo $ECHO_N "(cached) $ECHO_C" >&6
7515	–	else
7516	–	ac_check_lib_save_LIBS=$LIBS
7517	–	LIBS="-lgnugetopt  $LIBS"
12147		cat >conftest.$ac_ext <<_ACEOF
12148		/* confdefs.h.  */
12149		_ACEOF
#	Line 7522 | Line 12151 | cat >>conftest.$ac_ext <<_ACEOF
12151		cat >>conftest.$ac_ext <<_ACEOF
12152		/* end confdefs.h.  */
12153
12154	<	/* Override any gcc2 internal prototype to avoid an error.  */
12155	<	#ifdef __cplusplus
12156	<	extern "C"
12154	>	#ifdef FC_DUMMY_MAIN
12155	>	#ifndef FC_DUMMY_MAIN_EQ_F77
12156	>	#  ifdef __cplusplus
12157	>	extern "C"
12158	>	#  endif
12159	>	int FC_DUMMY_MAIN() { return 1; }
12160		#endif
12161	<	/* We use char because int might match the return type of a gcc2
7530	<	builtin and then its argument prototype would still apply.  */
7531	<	char getopt_long ();
12161	>	#endif
12162		int
12163		main ()
12164		{
12165	<	getopt_long ();
12165	>	const char *foo = __FUNCTION__;
12166		;
12167		return 0;
12168		}
12169		_ACEOF
12170	<	rm -f conftest.$ac_objext conftest$ac_exeext
12171	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12172	<	(eval $ac_link) 2>conftest.er1
12170	>	rm -f conftest.$ac_objext
12171	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12172	>	(eval $ac_compile) 2>conftest.er1
12173		ac_status=$?
12174		grep -v '^ *+' conftest.er1 >conftest.err
12175		rm -f conftest.er1
12176		cat conftest.err >&5
12177		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12178		(exit $ac_status); } &&
12179	<	{ ac_try='test -z "$ac_c_werror_flag"
12179	>	{ ac_try='test -z "$ac_cxx_werror_flag"
12180		|| test ! -s conftest.err'
12181		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12182		(eval $ac_try) 2>&5
12183		ac_status=$?
12184		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12185		(exit $ac_status); }; } &&
12186	<	{ ac_try='test -s conftest$ac_exeext'
12186	>	{ ac_try='test -s conftest.$ac_objext'
12187		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12188		(eval $ac_try) 2>&5
12189		ac_status=$?
12190		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12191		(exit $ac_status); }; }; then
12192	<	ac_cv_lib_gnugetopt_getopt_long=yes
12192	>	ac_cv_cpp_func=__FUNCTION__
12193		else
12194		echo "$as_me: failed program was:" >&5
12195		sed 's/^/| /' conftest.$ac_ext >&5
12196
12197	<	ac_cv_lib_gnugetopt_getopt_long=no
12197	>	ac_cv_cpp_func=no
12198		fi
12199	<	rm -f conftest.err conftest.$ac_objext \
7570	<	conftest$ac_exeext conftest.$ac_ext
7571	<	LIBS=$ac_check_lib_save_LIBS
12199	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12200		fi
12201	<	echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12202	<	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12203	<	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12204	<	cat >>confdefs.h <<\_ACEOF
12205	<	#define HAVE_GETOPT_LONG 1
12201	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12202	>	fi
12203	>	echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12204	>	echo "${ECHO_T}$ac_cv_cpp_func" >&6
12205	>	if test $ac_cv_cpp_func = __FUNCTION__; then
12206	>
12207	>	cat >>confdefs.h <<\_ACEOF
12208	>	#define __func__ __FUNCTION__
12209		_ACEOF
12210
12211	<	else
7581	<	# use the GNU replacement
7582	<	case $LIBOBJS in
7583	<	"getopt.$ac_objext"   | \
7584	<	*" getopt.$ac_objext"   | \
7585	<	"getopt.$ac_objext "* | \
7586	<	*" getopt.$ac_objext "* ) ;;
7587	<	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7588	<	esac
12211	>	elif test $ac_cv_cpp_func = no; then
12212
12213	<	case $LIBOBJS in
12214	<	"getopt1.$ac_objext"   | \
12215	<	*" getopt1.$ac_objext"   | \
7593	<	"getopt1.$ac_objext "* | \
7594	<	*" getopt1.$ac_objext "* ) ;;
7595	<	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7596	<	esac
12213	>	cat >>confdefs.h <<\_ACEOF
12214	>	#define __func__ ""
12215	>	_ACEOF
12216
7598	–	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7599	–
12217		fi
12218
7602	–	fi
7603	–	done
12219
12220
12221
12222	+
12223		case $debug in
12224		1)
12225		;;
#	Line 7612 | Line 12228 | case $debug in
12228
12229
12230
12231	+	# Try to determine "good" native compiler flags if none specified on command
12232	+	# line
12233
12234	+	if test "$ac_test_FFLAGS" != "set"; then
12235	+	FCFLAGS=""
12236	+	case "${host_cpu}-${host_os}" in
12237
12238	+	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12239	+	FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
12240	+	fi;;
12241	+	rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12242	+	FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12243	+	fi;;
12244	+	powerpc*-aix*)
12245	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12246	+	FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12247	+	echo "*******************************************************"
12248	+	echo "*  You have AIX on an unknown powerpc system.  It is  *"
12249	+	echo "*  recommended that you use                           *"
12250	+	echo "*                                                     *"
12251	+	echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12252	+	echo "*                                 ^^^                 *"
12253	+	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12254	+	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12255	+	echo "*******************************************************"
12256	+	fi;;
12257	+	*darwin*)
12258	+	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12259	+	FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12260	+	fi
12261	+	if test "$FC" = ifort; then
12262	+	FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12263	+	fi;;
12264	+	esac
12265	+
12266	+	if test -n "$CPU_FLAGS"; then
12267	+	FCFLAGS="$FCFLAGS $CPU_FLAGS"
12268	+	fi
12269	+
12270	+	if test -z "$FCFLAGS"; then
12271	+	echo ""
12272	+	echo "*********************************************************"
12273	+	echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12274	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12275	+	echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12276	+	echo "*********************************************************"
12277	+	echo ""
12278	+	FCFLAGS="-O3"
12279	+	fi
12280	+
12281	+
12282	+	echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12283	+	echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12284	+	if test "${ac_guessed_f90flags+set}" = set; then
12285	+	echo $ECHO_N "(cached) $ECHO_C" >&6
12286	+	else
12287	+
12288	+
12289	+
12290	+	ac_ext=${FC_SRCEXT-f}
12291	+	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12292	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12293	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12294	+
12295	+	echo 'program main' > conftest.$ac_ext
12296	+	echo 'end program main' >> conftest.$ac_ext
12297	+	ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12298	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12299	+	(eval $ac_compile) 2>&5
12300	+	ac_status=$?
12301	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12302	+	(exit $ac_status); }; then
12303	+	ac_guessed_f90flags=yes
12304	+	else
12305	+	ac_guessed_f90flags=no
12306	+	fi
12307	+	rm -f conftest*
12308	+	ac_ext=cc
12309	+	ac_cpp='$CXXCPP $CPPFLAGS'
12310	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12311	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12312	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12313	+
12314	+
12315	+	fi
12316	+	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12317	+	echo "${ECHO_T}$ac_guessed_f90flags" >&6
12318	+	if test "$ac_guessed_f90flags" = yes; then
12319	+	:
12320	+
12321	+	else
12322	+	:
12323	+
12324	+	echo ""
12325	+	echo "**********************************************************"
12326	+	echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12327	+	echo "* your compiler.                                        *"
12328	+	echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12329	+	echo "*********************************************************"
12330	+	echo ""
12331	+	FCFLAGS=""
12332	+
12333	+	fi
12334	+
12335	+
12336	+	fi
12337	+
12338	+
12339	+
12340	+
12341	+
12342	+
12343	+
12344		echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12345		echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12346		if test "${ac_cv_prog_really_gcc+set}" = set; then
#	Line 7622 | Line 12349 | cat > conftest.c <<EOF
12349
12350		cat > conftest.c <<EOF
12351		#ifdef __GNUC__
12352	<	#ifndef __INTEL_COMPILER
12352	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12353	>	no;
12354	>	#else
12355		yes;
12356		#endif
12357		#endif
#	Line 7660 | Line 12389 | if test "$ac_test_CFLAGS" != "set"; then
12389		CFLAGS="-O"
12390		fi;;
12391		sparc-solaris2*) if test "$CC" = cc; then
12392	<	CFLAGS="-native -fast -xO5 -dalign"
12392	>	CFLAGS="-O -dalign"
12393		fi;;
12394
12395		alpha*-osf*)  if test "$CC" = cc; then
#	Line 7690 | Line 12419 | if test "$ac_test_CFLAGS" != "set"; then
12419		*darwin*)
12420		if test "$CC" = xlc -o "$CC" = cc; then
12421		CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12422	+	fi
12423	+	if test "$CC" = icc; then
12424	+	CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12425		fi;;
12426		esac
12427
#	Line 7703 | Line 12435 | if test "$ac_test_CFLAGS" != "set"; then
12435		# -malign-double for x86 systems
12436
12437
12438	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439	<	echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439	>	echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440		if test "${ac_align_double+set}" = set; then
12441		echo $ECHO_N "(cached) $ECHO_C" >&6
12442		else
12443		echo 'void f(){}' > conftest.c
12444	<	if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444	>	if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445		ac_align_double=yes
12446		else
12447		ac_align_double=no
#	Line 7730 | Line 12462 | fi
12462		# -fstrict-aliasing for gcc-2.95+
12463
12464
12465	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466	<	echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466	>	echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467		if test "${ac_fstrict_aliasing+set}" = set; then
12468		echo $ECHO_N "(cached) $ECHO_C" >&6
12469		else
12470		echo 'void f(){}' > conftest.c
12471	<	if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471	>	if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472		ac_fstrict_aliasing=yes
12473		else
12474		ac_fstrict_aliasing=no
#	Line 7761 | Line 12493 | fi
12493		case "${host_cpu}" in
12494		i586*)
12495
12496	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498		if test "${ac_cpu_pentium+set}" = set; then
12499		echo $ECHO_N "(cached) $ECHO_C" >&6
12500		else
12501		echo 'void f(){}' > conftest.c
12502	<	if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502	>	if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503		ac_cpu_pentium=yes
12504		else
12505		ac_cpu_pentium=no
#	Line 7784 | Line 12516 | else
12516		:
12517
12518
12519	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520	>	echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521		if test "${ac_pentium+set}" = set; then
12522		echo $ECHO_N "(cached) $ECHO_C" >&6
12523		else
12524		echo 'void f(){}' > conftest.c
12525	<	if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525	>	if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526		ac_pentium=yes
12527		else
12528		ac_pentium=no
#	Line 7813 | Line 12545 | fi
12545		;;
12546		i686*)
12547
12548	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550		if test "${ac_cpu_pentiumpro+set}" = set; then
12551		echo $ECHO_N "(cached) $ECHO_C" >&6
12552		else
12553		echo 'void f(){}' > conftest.c
12554	<	if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554	>	if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555		ac_cpu_pentiumpro=yes
12556		else
12557		ac_cpu_pentiumpro=no
#	Line 7836 | Line 12568 | else
12568		:
12569
12570
12571	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572	>	echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573		if test "${ac_pentiumpro+set}" = set; then
12574		echo $ECHO_N "(cached) $ECHO_C" >&6
12575		else
12576		echo 'void f(){}' > conftest.c
12577	<	if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577	>	if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578		ac_pentiumpro=yes
12579		else
12580		ac_pentiumpro=no
#	Line 7869 | Line 12601 | fi
12601		if test -n "$is60x"; then
12602
12603
12604	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606		if test "${ac_m_cpu_60x+set}" = set; then
12607		echo $ECHO_N "(cached) $ECHO_C" >&6
12608		else
12609		echo 'void f(){}' > conftest.c
12610	<	if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610	>	if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611		ac_m_cpu_60x=yes
12612		else
12613		ac_m_cpu_60x=no
#	Line 7927 | Line 12659 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12659		:
12660
12661
12662	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664		if test "${ac_m_cpu_750+set}" = set; then
12665		echo $ECHO_N "(cached) $ECHO_C" >&6
12666		else
12667		echo 'void f(){}' > conftest.c
12668	<	if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668	>	if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669		ac_m_cpu_750=yes
12670		else
12671		ac_m_cpu_750=no
#	Line 7960 | Line 12692 | fi
12692		if test -z "$CPU_FLAGS"; then
12693
12694
12695	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696	>	echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697		if test "${ac_m_cpu_powerpc+set}" = set; then
12698		echo $ECHO_N "(cached) $ECHO_C" >&6
12699		else
12700		echo 'void f(){}' > conftest.c
12701	<	if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701	>	if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702		ac_m_cpu_powerpc=yes
12703		else
12704		ac_m_cpu_powerpc=no
#	Line 7988 | Line 12720 | fi
12720		if test -z "$CPU_FLAGS"; then
12721
12722
12723	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724	<	echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723	>	echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724	>	echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725		if test "${ac_m_powerpc+set}" = set; then
12726		echo $ECHO_N "(cached) $ECHO_C" >&6
12727		else
12728		echo 'void f(){}' > conftest.c
12729	<	if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729	>	if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730		ac_m_powerpc=yes
12731		else
12732		ac_m_powerpc=no
#	Line 8033 | Line 12765 | fi
12765
12766
12767
12768	<	echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769	<	echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768	>	echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769	>	echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770		if test "${ac_guessed_cflags+set}" = set; then
12771		echo $ECHO_N "(cached) $ECHO_C" >&6
12772		else
12773		echo 'void f(){}' > conftest.c
12774	<	if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774	>	if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775		ac_guessed_cflags=yes
12776		else
12777		ac_guessed_cflags=no
#	Line 8083 | Line 12815 | cat > conftest.cpp <<EOF
12815
12816		cat > conftest.cpp <<EOF
12817		#ifdef __GNUC__
12818	<	#ifndef __INTEL_COMPILER
12818	>	#if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12819	>	no;
12820	>	#else
12821		yes;
12822		#endif
12823		#endif
#	Line 8121 | Line 12855 | if test "$ac_test_CXXFLAGS" != "set"; then
12855		CXXFLAGS="-O"
12856		fi;;
12857		sparc-solaris2*) if test "$CXX" = CC; then
12858	<	CXXFLAGS="-native -fast -xO5 -dalign"
12858	>	CXXFLAGS="-features=extensions -O -dalign"
12859		fi;;
12860		rs6000*-aix*)  if test "$CXX" = xlC; then
12861		CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
#	Line 8142 | Line 12876 | if test "$ac_test_CXXFLAGS" != "set"; then
12876		*darwin*)
12877		if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12878		CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12879	+	fi
12880	+	if test "$CXX" = icpc; then
12881	+	CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12882		fi;;
12883		esac
12884
#	Line 8155 | Line 12892 | if test "$ac_test_CXXFLAGS" != "set"; then
12892		# -malign-double for x86 systems
12893
12894
12895	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896	>	echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897		if test "${ac_align_double+set}" = set; then
12898		echo $ECHO_N "(cached) $ECHO_C" >&6
12899		else
12900		echo 'void f(){}' > conftest.cpp
12901	<	if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901	>	if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902		ac_align_double=yes
12903		else
12904		ac_align_double=no
#	Line 8182 | Line 12919 | fi
12919		# -fstrict-aliasing for gcc-2.95+
12920
12921
12922	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923	>	echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924		if test "${ac_fstrict_aliasing+set}" = set; then
12925		echo $ECHO_N "(cached) $ECHO_C" >&6
12926		else
12927		echo 'void f(){}' > conftest.cpp
12928	<	if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928	>	if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929		ac_fstrict_aliasing=yes
12930		else
12931		ac_fstrict_aliasing=no
#	Line 8213 | Line 12950 | fi
12950		case "${host_cpu}" in
12951		i586*)
12952
12953	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955		if test "${ac_cpu_pentium+set}" = set; then
12956		echo $ECHO_N "(cached) $ECHO_C" >&6
12957		else
12958		echo 'void f(){}' > conftest.cpp
12959	<	if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959	>	if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960		ac_cpu_pentium=yes
12961		else
12962		ac_cpu_pentium=no
#	Line 8236 | Line 12973 | else
12973		:
12974
12975
12976	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978		if test "${ac_pentium+set}" = set; then
12979		echo $ECHO_N "(cached) $ECHO_C" >&6
12980		else
12981		echo 'void f(){}' > conftest.cpp
12982	<	if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982	>	if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983		ac_pentium=yes
12984		else
12985		ac_pentium=no
#	Line 8265 | Line 13002 | fi
13002		;;
13003		i686*)
13004
13005	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007		if test "${ac_cpu_pentiumpro+set}" = set; then
13008		echo $ECHO_N "(cached) $ECHO_C" >&6
13009		else
13010		echo 'void f(){}' > conftest.cpp
13011	<	if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011	>	if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012		ac_cpu_pentiumpro=yes
13013		else
13014		ac_cpu_pentiumpro=no
#	Line 8288 | Line 13025 | else
13025		:
13026
13027
13028	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029	>	echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030		if test "${ac_pentiumpro+set}" = set; then
13031		echo $ECHO_N "(cached) $ECHO_C" >&6
13032		else
13033		echo 'void f(){}' > conftest.cpp
13034	<	if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034	>	if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035		ac_pentiumpro=yes
13036		else
13037		ac_pentiumpro=no
#	Line 8321 | Line 13058 | fi
13058		if test -n "$is60x"; then
13059
13060
13061	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063		if test "${ac_m_cpu_60x+set}" = set; then
8327	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8328	–	else
8329	–	echo 'void f(){}' > conftest.cpp
8330	–	if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
8331	–	ac_m_cpu_60x=yes
8332	–	else
8333	–	ac_m_cpu_60x=no
8334	–	fi
8335	–	rm -f conftest*
8336	–
8337	–	fi
8338	–	echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8339	–	echo "${ECHO_T}$ac_m_cpu_60x" >&6
8340	–	if test "$ac_m_cpu_60x" = yes; then
8341	–	:
8342	–	CPU_FLAGS=-mcpu=$cputype
8343	–	else
8344	–	:
8345	–
8346	–	fi
8347	–
8348	–	elif test "$cputype" = 750; then
8349	–
8350	–
8351	–	echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8352	–	echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8353	–	if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13064		echo $ECHO_N "(cached) $ECHO_C" >&6
13065		else
8356	–
8357	–	cat > conftest.cpp <<EOF
8358	–	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8359	–	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8360	–	yes;
8361	–	#  endif
8362	–	#endif
8363	–	EOF
8364	–	if { ac_try='${CXX-c++} -E conftest.cpp'
8365	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8366	–	(eval $ac_try) 2>&5
8367	–	ac_status=$?
8368	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8369	–	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8370	–	ac_cv_prog_gxx_2_95=yes
8371	–	else
8372	–	ac_cv_prog_gxx_2_95=no
8373	–	fi
8374	–
8375	–	fi
8376	–	echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8377	–	echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8378	–	if test "$ac_cv_prog_gxx_2_95" = yes; then
8379	–	:
8380	–
8381	–
8382	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
8383	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
8384	–	if test "${ac_m_cpu_750+set}" = set; then
8385	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8386	–	else
13066		echo 'void f(){}' > conftest.cpp
13067	<	if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13068	<	ac_m_cpu_750=yes
8390	<	else
8391	<	ac_m_cpu_750=no
8392	<	fi
8393	<	rm -f conftest*
8394	<
8395	<	fi
8396	<	echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8397	<	echo "${ECHO_T}$ac_m_cpu_750" >&6
8398	<	if test "$ac_m_cpu_750" = yes; then
8399	<	:
8400	<	CPU_FLAGS=-mcpu=750
8401	<	else
8402	<	:
8403	<
8404	<	fi
8405	<
8406	<	else
8407	<	:
8408	<
8409	<	fi
8410	<
8411	<	fi
8412	<	if test -z "$CPU_FLAGS"; then
8413	<
8414	<
8415	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
8416	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
8417	<	if test "${ac_m_cpu_powerpc+set}" = set; then
8418	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8419	<	else
8420	<	echo 'void f(){}' > conftest.cpp
8421	<	if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
8422	<	ac_m_cpu_powerpc=yes
8423	<	else
8424	<	ac_m_cpu_powerpc=no
8425	<	fi
8426	<	rm -f conftest*
8427	<
8428	<	fi
8429	<	echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
8430	<	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8431	<	if test "$ac_m_cpu_powerpc" = yes; then
8432	<	:
8433	<	CPU_FLAGS=-mcpu=powerpc
8434	<	else
8435	<	:
8436	<
8437	<	fi
8438	<
8439	<	fi
8440	<	if test -z "$CPU_FLAGS"; then
8441	<
8442	<
8443	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8444	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8445	<	if test "${ac_m_powerpc+set}" = set; then
8446	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8447	<	else
8448	<	echo 'void f(){}' > conftest.cpp
8449	<	if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8450	<	ac_m_powerpc=yes
8451	<	else
8452	<	ac_m_powerpc=no
8453	<	fi
8454	<	rm -f conftest*
8455	<
8456	<	fi
8457	<	echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8458	<	echo "${ECHO_T}$ac_m_powerpc" >&6
8459	<	if test "$ac_m_powerpc" = yes; then
8460	<	:
8461	<	CPU_FLAGS=-mpowerpc
8462	<	else
8463	<	:
8464	<
8465	<	fi
8466	<
8467	<	fi
8468	<	esac
8469	<	fi
8470	<
8471	<	if test -n "$CPU_FLAGS"; then
8472	<	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8473	<	fi
8474	<
8475	<	if test -z "$CXXFLAGS"; then
8476	<	echo ""
8477	<	echo "**********************************************************"
8478	<	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8479	<	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8480	<	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8481	<	echo "**********************************************************"
8482	<	echo ""
8483	<	CXXFLAGS="-O3"
8484	<	fi
8485	<
8486	<
8487	<
8488	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8489	<	echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8490	<	if test "${ac_guessed_cxxflags+set}" = set; then
8491	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8492	<	else
8493	<	echo 'void f(){}' > conftest.cpp
8494	<	if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8495	<	ac_guessed_cxxflags=yes
8496	<	else
8497	<	ac_guessed_cxxflags=no
8498	<	fi
8499	<	rm -f conftest*
8500	<
8501	<	fi
8502	<	echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
8503	<	echo "${ECHO_T}$ac_guessed_cxxflags" >&6
8504	<	if test "$ac_guessed_cxxflags" = yes; then
8505	<	:
8506	<
8507	<	else
8508	<	:
8509	<
8510	<	echo ""
8511	<	echo "**********************************************************"
8512	<	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8513	<	echo "* your compiler.                                         *"
8514	<	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8515	<	echo "**********************************************************"
8516	<	echo ""
8517	<	CXXFLAGS=""
8518	<
8519	<	fi
8520	<
8521	<
8522	<	fi
8523	<
8524	<
8525	<
8526	<
8527	<
8528	<	# Try to determine "good" native compiler flags if none specified on command
8529	<	# line
8530	<
8531	<	if test x"$F90FLAGS" = x ; then
8532	<	F90FLAGS=""
8533	<	case "${host_cpu}-${host_os}" in
8534	<
8535	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8536	<	F90FLAGS="-O"
8537	<	fi;;
8538	<	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8539	<	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8540	<	fi;;
8541	<	powerpc*-aix*)
8542	<	if test "$F90" = f90 -o "$F90" = xlf90; then
8543	<	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8544	<	echo "*******************************************************"
8545	<	echo "*  You have AIX on an unknown powerpc system.  It is  *"
8546	<	echo "*  recommended that you use                           *"
8547	<	echo "*                                                     *"
8548	<	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8549	<	echo "*                                 ^^^                 *"
8550	<	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8551	<	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8552	<	echo "*******************************************************"
8553	<	fi;;
8554	<	*darwin*)
8555	<	if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8556	<	F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8557	<	fi;;
8558	<	esac
8559	<
8560	<	if test -n "$CPU_FLAGS"; then
8561	<	F90FLAGS="$F90FLAGS $CPU_FLAGS"
8562	<	fi
8563	<
8564	<	if test -z "$F90FLAGS"; then
8565	<	echo ""
8566	<	echo "**********************************************************"
8567	<	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8568	<	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8569	<	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8570	<	echo "**********************************************************"
8571	<	echo ""
8572	<	F90FLAGS="-O3"
8573	<	fi
8574	<
8575	<
8576	<	echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8577	<	echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8578	<	if test "${ac_guessed_f90flags+set}" = set; then
8579	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8580	<	else
8581	<
8582	<
8583	<
8584	<	ac_ext=f90
8585	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8586	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8587	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8588	<
8589	<	echo 'program main' > conftest.$ac_ext
8590	<	echo 'end program main' >> conftest.$ac_ext
8591	<	ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8592	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8593	<	(eval $ac_compile) 2>&5
8594	<	ac_status=$?
8595	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8596	<	(exit $ac_status); }; then
8597	<	ac_guessed_f90flags=yes
8598	<	else
8599	<	ac_guessed_f90flags=no
8600	<	fi
8601	<	rm -f conftest*
8602	<	ac_ext=c
8603	<	ac_cpp='$CPP $CPPFLAGS'
8604	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8605	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8606	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
8607	<
8608	<
8609	<	fi
8610	<	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8611	<	echo "${ECHO_T}$ac_guessed_f90flags" >&6
8612	<	if test "$ac_guessed_f90flags" = yes; then
8613	<	:
8614	<
8615	<	else
8616	<	:
8617	<
8618	<	echo ""
8619	<	echo "**********************************************************"
8620	<	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8621	<	echo "* your compiler.                                         *"
8622	<	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8623	<	echo "**********************************************************"
8624	<	echo ""
8625	<	F90FLAGS=""
8626	<
8627	<	fi
8628	<
8629	<
8630	<	fi
8631	<
8632	<	;;
8633	<	esac
8634	<
8635	<	# Find a good install program.  We prefer a C program (faster),
8636	<	# so one script is as good as another.  But avoid the broken or
8637	<	# incompatible versions:
8638	<	# SysV /etc/install, /usr/sbin/install
8639	<	# SunOS /usr/etc/install
8640	<	# IRIX /sbin/install
8641	<	# AIX /bin/install
8642	<	# AmigaOS /C/install, which installs bootblocks on floppy discs
8643	<	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8644	<	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
8645	<	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8646	<	# OS/2's system install, which has a completely different semantic
8647	<	# ./install, which can be erroneously created by make from ./install.sh.
8648	<	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8649	<	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8650	<	if test -z "$INSTALL"; then
8651	<	if test "${ac_cv_path_install+set}" = set; then
8652	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8653	<	else
8654	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8655	<	for as_dir in $PATH
8656	<	do
8657	<	IFS=$as_save_IFS
8658	<	test -z "$as_dir" && as_dir=.
8659	<	# Account for people who put trailing slashes in PATH elements.
8660	<	case $as_dir/ in
8661	<	./ | .// | /cC/* | \
8662	<	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8663	<	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8664	<	/usr/ucb/* ) ;;
8665	<	*)
8666	<	# OSF1 and SCO ODT 3.0 have their own names for install.
8667	<	# Don't use installbsd from OSF since it installs stuff as root
8668	<	# by default.
8669	<	for ac_prog in ginstall scoinst install; do
8670	<	for ac_exec_ext in '' $ac_executable_extensions; do
8671	<	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8672	<	if test $ac_prog = install &&
8673	<	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8674	<	# AIX install.  It has an incompatible calling convention.
8675	<	:
8676	<	elif test $ac_prog = install &&
8677	<	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8678	<	# program-specific install script used by HP pwplus--don't use.
8679	<	:
8680	<	else
8681	<	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8682	<	break 3
8683	<	fi
8684	<	fi
8685	<	done
8686	<	done
8687	<	;;
8688	<	esac
8689	<	done
8690	<
8691	<
8692	<	fi
8693	<	if test "${ac_cv_path_install+set}" = set; then
8694	<	INSTALL=$ac_cv_path_install
8695	<	else
8696	<	# As a last resort, use the slow shell script.  We don't cache a
8697	<	# path for INSTALL within a source directory, because that will
8698	<	# break other packages using the cache if that directory is
8699	<	# removed, or if the path is relative.
8700	<	INSTALL=$ac_install_sh
8701	<	fi
8702	<	fi
8703	<	echo "$as_me:$LINENO: result: $INSTALL" >&5
8704	<	echo "${ECHO_T}$INSTALL" >&6
8705	<
8706	<	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8707	<	# It thinks the first close brace ends the variable substitution.
8708	<	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8709	<
8710	<	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8711	<
8712	<	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8713	<
8714	<	echo "$as_me:$LINENO: checking whether ln -s works" >&5
8715	<	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8716	<	LN_S=$as_ln_s
8717	<	if test "$LN_S" = "ln -s"; then
8718	<	echo "$as_me:$LINENO: result: yes" >&5
8719	<	echo "${ECHO_T}yes" >&6
13067	>	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068	>	ac_m_cpu_60x=yes
13069		else
13070	<	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8722	<	echo "${ECHO_T}no, using $LN_S" >&6
13070	>	ac_m_cpu_60x=no
13071		fi
13072	+	rm -f conftest*
13073
8725	–	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8726	–	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8727	–	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8728	–	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8729	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8730	–	else
8731	–	cat >conftest.make <<\_ACEOF
8732	–	all:
8733	–	@echo 'ac_maketemp="$(MAKE)"'
8734	–	_ACEOF
8735	–	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8736	–	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8737	–	if test -n "$ac_maketemp"; then
8738	–	eval ac_cv_prog_make_${ac_make}_set=yes
8739	–	else
8740	–	eval ac_cv_prog_make_${ac_make}_set=no
13074		fi
13075	<	rm -f conftest.make
13076	<	fi
13077	<	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
13078	<	echo "$as_me:$LINENO: result: yes" >&5
13079	<	echo "${ECHO_T}yes" >&6
8747	<	SET_MAKE=
13075	>	echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13076	>	echo "${ECHO_T}$ac_m_cpu_60x" >&6
13077	>	if test "$ac_m_cpu_60x" = yes; then
13078	>	:
13079	>	CPU_FLAGS=-mcpu=$cputype
13080		else
13081	<	echo "$as_me:$LINENO: result: no" >&5
13082	<	echo "${ECHO_T}no" >&6
8751	<	SET_MAKE="MAKE=${MAKE-make}"
13081	>	:
13082	>
13083		fi
13084
13085	<	if test -n "$ac_tool_prefix"; then
13086	<	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
13087	<	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
13088	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
13089	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13090	<	if test "${ac_cv_prog_RANLIB+set}" = set; then
13085	>	elif test "$cputype" = 750; then
13086	>
13087	>
13088	>	echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
13089	>	echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
13090	>	if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13091		echo $ECHO_N "(cached) $ECHO_C" >&6
13092		else
8762	–	if test -n "$RANLIB"; then
8763	–	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8764	–	else
8765	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8766	–	for as_dir in $PATH
8767	–	do
8768	–	IFS=$as_save_IFS
8769	–	test -z "$as_dir" && as_dir=.
8770	–	for ac_exec_ext in '' $ac_executable_extensions; do
8771	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8772	–	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8773	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8774	–	break 2
8775	–	fi
8776	–	done
8777	–	done
13093
13094	<	fi
13095	<	fi
13096	<	RANLIB=$ac_cv_prog_RANLIB
13097	<	if test -n "$RANLIB"; then
13098	<	echo "$as_me:$LINENO: result: $RANLIB" >&5
13099	<	echo "${ECHO_T}$RANLIB" >&6
13094	>	cat > conftest.cpp <<EOF
13095	>	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13096	>	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13097	>	yes;
13098	>	#  endif
13099	>	#endif
13100	>	EOF
13101	>	if { ac_try='${CXX-c++} -E conftest.cpp'
13102	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13103	>	(eval $ac_try) 2>&5
13104	>	ac_status=$?
13105	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13106	>	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13107	>	ac_cv_prog_gxx_2_95=yes
13108		else
13109	<	echo "$as_me:$LINENO: result: no" >&5
8787	<	echo "${ECHO_T}no" >&6
13109	>	ac_cv_prog_gxx_2_95=no
13110		fi
13111
13112		fi
13113	<	if test -z "$ac_cv_prog_RANLIB"; then
13114	<	ac_ct_RANLIB=$RANLIB
13115	<	# Extract the first word of "ranlib", so it can be a program name with args.
13116	<	set dummy ranlib; ac_word=$2
13117	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
13118	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13119	<	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
13113	>	echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
13114	>	echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
13115	>	if test "$ac_cv_prog_gxx_2_95" = yes; then
13116	>	:
13117	>
13118	>
13119	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121	>	if test "${ac_m_cpu_750+set}" = set; then
13122		echo $ECHO_N "(cached) $ECHO_C" >&6
13123		else
13124	<	if test -n "$ac_ct_RANLIB"; then
13125	<	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
13124	>	echo 'void f(){}' > conftest.cpp
13125	>	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126	>	ac_m_cpu_750=yes
13127		else
13128	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13129	<	for as_dir in $PATH
13130	<	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_ac_ct_RANLIB="ranlib"
8811	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812	<	break 2
8813	<	fi
8814	<	done
8815	<	done
13128	>	ac_m_cpu_750=no
13129	>	fi
13130	>	rm -f conftest*
13131
8817	–	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
13132		fi
13133	<	fi
13134	<	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
13135	<	if test -n "$ac_ct_RANLIB"; then
13136	<	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
13137	<	echo "${ECHO_T}$ac_ct_RANLIB" >&6
13133	>	echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13134	>	echo "${ECHO_T}$ac_m_cpu_750" >&6
13135	>	if test "$ac_m_cpu_750" = yes; then
13136	>	:
13137	>	CPU_FLAGS=-mcpu=750
13138		else
13139	<	echo "$as_me:$LINENO: result: no" >&5
8826	<	echo "${ECHO_T}no" >&6
8827	<	fi
13139	>	:
13140
8829	–	RANLIB=$ac_ct_RANLIB
8830	–	else
8831	–	RANLIB="$ac_cv_prog_RANLIB"
13141		fi
13142
8834	–	for ac_prog in 'bison -y' byacc
8835	–	do
8836	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
8837	–	set dummy $ac_prog; ac_word=$2
8838	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
8839	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8840	–	if test "${ac_cv_prog_YACC+set}" = set; then
8841	–	echo $ECHO_N "(cached) $ECHO_C" >&6
13143		else
13144	<	if test -n "$YACC"; then
8844	<	ac_cv_prog_YACC="$YACC" # Let the user override the test.
8845	<	else
8846	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8847	<	for as_dir in $PATH
8848	<	do
8849	<	IFS=$as_save_IFS
8850	<	test -z "$as_dir" && as_dir=.
8851	<	for ac_exec_ext in '' $ac_executable_extensions; do
8852	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8853	<	ac_cv_prog_YACC="$ac_prog"
8854	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8855	<	break 2
8856	<	fi
8857	<	done
8858	<	done
13144	>	:
13145
13146		fi
8861	–	fi
8862	–	YACC=$ac_cv_prog_YACC
8863	–	if test -n "$YACC"; then
8864	–	echo "$as_me:$LINENO: result: $YACC" >&5
8865	–	echo "${ECHO_T}$YACC" >&6
8866	–	else
8867	–	echo "$as_me:$LINENO: result: no" >&5
8868	–	echo "${ECHO_T}no" >&6
8869	–	fi
13147
13148	<	test -n "$YACC" && break
13149	<	done
8873	<	test -n "$YACC" || YACC="yacc"
13148	>	fi
13149	>	if test -z "$CPU_FLAGS"; then
13150
13151	<	for ac_prog in flex lex
13152	<	do
13153	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
13154	<	set dummy $ac_prog; ac_word=$2
8879	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
8880	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8881	<	if test "${ac_cv_prog_LEX+set}" = set; then
13151	>
13152	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154	>	if test "${ac_m_cpu_powerpc+set}" = set; then
13155		echo $ECHO_N "(cached) $ECHO_C" >&6
13156		else
13157	<	if test -n "$LEX"; then
13158	<	ac_cv_prog_LEX="$LEX" # Let the user override the test.
13157	>	echo 'void f(){}' > conftest.cpp
13158	>	if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159	>	ac_m_cpu_powerpc=yes
13160		else
13161	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13162	<	for as_dir in $PATH
13163	<	do
8890	<	IFS=$as_save_IFS
8891	<	test -z "$as_dir" && as_dir=.
8892	<	for ac_exec_ext in '' $ac_executable_extensions; do
8893	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894	<	ac_cv_prog_LEX="$ac_prog"
8895	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896	<	break 2
8897	<	fi
8898	<	done
8899	<	done
13161	>	ac_m_cpu_powerpc=no
13162	>	fi
13163	>	rm -f conftest*
13164
13165		fi
13166	<	fi
13167	<	LEX=$ac_cv_prog_LEX
13168	<	if test -n "$LEX"; then
13169	<	echo "$as_me:$LINENO: result: $LEX" >&5
13170	<	echo "${ECHO_T}$LEX" >&6
13166	>	echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13167	>	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13168	>	if test "$ac_m_cpu_powerpc" = yes; then
13169	>	:
13170	>	CPU_FLAGS=-mcpu=powerpc
13171		else
13172	<	echo "$as_me:$LINENO: result: no" >&5
8909	<	echo "${ECHO_T}no" >&6
8910	<	fi
8911	<
8912	<	test -n "$LEX" && break
8913	<	done
8914	<	test -n "$LEX" || LEX=":"
8915	<
8916	<	if test -z "$LEXLIB"
8917	<	then
8918	<	echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8919	<	echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8920	<	if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8921	<	echo $ECHO_N "(cached) $ECHO_C" >&6
8922	<	else
8923	<	ac_check_lib_save_LIBS=$LIBS
8924	<	LIBS="-lfl  $LIBS"
8925	<	cat >conftest.$ac_ext <<_ACEOF
8926	<	/* confdefs.h.  */
8927	<	_ACEOF
8928	<	cat confdefs.h >>conftest.$ac_ext
8929	<	cat >>conftest.$ac_ext <<_ACEOF
8930	<	/* end confdefs.h.  */
8931	<
8932	<	/* Override any gcc2 internal prototype to avoid an error.  */
8933	<	#ifdef __cplusplus
8934	<	extern "C"
8935	<	#endif
8936	<	/* We use char because int might match the return type of a gcc2
8937	<	builtin and then its argument prototype would still apply.  */
8938	<	char yywrap ();
8939	<	int
8940	<	main ()
8941	<	{
8942	<	yywrap ();
8943	<	;
8944	<	return 0;
8945	<	}
8946	<	_ACEOF
8947	<	rm -f conftest.$ac_objext conftest$ac_exeext
8948	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8949	<	(eval $ac_link) 2>conftest.er1
8950	<	ac_status=$?
8951	<	grep -v '^ *+' conftest.er1 >conftest.err
8952	<	rm -f conftest.er1
8953	<	cat conftest.err >&5
8954	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8955	<	(exit $ac_status); } &&
8956	<	{ ac_try='test -z "$ac_c_werror_flag"
8957	<	|| test ! -s conftest.err'
8958	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8959	<	(eval $ac_try) 2>&5
8960	<	ac_status=$?
8961	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8962	<	(exit $ac_status); }; } &&
8963	<	{ ac_try='test -s conftest$ac_exeext'
8964	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8965	<	(eval $ac_try) 2>&5
8966	<	ac_status=$?
8967	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8968	<	(exit $ac_status); }; }; then
8969	<	ac_cv_lib_fl_yywrap=yes
8970	<	else
8971	<	echo "$as_me: failed program was:" >&5
8972	<	sed 's/^/| /' conftest.$ac_ext >&5
13172	>	:
13173
8974	–	ac_cv_lib_fl_yywrap=no
13174		fi
8976	–	rm -f conftest.err conftest.$ac_objext \
8977	–	conftest$ac_exeext conftest.$ac_ext
8978	–	LIBS=$ac_check_lib_save_LIBS
8979	–	fi
8980	–	echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8981	–	echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8982	–	if test $ac_cv_lib_fl_yywrap = yes; then
8983	–	LEXLIB="-lfl"
8984	–	else
8985	–	echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8986	–	echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8987	–	if test "${ac_cv_lib_l_yywrap+set}" = set; then
8988	–	echo $ECHO_N "(cached) $ECHO_C" >&6
8989	–	else
8990	–	ac_check_lib_save_LIBS=$LIBS
8991	–	LIBS="-ll  $LIBS"
8992	–	cat >conftest.$ac_ext <<_ACEOF
8993	–	/* confdefs.h.  */
8994	–	_ACEOF
8995	–	cat confdefs.h >>conftest.$ac_ext
8996	–	cat >>conftest.$ac_ext <<_ACEOF
8997	–	/* end confdefs.h.  */
13175
13176	<	/* Override any gcc2 internal prototype to avoid an error.  */
13177	<	#ifdef __cplusplus
9001	<	extern "C"
9002	<	#endif
9003	<	/* We use char because int might match the return type of a gcc2
9004	<	builtin and then its argument prototype would still apply.  */
9005	<	char yywrap ();
9006	<	int
9007	<	main ()
9008	<	{
9009	<	yywrap ();
9010	<	;
9011	<	return 0;
9012	<	}
9013	<	_ACEOF
9014	<	rm -f conftest.$ac_objext conftest$ac_exeext
9015	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9016	<	(eval $ac_link) 2>conftest.er1
9017	<	ac_status=$?
9018	<	grep -v '^ *+' conftest.er1 >conftest.err
9019	<	rm -f conftest.er1
9020	<	cat conftest.err >&5
9021	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022	<	(exit $ac_status); } &&
9023	<	{ ac_try='test -z "$ac_c_werror_flag"
9024	<	|| test ! -s conftest.err'
9025	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9026	<	(eval $ac_try) 2>&5
9027	<	ac_status=$?
9028	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9029	<	(exit $ac_status); }; } &&
9030	<	{ ac_try='test -s conftest$ac_exeext'
9031	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9032	<	(eval $ac_try) 2>&5
9033	<	ac_status=$?
9034	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9035	<	(exit $ac_status); }; }; then
9036	<	ac_cv_lib_l_yywrap=yes
9037	<	else
9038	<	echo "$as_me: failed program was:" >&5
9039	<	sed 's/^/| /' conftest.$ac_ext >&5
13176	>	fi
13177	>	if test -z "$CPU_FLAGS"; then
13178
9041	–	ac_cv_lib_l_yywrap=no
9042	–	fi
9043	–	rm -f conftest.err conftest.$ac_objext \
9044	–	conftest$ac_exeext conftest.$ac_ext
9045	–	LIBS=$ac_check_lib_save_LIBS
9046	–	fi
9047	–	echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9048	–	echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9049	–	if test $ac_cv_lib_l_yywrap = yes; then
9050	–	LEXLIB="-ll"
9051	–	fi
13179
13180	<	fi
13181	<
13182	<	fi
9056	<
9057	<	if test "x$LEX" != "x:"; then
9058	<	echo "$as_me:$LINENO: checking lex output file root" >&5
9059	<	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9060	<	if test "${ac_cv_prog_lex_root+set}" = set; then
13180	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13181	>	echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13182	>	if test "${ac_m_powerpc+set}" = set; then
13183		echo $ECHO_N "(cached) $ECHO_C" >&6
13184		else
13185	<	# The minimal lex program is just a single line: %%.  But some broken lexes
13186	<	# (Solaris, I think it was) want two %% lines, so accommodate them.
13187	<	cat >conftest.l <<_ACEOF
9066	<	%%
9067	<	%%
9068	<	_ACEOF
9069	<	{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9070	<	(eval $LEX conftest.l) 2>&5
9071	<	ac_status=$?
9072	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073	<	(exit $ac_status); }
9074	<	if test -f lex.yy.c; then
9075	<	ac_cv_prog_lex_root=lex.yy
9076	<	elif test -f lexyy.c; then
9077	<	ac_cv_prog_lex_root=lexyy
13185	>	echo 'void f(){}' > conftest.cpp
13186	>	if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13187	>	ac_m_powerpc=yes
13188		else
13189	<	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9080	<	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9081	<	{ (exit 1); exit 1; }; }
13189	>	ac_m_powerpc=no
13190		fi
13191	<	fi
9084	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9085	<	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9086	<	rm -f conftest.l
9087	<	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13191	>	rm -f conftest*
13192
13193	<	echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13194	<	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13195	<	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13196	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13193	>	fi
13194	>	echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13195	>	echo "${ECHO_T}$ac_m_powerpc" >&6
13196	>	if test "$ac_m_powerpc" = yes; then
13197	>	:
13198	>	CPU_FLAGS=-mpowerpc
13199		else
13200	<	# POSIX says lex can declare yytext either as a pointer or an array; the
9095	<	# default is implementation-dependent. Figure out which it is, since
9096	<	# not all implementations provide the %pointer and %array declarations.
9097	<	ac_cv_prog_lex_yytext_pointer=no
9098	<	echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9099	<	ac_save_LIBS=$LIBS
9100	<	LIBS="$LIBS $LEXLIB"
9101	<	cat >conftest.$ac_ext <<_ACEOF
9102	<	`cat $LEX_OUTPUT_ROOT.c`
9103	<	_ACEOF
9104	<	rm -f conftest.$ac_objext conftest$ac_exeext
9105	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9106	<	(eval $ac_link) 2>conftest.er1
9107	<	ac_status=$?
9108	<	grep -v '^ *+' conftest.er1 >conftest.err
9109	<	rm -f conftest.er1
9110	<	cat conftest.err >&5
9111	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9112	<	(exit $ac_status); } &&
9113	<	{ ac_try='test -z "$ac_c_werror_flag"
9114	<	|| test ! -s conftest.err'
9115	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9116	<	(eval $ac_try) 2>&5
9117	<	ac_status=$?
9118	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9119	<	(exit $ac_status); }; } &&
9120	<	{ ac_try='test -s conftest$ac_exeext'
9121	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9122	<	(eval $ac_try) 2>&5
9123	<	ac_status=$?
9124	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9125	<	(exit $ac_status); }; }; then
9126	<	ac_cv_prog_lex_yytext_pointer=yes
9127	<	else
9128	<	echo "$as_me: failed program was:" >&5
9129	<	sed 's/^/| /' conftest.$ac_ext >&5
13200	>	:
13201
13202		fi
9132	–	rm -f conftest.err conftest.$ac_objext \
9133	–	conftest$ac_exeext conftest.$ac_ext
9134	–	LIBS=$ac_save_LIBS
9135	–	rm -f "${LEX_OUTPUT_ROOT}.c"
13203
13204	<	fi
13205	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
13206	<	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9140	<	if test $ac_cv_prog_lex_yytext_pointer = yes; then
13204	>	fi
13205	>	esac
13206	>	fi
13207
13208	<	cat >>confdefs.h <<\_ACEOF
13209	<	#define YYTEXT_POINTER 1
13210	<	_ACEOF
13208	>	if test -n "$CPU_FLAGS"; then
13209	>	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210	>	fi
13211
13212	<	fi
13212	>	if test -z "$CXXFLAGS"; then
13213	>	echo ""
13214	>	echo "**********************************************************"
13215	>	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
13216	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13217	>	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
13218	>	echo "**********************************************************"
13219	>	echo ""
13220	>	CXXFLAGS="-O3"
13221	>	fi
13222
9148	–	fi
13223
13224	<	# Extract the first word of "perl", so it can be a program name with args.
13225	<	set dummy perl; ac_word=$2
13226	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
13227	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9154	<	if test "${ac_cv_path_PERLINTERP+set}" = set; then
13224	>
13225	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13226	>	echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13227	>	if test "${ac_guessed_cxxflags+set}" = set; then
13228		echo $ECHO_N "(cached) $ECHO_C" >&6
13229		else
13230	<	case $PERLINTERP in
13231	<	[\\/]* | ?:[\\/]*)
13232	<	ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9160	<	;;
9161	<	*)
9162	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9163	<	for as_dir in $PATH
9164	<	do
9165	<	IFS=$as_save_IFS
9166	<	test -z "$as_dir" && as_dir=.
9167	<	for ac_exec_ext in '' $ac_executable_extensions; do
9168	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9169	<	ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9170	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9171	<	break 2
9172	<	fi
9173	<	done
9174	<	done
9175	<
9176	<	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9177	<	;;
9178	<	esac
9179	<	fi
9180	<	PERLINTERP=$ac_cv_path_PERLINTERP
9181	<
9182	<	if test -n "$PERLINTERP"; then
9183	<	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9184	<	echo "${ECHO_T}$PERLINTERP" >&6
13230	>	echo 'void f(){}' > conftest.cpp
13231	>	if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232	>	ac_guessed_cxxflags=yes
13233		else
13234	<	echo "$as_me:$LINENO: result: no" >&5
9187	<	echo "${ECHO_T}no" >&6
13234	>	ac_guessed_cxxflags=no
13235		fi
13236	+	rm -f conftest*
13237
9190	–	ac_cv_path_perlinterp="$PERLINTERP"
9191	–	_sHpB='#!'
9192	–
9193	–
9194	–	# Check whether --with-perl-shebang or --without-perl-shebang was given.
9195	–	if test "${with_perl_shebang+set}" = set; then
9196	–	withval="$with_perl_shebang"
9197	–	opt_perl_shebang="$withval"
9198	–	else
9199	–	opt_perl_shebang="not_set"
9200	–	fi;
9201	–	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9202	–	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9203	–	if test "${ax_cv_opt_perl_shebang+set}" = set; then
9204	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9205	–	else
9206	–	case "$opt_perl_shebang" in
9207	–	not_set  ) ax_cv_opt_perl_shebang=''
9208	–	;;
9209	–	*     )
9210	–	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9211	–	esac
9212	–
13238		fi
13239	<	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
13240	<	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
13241	<	if test "A$ax_cv_opt_perl_shebang" != "A"
13242	<	then
9218	<	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9219	<	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9220	<	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9221	<	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
13239	>	echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
13240	>	echo "${ECHO_T}$ac_guessed_cxxflags" >&6
13241	>	if test "$ac_guessed_cxxflags" = yes; then
13242	>	:
13243
9223	–	# Automatic detection of sharpbang formula starts here
9224	–	else
9225	–	_somian_shbangperl=`$PERLINTERP -V:startperl`
9226	–	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9227	–	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9228	–	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9229	–	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9230	–	echo $ECHO_N "(cached) $ECHO_C" >&6
13244		else
13245	<	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9233	<	if test "x$_somian_kspb_perl" == x
9234	<	then _somian_ksbp_warn_empty='durnit'
9235	<	else
9236	<	case "A$_somian_kspb_perl" in
9237	<	A#!*perl* )
9238	<	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9239	<	;;
9240	<	A*    )  _somian_ksbp_warn_defau='trouble'
9241	<	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9242	<	esac
9243	<	fi
13245	>	:
13246
13247	<	fi
13248	<	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
13249	<	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
13250	<	# The above prints Checking ... result message to user.
13251	<	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
13247	>	echo ""
13248	>	echo "**********************************************************"
13249	>	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13250	>	echo "* your compiler.                                         *"
13251	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13252	>	echo "**********************************************************"
13253	>	echo ""
13254	>	CXXFLAGS=""
13255
9251	–	if test A${_somian_ksbp_warn_empty+set} == Aset
9252	–	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9253	–	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9254	–	fi
9255	–	# Inform user after printing result value
9256	–	if test A${_somian_ksbp_warn_defau+set} == Aset
9257	–	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9258	–	echo "$as_me: Maybe Not good -" >&6;}
9259	–	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9260	–	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9261	–	else { echo "$as_me:$LINENO: OK Good result - " >&5
9262	–	echo "$as_me: OK Good result - " >&6;}
9263	–	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9264	–	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9265	–	fi
9266	–	fi
9267	–
9268	–	# Extract the first word of "ar", so it can be a program name with args.
9269	–	set dummy ar; ac_word=$2
9270	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
9271	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9272	–	if test "${ac_cv_prog_AR+set}" = set; then
9273	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9274	–	else
9275	–	if test -n "$AR"; then
9276	–	ac_cv_prog_AR="$AR" # Let the user override the test.
9277	–	else
9278	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9279	–	for as_dir in $PATH
9280	–	do
9281	–	IFS=$as_save_IFS
9282	–	test -z "$as_dir" && as_dir=.
9283	–	for ac_exec_ext in '' $ac_executable_extensions; do
9284	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9285	–	ac_cv_prog_AR="ar"
9286	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9287	–	break 2
9288	–	fi
9289	–	done
9290	–	done
9291	–
9292	–	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13256		fi
9294	–	fi
9295	–	AR=$ac_cv_prog_AR
9296	–	if test -n "$AR"; then
9297	–	echo "$as_me:$LINENO: result: $AR" >&5
9298	–	echo "${ECHO_T}$AR" >&6
9299	–	else
9300	–	echo "$as_me:$LINENO: result: no" >&5
9301	–	echo "${ECHO_T}no" >&6
9302	–	fi
13257
9304	–	if test "$AR" = "NONE"; then
9305	–	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9306	–	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9307	–	{ (exit 1); exit 1; }; }
9308	–	cat >confcache <<\_ACEOF
9309	–	# This file is a shell script that caches the results of configure
9310	–	# tests run on this system so they can be shared between configure
9311	–	# scripts and configure runs, see configure's option --config-cache.
9312	–	# It is not useful on other systems.  If it contains results you don't
9313	–	# want to keep, you may remove or edit it.
9314	–	#
9315	–	# config.status only pays attention to the cache file if you give it
9316	–	# the --recheck option to rerun configure.
9317	–	#
9318	–	# `ac_cv_env_foo' variables (set or unset) will be overridden when
9319	–	# loading this file, other *unset* `ac_cv_foo' will be assigned the
9320	–	# following values.
13258
9322	–	_ACEOF
9323	–
9324	–	# The following way of writing the cache mishandles newlines in values,
9325	–	# but we know of no workaround that is simple, portable, and efficient.
9326	–	# So, don't put newlines in cache variables' values.
9327	–	# Ultrix sh set writes to stderr and can't be redirected directly,
9328	–	# and sets the high bit in the cache file unless we assign to the vars.
9329	–	{
9330	–	(set) 2>&1 |
9331	–	case `(ac_space=' '; set | grep ac_space) 2>&1` in
9332	–	*ac_space=\ *)
9333	–	# `set' does not quote correctly, so add quotes (double-quote
9334	–	# substitution turns \\\\ into \\, and sed turns \\ into \).
9335	–	sed -n \
9336	–	"s/'/'\\\\''/g;
9337	–	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9338	–	;;
9339	–	*)
9340	–	# `set' quotes correctly as required by POSIX, so do not add quotes.
9341	–	sed -n \
9342	–	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9343	–	;;
9344	–	esac;
9345	–	} |
9346	–	sed '
9347	–	t clear
9348	–	: clear
9349	–	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9350	–	t end
9351	–	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9352	–	: end' >>confcache
9353	–	if diff $cache_file confcache >/dev/null 2>&1; then :; else
9354	–	if test -w $cache_file; then
9355	–	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9356	–	cat confcache >$cache_file
9357	–	else
9358	–	echo "not updating unwritable cache $cache_file"
9359	–	fi
13259		fi
9361	–	rm -f confcache
9362	–	exit 1
9363	–	fi
13260
13261	<	# Extract the first word of "ps", so it can be a program name with args.
9366	<	set dummy ps; ac_word=$2
9367	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
9368	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9369	<	if test "${ac_cv_path_PS+set}" = set; then
9370	<	echo $ECHO_N "(cached) $ECHO_C" >&6
9371	<	else
9372	<	case $PS in
9373	<	[\\/]* | ?:[\\/]*)
9374	<	ac_cv_path_PS="$PS" # Let the user override the test with a path.
9375	<	;;
9376	<	*)
9377	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9378	<	for as_dir in $PATH
9379	<	do
9380	<	IFS=$as_save_IFS
9381	<	test -z "$as_dir" && as_dir=.
9382	<	for ac_exec_ext in '' $ac_executable_extensions; do
9383	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9384	<	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9385	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9386	<	break 2
9387	<	fi
9388	<	done
9389	<	done
9390	<
9391	<	;;
13261	>	;;
13262		esac
9393	–	fi
9394	–	PS=$ac_cv_path_PS
13263
9396	–	if test -n "$PS"; then
9397	–	echo "$as_me:$LINENO: result: $PS" >&5
9398	–	echo "${ECHO_T}$PS" >&6
9399	–	else
9400	–	echo "$as_me:$LINENO: result: no" >&5
9401	–	echo "${ECHO_T}no" >&6
9402	–	fi
13264
9404	–	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9405	–	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9406	–	if test "${ac_cv_prog_ps_syntax+set}" = set; then
9407	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9408	–	else
9409	–
9410	–	if $PS ax -o rss > /dev/null 2>&1; then
9411	–	ac_cv_prog_ps_ax=yes
9412	–	else
9413	–	ac_cv_prog_ps_ax=no
9414	–	fi
9415	–	if $PS -ef -o rss > /dev/null 2>&1; then
9416	–	ac_cv_prog_ps_ef=yes
9417	–	else
9418	–	ac_cv_prog_ps_ef=no
9419	–	fi
9420	–	if test "$ac_cv_prog_ps_ax" = yes; then
9421	–	ac_cv_prog_ps_syntax=BSD
9422	–	else
9423	–	if test "$ac_cv_prog_ps_ef" = yes; then
9424	–	ac_cv_prog_ps_syntax=POSIX
9425	–	else
9426	–	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9427	–	echo "$as_me: error: Could not determine ps syntax" >&2;}
9428	–	{ (exit 1); exit 1; }; }
9429	–	fi
9430	–	fi
9431	–
9432	–	fi
9433	–	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9434	–	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9435	–
9436	–
9437	–	cat >>confdefs.h <<_ACEOF
9438	–	#define PSCOMMAND $PS
9439	–	_ACEOF
9440	–
9441	–
13265		cat >>confdefs.h <<\_ACEOF
13266		#define OBAPI
13267		_ACEOF
13268
9446	–
9447	–
9448	–	if test "$ac_cv_prog_ps_syntax" = BSD; then
9449	–	cat >>confdefs.h <<\_ACEOF
9450	–	#define PSTYPE_IS_BSD 1
9451	–	_ACEOF
9452	–
9453	–	else
9454	–	if test "$ac_cv_prog_ps_syntax" = POSIX; then
9455	–	cat >>confdefs.h <<\_ACEOF
9456	–	#define PSTYPE_IS_POSIX 1
9457	–	_ACEOF
13269
9459	–	else
9460	–	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9461	–	echo "$as_me: error: Unknown ps syntax type!" >&2;}
9462	–	{ (exit 1); exit 1; }; }
9463	–	fi
9464	–	fi
13270
13271
13272		# Check whether --with-mpi or --without-mpi was given.
#	Line 9519 | Line 13324 | rm -f conftest*
13324		echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325		have_mpif_h=0
13326		rm -f conftest*
13327	<	cat >conftest.f90 <<EOF
13327	>	cat >conftest.$ac_ext <<EOF
13328		program main
13329		include 'mpif.h'
13330		end
13331		EOF
13332	<	if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332	>	if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333		echo "$as_me:$LINENO: result: yes" >&5
13334		echo "${ECHO_T}yes" >&6
13335		MPI_F90_INC="$MPI_INC_DIR"
#	Line 9578 | Line 13383 | char MPI_Init ();
13383		/* We use char because int might match the return type of a gcc2
13384		builtin and then its argument prototype would still apply.  */
13385		char MPI_Init ();
13386	+	#ifdef FC_DUMMY_MAIN
13387	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13388	+	#  ifdef __cplusplus
13389	+	extern "C"
13390	+	#  endif
13391	+	int FC_DUMMY_MAIN() { return 1; }
13392	+	#endif
13393	+	#endif
13394		int
13395		main ()
13396		{
#	Line 9648 | Line 13461 | char MPI_Init ();
13461		/* We use char because int might match the return type of a gcc2
13462		builtin and then its argument prototype would still apply.  */
13463		char MPI_Init ();
13464	+	#ifdef FC_DUMMY_MAIN
13465	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13466	+	#  ifdef __cplusplus
13467	+	extern "C"
13468	+	#  endif
13469	+	int FC_DUMMY_MAIN() { return 1; }
13470	+	#endif
13471	+	#endif
13472		int
13473		main ()
13474		{
#	Line 9719 | Line 13540 | char MPI_Init ();
13540		/* We use char because int might match the return type of a gcc2
13541		builtin and then its argument prototype would still apply.  */
13542		char MPI_Init ();
13543	+	#ifdef FC_DUMMY_MAIN
13544	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13545	+	#  ifdef __cplusplus
13546	+	extern "C"
13547	+	#  endif
13548	+	int FC_DUMMY_MAIN() { return 1; }
13549	+	#endif
13550	+	#endif
13551		int
13552		main ()
13553		{
#	Line 9790 | Line 13619 | char MPI_Init ();
13619		/* We use char because int might match the return type of a gcc2
13620		builtin and then its argument prototype would still apply.  */
13621		char MPI_Init ();
13622	+	#ifdef FC_DUMMY_MAIN
13623	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13624	+	#  ifdef __cplusplus
13625	+	extern "C"
13626	+	#  endif
13627	+	int FC_DUMMY_MAIN() { return 1; }
13628	+	#endif
13629	+	#endif
13630		int
13631		main ()
13632		{
#	Line 9834 | Line 13671 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13671		echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13672		echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13673		if test $ac_cv_lib_mpich_MPI_Init = yes; then
13674	<	MPI_LIB="-lmpich -lpmpich"
13674	>	MPI_LIB="-lpmpich -lmpich"
13675		fi
13676
13677		fi
#	Line 9862 | Line 13699 | char MPI_Init ();
13699		/* We use char because int might match the return type of a gcc2
13700		builtin and then its argument prototype would still apply.  */
13701		char MPI_Init ();
13702	+	#ifdef FC_DUMMY_MAIN
13703	+	#ifndef FC_DUMMY_MAIN_EQ_F77
13704	+	#  ifdef __cplusplus
13705	+	extern "C"
13706	+	#  endif
13707	+	int FC_DUMMY_MAIN() { return 1; }
13708	+	#endif
13709	+	#endif
13710		int
13711		main ()
13712		{
#	Line 10280 | Line 14125 | cat >>conftest.$ac_ext <<_ACEOF
14125		cat >>conftest.$ac_ext <<_ACEOF
14126		/* end confdefs.h.  */
14127		#include <CGAL/Cartesian.h>
14128	+	#ifdef FC_DUMMY_MAIN
14129	+	#ifndef FC_DUMMY_MAIN_EQ_F77
14130	+	#  ifdef __cplusplus
14131	+	extern "C"
14132	+	#  endif
14133	+	int FC_DUMMY_MAIN() { return 1; }
14134	+	#endif
14135	+	#endif
14136		int
14137		main ()
14138		{
#	Line 10527 | Line 14380 | fi
14380
14381
14382
10530	–	OBJEXT=".$OBJEXT"
14383
10532	–	OOPSE=oopse
14384
10534	–	if test "x${prefix}" = "xNONE"
10535	–	then
10536	–	OOPSE_HOME=${ac_default_prefix}/oopse
10537	–	else
10538	–	OOPSE_HOME=${prefix}/oopse
10539	–	fi
10540	–	# Check whether --enable-oopse-home or --disable-oopse-home was given.
10541	–	if test "${enable_oopse_home+set}" = set; then
10542	–	enableval="$enable_oopse_home"
10543	–	OOPSE_HOME="${enableval}"
10544	–	fi;
14385
10546	–	case "x$INSTALL" in
10547	–	x/*) ;;
10548	–	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10549	–	esac
14386
10551	–	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14387
10553	–	CFLAGS=${CFLAGS-""}
10554	–	CXXFLAGS=${CXXFLAGS-""}
10555	–	CPPFLAGS=${CPPFLAGS-""}
10556	–	FFLAGS=${FFLAGS-""}
10557	–	F90FLAGS=${F90FLAGS-""}
10558	–	LDFLAGS=${LDFLAGS-""}
10559	–	DEBUG=${DEBUG-"-g"}
14388
10561	–	case $debug in
10562	–	1)
10563	–	FFLAGS="$DEBUG $FFLAGS"
10564	–	F90FLAGS="$DEBUG $F90FLAGS"
10565	–	;;
10566	–	*)
10567	–	;;
10568	–	esac
14389
14390
14391
14392
14393
14394
10575	–
10576	–
10577	–
10578	–
10579	–
10580	–
10581	–
10582	–
10583	–
10584	–
10585	–
10586	–
10587	–	ac_config_headers="$ac_config_headers src/config.h"
10588	–
14395		ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396
14397
#	Line 10951 | Line 14757 | cat >&5 <<_CSEOF
14757		} >&5
14758		cat >&5 <<_CSEOF
14759
14760	<	This file was extended by OOPSE $as_me 2.0, which was
14760	>	This file was extended by OOPSE $as_me 3.0, which was
14761		generated by GNU Autoconf 2.59.  Invocation command line was
14762
14763		CONFIG_FILES    = $CONFIG_FILES
#	Line 11014 | Line 14820 | ac_cs_version="\\
14820
14821		cat >>$CONFIG_STATUS <<_ACEOF
14822		ac_cs_version="\\
14823	<	OOPSE config.status 2.0
14823	>	OOPSE config.status 3.0
14824		configured by $0, generated by GNU Autoconf 2.59,
14825		with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826
#	Line 11208 | Line 15014 | s,@LIBS@,$LIBS,;t t
15014		s,@ECHO_N@,$ECHO_N,;t t
15015		s,@ECHO_T@,$ECHO_T,;t t
15016		s,@LIBS@,$LIBS,;t t
11211	–	s,@PROGNAME@,$PROGNAME,;t t
11212	–	s,@debug@,$debug,;t t
15017		s,@build@,$build,;t t
15018		s,@build_cpu@,$build_cpu,;t t
15019		s,@build_vendor@,$build_vendor,;t t
#	Line 11218 | Line 15022 | s,@host_os@,$host_os,;t t
15022		s,@host_cpu@,$host_cpu,;t t
15023		s,@host_vendor@,$host_vendor,;t t
15024		s,@host_os@,$host_os,;t t
15025	<	s,@CC@,$CC,;t t
15026	<	s,@CFLAGS@,$CFLAGS,;t t
15025	>	s,@PROGNAME@,$PROGNAME,;t t
15026	>	s,@debug@,$debug,;t t
15027	>	s,@CXX@,$CXX,;t t
15028	>	s,@CXXFLAGS@,$CXXFLAGS,;t t
15029		s,@LDFLAGS@,$LDFLAGS,;t t
15030		s,@CPPFLAGS@,$CPPFLAGS,;t t
15031	<	s,@ac_ct_CC@,$ac_ct_CC,;t t
15031	>	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032		s,@EXEEXT@,$EXEEXT,;t t
15033		s,@OBJEXT@,$OBJEXT,;t t
15034	<	s,@CXX@,$CXX,;t t
15035	<	s,@CXXFLAGS@,$CXXFLAGS,;t t
15036	<	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15034	>	s,@CC@,$CC,;t t
15035	>	s,@CFLAGS@,$CFLAGS,;t t
15036	>	s,@ac_ct_CC@,$ac_ct_CC,;t t
15037	>	s,@FC@,$FC,;t t
15038	>	s,@FCFLAGS@,$FCFLAGS,;t t
15039	>	s,@ac_ct_FC@,$ac_ct_FC,;t t
15040		s,@CPP@,$CPP,;t t
15041		s,@EGREP@,$EGREP,;t t
11233	–	s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11234	–	s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11235	–	s,@F90@,$F90,;t t
11236	–	s,@F90FLAGS@,$F90FLAGS,;t t
11237	–	s,@ac_ct_F90@,$ac_ct_F90,;t t
11238	–	s,@PREPFLAG@,$PREPFLAG,;t t
11239	–	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11240	–	s,@F90LIBS@,$F90LIBS,;t t
11241	–	s,@F90_FUNC@,$F90_FUNC,;t t
11242	–	s,@F90_FUNC_@,$F90_FUNC_,;t t
11243	–	s,@MOD@,$MOD,;t t
11244	–	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11245	–	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11246	–	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11247	–	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11248	–	s,@CXXCPP@,$CXXCPP,;t t
11249	–	s,@LIBOBJS@,$LIBOBJS,;t t
11250	–	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11251	–	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11252	–	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042		s,@LN_S@,$LN_S,;t t
15043		s,@SET_MAKE@,$SET_MAKE,;t t
15044		s,@RANLIB@,$RANLIB,;t t
15045		s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11257	–	s,@YACC@,$YACC,;t t
11258	–	s,@LEX@,$LEX,;t t
11259	–	s,@LEXLIB@,$LEXLIB,;t t
11260	–	s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046		s,@PERLINTERP@,$PERLINTERP,;t t
15047		s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048	+	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049	+	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050	+	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051		s,@AR@,$AR,;t t
15052		s,@PS@,$PS,;t t
15053	+	s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054	+	s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055	+	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056	+	s,@FCLIBS@,$FCLIBS,;t t
15057	+	s,@FC_FUNC@,$FC_FUNC,;t t
15058	+	s,@FC_FUNC_@,$FC_FUNC_,;t t
15059	+	s,@MOD@,$MOD,;t t
15060	+	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061	+	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062	+	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063	+	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064	+	s,@LIBOBJS@,$LIBOBJS,;t t
15065	+	s,@POW_LIB@,$POW_LIB,;t t
15066	+	s,@CXXCPP@,$CXXCPP,;t t
15067	+	s,@__func__@,$__func__,;t t
15068		s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069		s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070		s,@MPI_F90_INC@,$MPI_F90_INC,;t t
#	Line 11286 | Line 15089 | s,@SUBDIRS@,$SUBDIRS,;t t
15089		s,@OOPSE@,$OOPSE,;t t
15090		s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091		s,@SUBDIRS@,$SUBDIRS,;t t
11289	–	s,@FFLAGS@,$FFLAGS,;t t
15092		s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093		CEOF
15094

Diff Legend

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