ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 397 by gezelter, Fri Mar 4 15:29:03 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 OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI 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
764	–	ac_env_LDFLAGS_set=${LDFLAGS+set}
765	–	ac_env_LDFLAGS_value=$LDFLAGS
766	–	ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767	–	ac_cv_env_LDFLAGS_value=$LDFLAGS
768	–	ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769	–	ac_env_CPPFLAGS_value=$CPPFLAGS
770	–	ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771	–	ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756		ac_env_CXX_set=${CXX+set}
757		ac_env_CXX_value=$CXX
758		ac_cv_env_CXX_set=${CXX+set}
#	Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761		ac_env_CXXFLAGS_value=$CXXFLAGS
762		ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763		ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764	<	ac_env_F90_set=${F90+set}
765	<	ac_env_F90_value=$F90
766	<	ac_cv_env_F90_set=${F90+set}
767	<	ac_cv_env_F90_value=$F90
768	<	ac_env_F90FLAGS_set=${F90FLAGS+set}
769	<	ac_env_F90FLAGS_value=$F90FLAGS
770	<	ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771	<	ac_cv_env_F90FLAGS_value=$F90FLAGS
764	>	ac_env_LDFLAGS_set=${LDFLAGS+set}
765	>	ac_env_LDFLAGS_value=$LDFLAGS
766	>	ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767	>	ac_cv_env_LDFLAGS_value=$LDFLAGS
768	>	ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769	>	ac_env_CPPFLAGS_value=$CPPFLAGS
770	>	ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771	>	ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772	>	ac_env_CC_set=${CC+set}
773	>	ac_env_CC_value=$CC
774	>	ac_cv_env_CC_set=${CC+set}
775	>	ac_cv_env_CC_value=$CC
776	>	ac_env_CFLAGS_set=${CFLAGS+set}
777	>	ac_env_CFLAGS_value=$CFLAGS
778	>	ac_cv_env_CFLAGS_set=${CFLAGS+set}
779	>	ac_cv_env_CFLAGS_value=$CFLAGS
780	>	ac_env_FC_set=${FC+set}
781	>	ac_env_FC_value=$FC
782	>	ac_cv_env_FC_set=${FC+set}
783	>	ac_cv_env_FC_value=$FC
784	>	ac_env_FCFLAGS_set=${FCFLAGS+set}
785	>	ac_env_FCFLAGS_value=$FCFLAGS
786	>	ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787	>	ac_cv_env_FCFLAGS_value=$FCFLAGS
788		ac_env_CPP_set=${CPP+set}
789		ac_env_CPP_value=$CPP
790		ac_cv_env_CPP_set=${CPP+set}
791		ac_cv_env_CPP_value=$CPP
792	+	ac_env_CXXCPP_set=${CXXCPP+set}
793	+	ac_env_CXXCPP_value=$CXXCPP
794	+	ac_cv_env_CXXCPP_set=${CXXCPP+set}
795	+	ac_cv_env_CXXCPP_value=$CXXCPP
796
797		#
798		# Report the --help message.
#	Line 797 | Line 801 | if test "$ac_init_help" = "long"; then
801		# Omit some internal or obsolete options to make the list less imposing.
802		# This message is too long to be a string in the A/UX 3.1 sh.
803		cat <<_ACEOF
804	<	\`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804	>	\`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805
806		Usage: $0 [OPTION]... [VAR=VALUE]...
807
#	Line 858 | Line 862 | if test -n "$ac_init_help"; then
862
863		if test -n "$ac_init_help"; then
864		case $ac_init_help in
865	<	short | recursive ) echo "Configuration of OOPSE 2.0:";;
865	>	short | recursive ) echo "Configuration of OOPSE 3.0:";;
866		esac
867		cat <<\_ACEOF
868
869		Optional Features:
870		--disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871		--enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872	+	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873		--enable-debug          Compile OOPSE in debug mode
874		--enable-doxygen        enable documentation generation with doxygen (auto)
875		--enable-dot            use 'dot' to generate graphs in doxygen (auto)
876		--enable-html-docs      enable HTML generation with doxygen (yes)
877		--enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
873	–	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878
879		Optional Packages:
880		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882	+	--with-perl-shebang     override what perl thinks is the way for the kernel
883	+	to start it (seldom needed)
884	+	--with-zlib=DIR root directory path of zlib installation defaults to
885	+	/usr/local or /usr if not found in /usr/local
886	+	--without-zlib to disable zlib usage completely
887	+	--without-fftw          if you turn this off you cannot compute undulation spectra
888		--with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889	+	--with-cgal-makefile=FILE  CGAL makefile that should be used
890
891		Some influential environment variables:
892	<	CC          C compiler command
893	<	CFLAGS      C compiler flags
892	>	CXX         C++ compiler command
893	>	CXXFLAGS    C++ compiler flags
894		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895		nonstandard directory <lib dir>
896		CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897		headers in a nonstandard directory <include dir>
898	<	CXX         C++ compiler command
899	<	CXXFLAGS    C++ compiler flags
900	<	F90         Fortran 90 compiler command
901	<	F90FLAGS    Fortran 90 compiler flags
898	>	CC          C compiler command
899	>	CFLAGS      C compiler flags
900	>	FC          Fortran compiler command
901	>	FCFLAGS     Fortran compiler flags
902		CPP         C preprocessor
903	+	CXXCPP      C++ preprocessor
904
905		Use these variables to override the choices made by `configure' or to help
906		it to find libraries and programs with nonstandard names/locations.
#	Line 989 | 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 1003 | 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 1365 | 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 -*-
1369	<	# Programming languages support.
1370	<	# Copyright 2000, 2001
1371	<	# Free Software Foundation, Inc.
1372	<	#
1373	<	# This program is free software; you can redistribute it and/or modify
1374	<	# it under the terms of the GNU General Public License as published by
1375	<	# the Free Software Foundation; either version 2, or (at your option)
1376	<	# any later version.
1377	<	#
1378	<	# This program is distributed in the hope that it will be useful,
1379	<	# but WITHOUT ANY WARRANTY; without even the implied warranty of
1380	<	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1381	<	# GNU General Public License for more details.
1382	<	#
1383	<	# You should have received a copy of the GNU General Public License
1384	<	# along with this program; if not, write to the Free Software
1385	<	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1386	<	# 02111-1307, USA.
1387	<	#
1388	<	# As a special exception, the Free Software Foundation gives unlimited
1389	<	# permission to copy, distribute and modify the configure scripts that
1390	<	# are the output of Autoconf.  You need not follow the terms of the GNU
1391	<	# General Public License when using or distributing such scripts, even
1392	<	# though portions of the text of Autoconf appear in them.  The GNU
1393	<	# General Public License (GPL) does govern all other use of the material
1394	<	# that constitutes the Autoconf program.
1395	<	#
1396	<	# Certain portions of the Autoconf source text are designed to be copied
1397	<	# (in certain cases, depending on the input) into the output of
1398	<	# Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1399	<	# source text consists of comments plus executable code that decides which
1400	<	# of the data portions to output in any given case.  We call these
1401	<	# comments and executable code the "non-data" portions.  Autoconf never
1402	<	# copies any of the non-data portions into its output.
1403	<	#
1404	<	# This special exception to the GPL applies to versions of Autoconf
1405	<	# released by the Free Software Foundation.  When you make and
1406	<	# distribute a modified version of Autoconf, you may extend this special
1407	<	# exception to the GPL to apply to your modified version as well, *unless*
1408	<	# your modified version has the potential to copy into its output some
1409	<	# of the text that was the non-data portion of the version that you started
1410	<	# with.  (In other words, unless your change moves or copies text from
1411	<	# the non-data portions to the data portions.)  If your modification has
1412	<	# such potential, you must delete any notice of this special exception
1413	<	# to the GPL from your modified version.
1414	<	#
1415	<	# Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1416	<	# many others).
1417	<
1418	<
1419	<	# Table of Contents:
1420	<	#
1421	<	# 1. Language selection
1422	<	#    and routines to produce programs in a given language.
1423	<	#  a. Fortran 77 (to be moved from aclang.m4)
1424	<	#  b. Fortran 90
1425	<	#  c. Fortran 95
1426	<	#
1427	<	# 2. Producing programs in a given language.
1428	<	#  a. Fortran 77 (to be moved from aclang.m4)
1429	<	#  b. Fortran 90
1430	<	#  c. Fortran 95
1431	<	#
1432	<	# 3. Looking for a compiler
1433	<	#    And possibly the associated preprocessor.
1434	<	#  a. Fortran 77 (to be moved from aclang.m4)
1435	<	#  b. Fortran 90
1436	<	#  c. Fortran 95
1437	<	#
1438	<	# 4. Compilers' characteristics.
1439	<	#  a. Fortran 77 (to be moved from aclang.m4)
1440	<	#  b. Fortran 90
1441	<	#  c. Fortran 95
1442	<
1443	<	# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1444	<	# ---------------------------------------------------------------------------
1445	<	#
1446	<	# Processing the elements of a list is tedious in shell programming,
1447	<	# as lists tend to be implemented as space delimited strings.
1448	<	#
1449	<	# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1450	<	# if ELEMENT is a member of LIST, otherwise it executes
1451	<	# ACTION-IF-NOT-FOUND.
1452	<	# _AC_LIST_MEMBER_IF
1453	<
1454	<
1455	<
1456	<	# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1457	<	# -------------------------------------------------
1458	<	#
1459	<	# Specifying options to the compiler (whether it be the C, C++ or
1460	<	# Fortran 77 compiler) that are meant for the linker is compiler
1461	<	# dependent.  This macro lets you give options to the compiler that
1462	<	# are meant for the linker in a portable, compiler-independent way.
1463	<	#
1464	<	# This macro take two arguments, a list of linker options that the
1465	<	# compiler should pass to the linker (LINKER-OPTIONS) and the name of
1466	<	# a shell variable (SHELL-VARIABLE).  The list of linker options are
1467	<	# appended to the shell variable in a compiler-dependent way.
1468	<	#
1469	<	# For example, if the selected language is C, then this:
1470	<	#
1471	<	#   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1472	<	#
1473	<	# will expand into this if the selected C compiler is gcc:
1474	<	#
1475	<	#   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1476	<	#
1477	<	# otherwise, it will expand into this:
1478	<	#
1479	<	#   foo_LDFLAGS"-R /usr/local/lib/foo"
1480	<	#
1481	<	# You are encouraged to add support for compilers that this macro
1482	<	# doesn't currently support.
1483	<	# FIXME: Get rid of this macro.
1484	<	# _AC_LINKER_OPTION
1485	<
1486	<
1487	<
1488	<	## ----------------------- ##
1489	<	## 1. Language selection.  ##
1490	<	## ----------------------- ##
1491	<
1492	<	# ----------------------------- #
1493	<	# 1b. The Fortran 90 language.  #
1494	<	# ----------------------------- #
1495	<
1496	<	# AC_LANG(Fortran 90)
1497	<	# -------------------
1498	<
1499	<
1500	<
1501	<	# _AC_LANG_ABBREV(Fortran 90)
1502	<	# ---------------------------
1503	<
1504	<
1505	<
1506	<	# ----------------------------- #
1507	<	# 1c. The Fortran 95 language.  #
1508	<	# ----------------------------- #
1509	<
1510	<	# AC_LANG(Fortran 95)
1511	<	# -------------------
1512	<
1513	<
1514	<
1515	<	# _AC_LANG_ABBREV(Fortran 95)
1516	<	# ---------------------------
1517	<
1518	<
1519	<
1520	<	## ---------------------- ##
1521	<	## 2.Producing programs.  ##
1522	<	## ---------------------- ##
1523	<
1524	<	# ------------------------ #
1525	<	# 2b. Fortran 90 sources.  #
1526	<	# ------------------------ #
1527	<
1528	<	# AC_LANG_SOURCE(Fortran 90)(BODY)
1529	<	# --------------------------------
1530	<
1531	<
1532	<
1533	<	# AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1534	<	# -----------------------------------------------
1535	<
1536	<
1537	<	# AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1538	<	# --------------------------------------------
1539	<
1540	<
1541	<
1542	<	# ------------------------ #
1543	<	# 2c. Fortran 95 sources.  #
1544	<	# ------------------------ #
1380	>	ac_config_headers="$ac_config_headers src/config.h"
1381
1546	–	# AC_LANG_SOURCE(Fortran 95)(BODY)
1547	–	# --------------------------------
1382
1383
1550	–	# AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1551	–	# -----------------------------------------------
1384
1385
1554	–	# AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1555	–	# --------------------------------------------
1386
1387
1388
1559	–	## -------------------------------------------- ##
1560	–	## 3. Looking for Compilers and Preprocessors.  ##
1561	–	## -------------------------------------------- ##
1389
1563	–	# ----------------------------- #
1564	–	# 3b. The Fortran 90 compiler.  #
1565	–	# ----------------------------- #
1390
1391
1568	–	# AC_LANG_PREPROC(Fortran 90)
1569	–	# ---------------------------
1570	–	# Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1392
1393
1394
1574	–	# AC_LANG_COMPILER(Fortran 90)
1575	–	# ----------------------------
1576	–	# Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1577	–	# AC_REQUIRE'able.
1395
1396
1397
1581	–	# AC_PROG_F90([COMPILERS...])
1582	–	# ---------------------------
1583	–	# COMPILERS is a space separated list of Fortran 90 compilers to search
1584	–	# for.
1585	–	#
1586	–	# Compilers are ordered by
1587	–	#  1. F90, F95
1588	–	#  2. Good/tested native compilers, bad/untested native compilers
1589	–	#
1590	–	# pgf90 is the Portland Group F90 compilers.
1591	–	# xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1592	–	# lf95 is the Lahey-Fujitsu compiler.
1593	–	# epcf90 is the "Edinburgh Portable Compiler" F90.
1594	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1595	–	# AC_PROG_F90
1398
1399
1598	–	# ----------------------------- #
1599	–	# 3c. The Fortran 95 compiler.  #
1600	–	# ----------------------------- #
1400
1401
1603	–	# AC_LANG_PREPROC(Fortran 95)
1604	–	# ---------------------------
1605	–	# Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1402
1403
1404
1609	–	# AC_LANG_COMPILER(Fortran 95)
1610	–	# ----------------------------
1611	–	# Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1612	–	# AC_REQUIRE'able.
1405
1406
1407
1616	–	# AC_PROG_F95([COMPILERS...])
1617	–	# ---------------------------
1618	–	# COMPILERS is a space separated list of Fortran 95 compilers to search
1619	–	# for.
1620	–	#
1621	–	# Compilers are ordered by
1622	–	#  1. Good/tested native compilers, bad/untested native compilers
1623	–	#
1624	–	# xlf95 is the IBM (AIX) F95 compiler.
1625	–	# lf95 is the Lahey-Fujitsu compiler.
1626	–	# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1627	–	# AC_PROG_F95
1408
1409
1630	–	## ------------------------------- ##
1631	–	## 4. Compilers' characteristics.  ##
1632	–	## ------------------------------- ##
1410
1411
1635	–	# ---------------------------------------- #
1636	–	# 4b. Fortan 90 compiler characteristics.  #
1637	–	# ---------------------------------------- #
1412
1413
1640	–	# _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1641	–	# -------------------------------------------------
1642	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1643	–	# (which default value, $ac_cv_prog_f90_v, is computed by
1644	–	# _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1645	–	# output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1646	–	# so that any link flags that are echoed by the compiler appear as
1647	–	# space-separated items.
1648	–	# _AC_PROG_F90_V_OUTPUT
1414
1415
1651	–	# _AC_PROG_F90_V
1652	–	# --------------
1653	–	#
1654	–	# Determine the flag that causes the Fortran 90 compiler to print
1655	–	# information of library and object files (normally -v)
1656	–	# Needed for AC_F90_LIBRARY_FLAGS
1657	–	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1658	–	# _AC_PROG_F90_V
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
1661	–	# AC_F90_LIBRARY_LDFLAGS
1662	–	# ----------------------
1663	–	#
1664	–	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1665	–	# intrinsic and run-time libraries that are required to successfully
1666	–	# link a Fortran 90 program or shared library.  The output variable
1667	–	# F90LIBS is set to these flags.
1668	–	#
1669	–	# This macro is intended to be used in those situations when it is
1670	–	# necessary to mix, e.g. C++ and Fortran 90, source code into a single
1671	–	# program or shared library.
1672	–	#
1673	–	# For example, if object files from a C++ and Fortran 90 compiler must
1674	–	# be linked together, then the C++ compiler/linker must be used for
1675	–	# linking (since special C++-ish things need to happen at link time
1676	–	# like calling global constructors, instantiating templates, enabling
1677	–	# exception support, etc.).
1678	–	#
1679	–	# However, the Fortran 90 intrinsic and run-time libraries must be
1680	–	# linked in as well, but the C++ compiler/linker doesn't know how to
1681	–	# add these Fortran 90 libraries.  Hence, the macro
1682	–	# "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1683	–	# libraries.
1684	–	#
1685	–	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1686	–	# AC_F90_LIBRARY_LDFLAGS
1425
1426
1689	–	# _AC_F90_NAME_MANGLING
1690	–	# ---------------------
1691	–	# Test for the name mangling scheme used by the Fortran 90 compiler.
1692	–	#
1693	–	# Sets ac_cv_f90_mangling. The value contains three fields, separated
1694	–	# by commas:
1695	–	#
1696	–	# lower case / upper case:
1697	–	#    case translation of the Fortan 90 symbols
1698	–	# underscore / no underscore:
1699	–	#    whether the compiler appends "_" to symbol names
1700	–	# extra underscore / no extra underscore:
1701	–	#    whether the compiler appends an extra "_" to symbol names already
1702	–	#    containing at least one underscore
1703	–	#
1704	–	# _AC_F90_NAME_MANGLING
1427
1706	–	# The replacement is empty.
1428
1429
1430
1710	–	# AC_F90_WRAPPERS
1711	–	# ---------------
1712	–	# Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1713	–	# properly mangle the names of C identifiers, and C identifiers with
1714	–	# underscores, respectively, so that they match the name mangling
1715	–	# scheme used by the Fortran 90 compiler.
1716	–	# AC_F90_WRAPPERS
1431
1432
1719	–	# AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1720	–	# ------------------------------------
1721	–	# For a Fortran subroutine of given NAME, define a shell variable
1722	–	# $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1723	–	# argument is not supplied, it defaults to NAME.
1724	–	# AC_F90_FUNC
1433
1434
1727	–	# ---------------------------------------- #
1728	–	# 4c. Fortan 95 compiler characteristics.  #
1729	–	# ---------------------------------------- #
1435
1731	–
1732	–	# _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1733	–	# -------------------------------------------------
1734	–	# Link a trivial Fortran program, compiling with a verbose output FLAG
1735	–	# (which default value, $ac_cv_prog_f95_v, is computed by
1736	–	# _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1737	–	# output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1738	–	# so that any link flags that are echoed by the compiler appear as
1739	–	# space-separated items.
1740	–	# _AC_PROG_F95_V_OUTPUT
1741	–
1742	–
1743	–	# _AC_PROG_F95_V
1744	–	# --------------
1436		#
1746	–	# Determine the flag that causes the Fortran 95 compiler to print
1747	–	# information of library and object files (normally -v)
1748	–	# Needed for AC_F95_LIBRARY_FLAGS
1749	–	# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1750	–	# _AC_PROG_F95_V
1751	–
1752	–
1753	–	# AC_F95_LIBRARY_LDFLAGS
1754	–	# ----------------------
1437		#
1756	–	# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1757	–	# intrinsic and run-time libraries that are required to successfully
1758	–	# link a Fortran 95 program or shared library.  The output variable
1759	–	# F95LIBS is set to these flags.
1438		#
1761	–	# This macro is intended to be used in those situations when it is
1762	–	# necessary to mix, e.g. C++ and Fortran 95, source code into a single
1763	–	# program or shared library.
1764	–	#
1765	–	# For example, if object files from a C++ and Fortran 95 compiler must
1766	–	# be linked together, then the C++ compiler/linker must be used for
1767	–	# linking (since special C++-ish things need to happen at link time
1768	–	# like calling global constructors, instantiating templates, enabling
1769	–	# exception support, etc.).
1770	–	#
1771	–	# However, the Fortran 95 intrinsic and run-time libraries must be
1772	–	# linked in as well, but the C++ compiler/linker doesn't know how to
1773	–	# add these Fortran 95 libraries.  Hence, the macro
1774	–	# "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1775	–	# libraries.
1776	–	#
1777	–	# This macro was copied from the Fortran 77 version by Matthew D. Langston.
1778	–	# AC_F95_LIBRARY_LDFLAGS
1439
1440
1781	–	# _AC_F95_NAME_MANGLING
1782	–	# ---------------------
1783	–	# Test for the name mangling scheme used by the Fortran 95 compiler.
1784	–	#
1785	–	# Sets ac_cv_f95_mangling. The value contains three fields, separated
1786	–	# by commas:
1787	–	#
1788	–	# lower case / upper case:
1789	–	#    case translation of the Fortan 95 symbols
1790	–	# underscore / no underscore:
1791	–	#    whether the compiler appends "_" to symbol names
1792	–	# extra underscore / no extra underscore:
1793	–	#    whether the compiler appends an extra "_" to symbol names already
1794	–	#    containing at least one underscore
1795	–	#
1796	–	# _AC_F95_NAME_MANGLING
1797	–
1798	–	# The replacement is empty.
1799	–
1800	–
1801	–
1802	–	# AC_F95_WRAPPERS
1803	–	# ---------------
1804	–	# Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1805	–	# properly mangle the names of C identifiers, and C identifiers with
1806	–	# underscores, respectively, so that they match the name mangling
1807	–	# scheme used by the Fortran 95 compiler.
1808	–	# AC_F95_WRAPPERS
1809	–
1810	–
1811	–	# AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1812	–	# ------------------------------------
1813	–	# For a Fortran subroutine of given NAME, define a shell variable
1814	–	# $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1815	–	# argument is not supplied, it defaults to NAME.
1816	–	# AC_F95_FUNC
1817	–
1441		# AC_F90_MODULE_NAMES
1442		# -------------------
1443		#
#	Line 1857 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480
1481
1482
1860	–
1861	–
1862	–
1863	–
1864	–
1865	–
1866	–
1867	–
1868	–
1869	–
1870	–
1871	–
1872	–
1873	–
1874	–
1875	–
1876	–
1877	–
1878	–
1879	–
1880	–
1881	–
1882	–
1883	–	# set program name
1884	–	PROGNAME="oopse"
1885	–
1886	–
1887	–	# there are two ways to do debugging.  One with the --enable-debug flag
1888	–	# and one using the DEBUG environment variable
1889	–
1890	–	debug=0
1891	–	# Check whether --enable-debug or --disable-debug was given.
1892	–	if test "${enable_debug+set}" = set; then
1893	–	enableval="$enable_debug"
1894	–	debug=1
1895	–	fi;
1896	–	if test "${DEBUG}"; then
1897	–
1898	–	cat >>confdefs.h <<\_ACEOF
1899	–	#define debug 1
1900	–	_ACEOF
1901	–
1902	–	msg="$msg, debug mode"
1903	–	fi
1904	–
1905	–
1483		# who am i
1484		# Make sure we can run config.sub.
1485		$ac_config_sub sun4 >/dev/null 2>&1 ||
#	Line 1961 | 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 1986 | 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 1995 | 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 2028 | 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 2037 | 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
2056	–	test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2057	–	See \`config.log' for more details." >&5
2058	–	echo "$as_me: error: no acceptable C compiler found in \$PATH
2059	–	See \`config.log' for more details." >&2;}
2060	–	{ (exit 1); exit 1; }; }
2061	–
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 2099 | 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 2143 | 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 2156 | 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 2172 | 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 2280 | 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 2312 | 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 2333 | 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 2371 | 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 2384 | 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
2414	<	echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2415	<	if test "${ac_cv_prog_cc_stdc+set}" = set; then
2416	<	echo $ECHO_N "(cached) $ECHO_C" >&6
2417	<	else
2418	<	ac_cv_prog_cc_stdc=no
2419	<	ac_save_CC=$CC
2420	<	cat >conftest.$ac_ext <<_ACEOF
2421	<	/* confdefs.h.  */
2422	<	_ACEOF
2423	<	cat confdefs.h >>conftest.$ac_ext
2424	<	cat >>conftest.$ac_ext <<_ACEOF
2425	<	/* end confdefs.h.  */
2426	<	#include <stdarg.h>
2427	<	#include <stdio.h>
2428	<	#include <sys/types.h>
2429	<	#include <sys/stat.h>
2430	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2431	<	struct buf { int x; };
2432	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
2433	<	static char *e (p, i)
2434	<	char **p;
2435	<	int i;
2436	<	{
2437	<	return p[i];
2438	<	}
2439	<	static char *f (char * (*g) (char **, int), char **p, ...)
2440	<	{
2441	<	char *s;
2442	<	va_list v;
2443	<	va_start (v,p);
2444	<	s = g (p, va_arg (v,int));
2445	<	va_end (v);
2446	<	return s;
2447	<	}
2448	<
2449	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2450	<	function prototypes and stuff, but not '\xHH' hex character constants.
2451	<	These don't provoke an error unfortunately, instead are silently treated
2452	<	as 'x'.  The following induces an error, until -std1 is added to get
2453	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2454	<	array size at least.  It's necessary to write '\x00'==0 to get something
2455	<	that's true only with -std1.  */
2456	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2457	<
2458	<	int test (int i, double x);
2459	<	struct s1 {int (*f) (int a);};
2460	<	struct s2 {int (*f) (double a);};
2461	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2462	<	int argc;
2463	<	char **argv;
2464	<	int
2465	<	main ()
2466	<	{
2467	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2468	<	;
2469	<	return 0;
2470	<	}
2471	<	_ACEOF
2472	<	# Don't try gcc -ansi; that turns off useful extensions and
2473	<	# breaks some systems' header files.
2474	<	# AIX                   -qlanglvl=ansi
2475	<	# Ultrix and OSF/1      -std1
2476	<	# HP-UX 10.20 and later -Ae
2477	<	# HP-UX older versions  -Aa -D_HPUX_SOURCE
2478	<	# SVR4                  -Xc -D__EXTENSIONS__
2479	<	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2480	<	do
2481	<	CC="$ac_save_CC $ac_arg"
2482	<	rm -f conftest.$ac_objext
2483	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2484	<	(eval $ac_compile) 2>conftest.er1
2485	<	ac_status=$?
2486	<	grep -v '^ *+' conftest.er1 >conftest.err
2487	<	rm -f conftest.er1
2488	<	cat conftest.err >&5
2489	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2490	<	(exit $ac_status); } &&
2491	<	{ ac_try='test -z "$ac_c_werror_flag"
2492	<	|| test ! -s conftest.err'
2493	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2494	<	(eval $ac_try) 2>&5
2495	<	ac_status=$?
2496	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2497	<	(exit $ac_status); }; } &&
2498	<	{ ac_try='test -s conftest.$ac_objext'
2499	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2500	<	(eval $ac_try) 2>&5
2501	<	ac_status=$?
2502	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2503	<	(exit $ac_status); }; }; then
2504	<	ac_cv_prog_cc_stdc=$ac_arg
2505	<	break
2506	<	else
2507	<	echo "$as_me: failed program was:" >&5
2508	<	sed 's/^/| /' conftest.$ac_ext >&5
2509	<
2510	<	fi
2511	<	rm -f conftest.err conftest.$ac_objext
2512	<	done
2513	<	rm -f conftest.$ac_ext conftest.$ac_objext
2514	<	CC=$ac_save_CC
2515	<
2516	<	fi
2517	<
2518	<	case "x$ac_cv_prog_cc_stdc" in
2519	<	x|xno)
2520	<	echo "$as_me:$LINENO: result: none needed" >&5
2521	<	echo "${ECHO_T}none needed" >&6 ;;
2522	<	*)
2523	<	echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2524	<	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2525	<	CC="$CC $ac_cv_prog_cc_stdc" ;;
2526	<	esac
2527	<
2528	<	# Some people use a C++ compiler to compile C.  Since we use `exit',
2529	<	# in C++ we need to declare it.  In case someone uses the same compiler
2530	<	# for both compiling C and C++ we need to have the C++ compiler decide
2531	<	# the declaration of exit, since it's the most demanding environment.
2532	<	cat >conftest.$ac_ext <<_ACEOF
2533	<	#ifndef __cplusplus
2534	<	choke me
2535	<	#endif
2536	<	_ACEOF
2537	<	rm -f conftest.$ac_objext
2538	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2539	<	(eval $ac_compile) 2>conftest.er1
2540	<	ac_status=$?
2541	<	grep -v '^ *+' conftest.er1 >conftest.err
2542	<	rm -f conftest.er1
2543	<	cat conftest.err >&5
2544	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2545	<	(exit $ac_status); } &&
2546	<	{ ac_try='test -z "$ac_c_werror_flag"
2547	<	|| test ! -s conftest.err'
2548	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2549	<	(eval $ac_try) 2>&5
2550	<	ac_status=$?
2551	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2552	<	(exit $ac_status); }; } &&
2553	<	{ ac_try='test -s conftest.$ac_objext'
2554	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2555	<	(eval $ac_try) 2>&5
2556	<	ac_status=$?
2557	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2558	<	(exit $ac_status); }; }; then
2559	<	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 2589 | 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 2634 | 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 2662 | Line 2130 | fi
2130		echo '#endif'             >>confdefs.h
2131		fi
2132
2665	–	else
2666	–	echo "$as_me: failed program was:" >&5
2667	–	sed 's/^/| /' conftest.$ac_ext >&5
2668	–
2669	–	fi
2670	–	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'
2682	<	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 2700 | 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 2709 | 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 2742 | 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 2751 | 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
2765	–	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 2788 | 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 2820 | 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 2841 | 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 2879 | 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 2892 | 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
2929	<	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;
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 2951 | 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 2964 | 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 2996 | 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 3024 | Line 2636 | fi
2636		echo '#endif'             >>confdefs.h
2637		fi
2638
2639	+	else
2640	+	echo "$as_me: failed program was:" >&5
2641	+	sed 's/^/| /' conftest.$ac_ext >&5
2642	+
2643	+	fi
2644	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645		ac_ext=c
2646		ac_cpp='$CPP $CPPFLAGS'
2647		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650
2651	<
2652	<	OOPSE_TEMPLATE_FLAGS=""
2653	<	if test $ac_cv_cxx_compiler_gnu = no; then
2654	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3037	<	echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3038	<	echo 'void f(){}' > conftest.cc
3039	<	if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3040	<	echo "$as_me:$LINENO: result: yes" >&5
3041	<	echo "${ECHO_T}yes" >&6
3042	<	OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3043	<	else
3044	<	echo "$as_me:$LINENO: result: no" >&5
3045	<	echo "${ECHO_T}no" >&6
3046	<	fi
3047	<	rm -f conftest*
3048	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3049	<	echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3050	<	echo 'void f(){}' > conftest.cc
3051	<	if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3052	<	echo "$as_me:$LINENO: result: yes" >&5
3053	<	echo "${ECHO_T}yes" >&6
3054	<	OOPSE_TEMPLATE_FLAGS="-instances=static"
3055	<	else
3056	<	echo "$as_me:$LINENO: result: no" >&5
3057	<	echo "${ECHO_T}no" >&6
3058	<	fi
3059	<	rm -f conftest*
3060	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3061	<	echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3062	<	echo 'void f(){}' > conftest.cc
3063	<	if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3064	<	echo "$as_me:$LINENO: result: yes" >&5
3065	<	echo "${ECHO_T}yes" >&6
3066	<	OOPSE_TEMPLATE_FLAGS="-pto"
3067	<	else
3068	<	echo "$as_me:$LINENO: result: no" >&5
3069	<	echo "${ECHO_T}no" >&6
3070	<	fi
3071	<	rm -f conftest*
3072	<	echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3073	<	echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3074	<	echo 'void f(){}' > conftest.cc
3075	<	if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3076	<	echo "$as_me:$LINENO: result: yes" >&5
3077	<	echo "${ECHO_T}yes" >&6
3078	<
3079	<
3080	<	EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3081	<	else
3082	<	echo "$as_me:$LINENO: result: no" >&5
3083	<	echo "${ECHO_T}no" >&6
3084	<	fi
3085	<	fi
3086	<
3087	<
3088	<
3089	<
3090	<	ac_ext=f90
3091	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3092	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3093	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2651	>	ac_ext=${FC_SRCEXT-f}
2652	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655		if test -n "$ac_tool_prefix"; then
2656	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2656	>	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657		do
2658		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660		echo "$as_me:$LINENO: checking for $ac_word" >&5
2661		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662	<	if test "${ac_cv_prog_F90+set}" = set; then
2662	>	if test "${ac_cv_prog_FC+set}" = set; then
2663		echo $ECHO_N "(cached) $ECHO_C" >&6
2664		else
2665	<	if test -n "$F90"; then
2666	<	ac_cv_prog_F90="$F90" # Let the user override the test.
2665	>	if test -n "$FC"; then
2666	>	ac_cv_prog_FC="$FC" # Let the user override the test.
2667		else
2668		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669		for as_dir in $PATH
#	Line 3111 | Line 2672 | do
2672		test -z "$as_dir" && as_dir=.
2673		for ac_exec_ext in '' $ac_executable_extensions; do
2674		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675	<	ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2675	>	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677		break 2
2678		fi
#	Line 3120 | Line 2681 | fi
2681
2682		fi
2683		fi
2684	<	F90=$ac_cv_prog_F90
2685	<	if test -n "$F90"; then
2686	<	echo "$as_me:$LINENO: result: $F90" >&5
2687	<	echo "${ECHO_T}$F90" >&6
2684	>	FC=$ac_cv_prog_FC
2685	>	if test -n "$FC"; then
2686	>	echo "$as_me:$LINENO: result: $FC" >&5
2687	>	echo "${ECHO_T}$FC" >&6
2688		else
2689		echo "$as_me:$LINENO: result: no" >&5
2690		echo "${ECHO_T}no" >&6
2691		fi
2692
2693	<	test -n "$F90" && break
2693	>	test -n "$FC" && break
2694		done
2695		fi
2696	<	if test -z "$F90"; then
2697	<	ac_ct_F90=$F90
2698	<	for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2696	>	if test -z "$FC"; then
2697	>	ac_ct_FC=$FC
2698	>	for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699		do
2700		# Extract the first word of "$ac_prog", so it can be a program name with args.
2701		set dummy $ac_prog; ac_word=$2
2702		echo "$as_me:$LINENO: checking for $ac_word" >&5
2703		echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704	<	if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2704	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705		echo $ECHO_N "(cached) $ECHO_C" >&6
2706		else
2707	<	if test -n "$ac_ct_F90"; then
2708	<	ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2707	>	if test -n "$ac_ct_FC"; then
2708	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709		else
2710		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711		for as_dir in $PATH
#	Line 3153 | Line 2714 | do
2714		test -z "$as_dir" && as_dir=.
2715		for ac_exec_ext in '' $ac_executable_extensions; do
2716		if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717	<	ac_cv_prog_ac_ct_F90="$ac_prog"
2717	>	ac_cv_prog_ac_ct_FC="$ac_prog"
2718		echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719		break 2
2720		fi
#	Line 3162 | Line 2723 | fi
2723
2724		fi
2725		fi
2726	<	ac_ct_F90=$ac_cv_prog_ac_ct_F90
2727	<	if test -n "$ac_ct_F90"; then
2728	<	echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2729	<	echo "${ECHO_T}$ac_ct_F90" >&6
2726	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727	>	if test -n "$ac_ct_FC"; then
2728	>	echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729	>	echo "${ECHO_T}$ac_ct_FC" >&6
2730		else
2731		echo "$as_me:$LINENO: result: no" >&5
2732		echo "${ECHO_T}no" >&6
2733		fi
2734
2735	<	test -n "$ac_ct_F90" && break
2735	>	test -n "$ac_ct_FC" && break
2736		done
2737
2738	<	F90=$ac_ct_F90
2738	>	FC=$ac_ct_FC
2739		fi
2740
2741
2742	<	# If we don't use `.F90' as extension, the preprocessor is not run on the
2743	<	# input file.
2742	>	# Provide some information about the compiler.
2743	>	echo "$as_me:2743:" \
2744	>	"checking for Fortran compiler version" >&5
2745	>	ac_compiler=`set X $ac_compile; echo $2`
2746	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747	>	(eval $ac_compiler --version </dev/null >&5) 2>&5
2748	>	ac_status=$?
2749	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750	>	(exit $ac_status); }
2751	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752	>	(eval $ac_compiler -v </dev/null >&5) 2>&5
2753	>	ac_status=$?
2754	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755	>	(exit $ac_status); }
2756	>	{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757	>	(eval $ac_compiler -V </dev/null >&5) 2>&5
2758	>	ac_status=$?
2759	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760	>	(exit $ac_status); }
2761	>	rm -f a.out
2762	>
2763	>	# If we don't use `.F' as extension, the preprocessor is not run on the
2764	>	# input file.  (Note that this only needs to work for GNU compilers.)
2765		ac_save_ext=$ac_ext
2766	<	ac_ext=F90
2767	<	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2768	<	echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2769	<	if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2766	>	ac_ext=F
2767	>	echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768	>	echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770		echo $ECHO_N "(cached) $ECHO_C" >&6
2771		else
2772		cat >conftest.$ac_ext <<_ACEOF
2773	<
3192	<	program main
3193	<
2773	>	program main
2774		#ifndef __GNUC__
2775		choke me
2776		#endif
2777
2778	<	end program main
3199	<
2778	>	end
2779		_ACEOF
2780		rm -f conftest.$ac_objext
2781		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3207 | Line 2786 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2786		cat conftest.err >&5
2787		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788		(exit $ac_status); } &&
2789	<	{ ac_try='test -z "$ac_f90_werror_flag"
2789	>	{ ac_try='test -z "$ac_fc_werror_flag"
2790		|| test ! -s conftest.err'
2791		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792		(eval $ac_try) 2>&5
#	Line 3228 | Line 2807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2807		ac_compiler_gnu=no
2808		fi
2809		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810	<	ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2810	>	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811
2812		fi
2813	<	echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2814	<	echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2813	>	echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814	>	echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815		ac_ext=$ac_save_ext
2816	<	G95=`test $ac_compiler_gnu = yes && echo yes`
2817	<	ac_ext=c
2818	<	ac_cpp='$CPP $CPPFLAGS'
2819	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2820	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2821	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2816	>	ac_test_FFLAGS=${FCFLAGS+set}
2817	>	ac_save_FFLAGS=$FCFLAGS
2818	>	FCFLAGS=
2819	>	echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820	>	echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821	>	if test "${ac_cv_prog_fc_g+set}" = set; then
2822	>	echo $ECHO_N "(cached) $ECHO_C" >&6
2823	>	else
2824	>	FCFLAGS=-g
2825	>	cat >conftest.$ac_ext <<_ACEOF
2826	>	program main
2827
2828	<
3245	<
3246	<
3247	<
3248	<	# Try to determine native compiler flags that allow us to use F90 suffix
3249	<	# for preprocessed f90 source.
3250	<
3251	<	if test "$ac_test_PREPFLAG" != "set"; then
3252	<	PREPFLAG=""
3253	<	case "${host_cpu}-${host_os}" in
3254	<
3255	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3256	<	PREPFLAG="-fpp1 "
3257	<	fi;;
3258	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3259	<	PREPFLAG="-qsuffix=cpp=F90 "
3260	<	fi;;
3261	<	*darwin*)
3262	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3263	<	PREPFLAG="-qsuffix=cpp=F90 "
3264	<	fi;;
3265	<	esac
3266	<
3267	<	if test -z "$PREPFLAG"; then
3268	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3269	<	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3270	<	PREPFLAG=""
3271	<	fi
3272	<
3273	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3274	<	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3275	<
3276	<
3277	<	ac_ext=f90
3278	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3279	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3280	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3281	<
3282	<	ac_save_ext=$ac_ext
3283	<	ac_ext=F90
3284	<	ac_save_F90FLAGS=$F90FLAGS
3285	<
3286	<	if test "$PREPFLAG"; then
3287	<	F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3288	<	fi
3289	<
3290	<	cat >conftest.$ac_ext <<_ACEOF
3291	<
3292	<
3293	<	program main
3294	<
3295	<	integer :: i
3296	<	i = 1
3297	<
3298	<
3299	<	end program main
3300	<
2828	>	end
2829		_ACEOF
2830		rm -f conftest.$ac_objext
2831		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
#	Line 3308 | Line 2836 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2836		cat conftest.err >&5
2837		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838		(exit $ac_status); } &&
2839	<	{ ac_try='test -z "$ac_f90_werror_flag"
2839	>	{ ac_try='test -z "$ac_fc_werror_flag"
2840		|| test ! -s conftest.err'
2841		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842		(eval $ac_try) 2>&5
#	Line 3321 | Line 2849 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2849		ac_status=$?
2850		echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851		(exit $ac_status); }; }; then
2852	<	prepflagworks=1
2852	>	ac_cv_prog_fc_g=yes
2853		else
2854		echo "$as_me: failed program was:" >&5
2855		sed 's/^/| /' conftest.$ac_ext >&5
2856
2857	<	prepflagworks=0
2857	>	ac_cv_prog_fc_g=no
2858		fi
2859		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860
2861	<	F90FLAGS=$ac_save_F90FLAGS
2862	<	ac_ext=$ac_save_ext
2863	<	ac_ext=c
2861	>	fi
2862	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863	>	echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864	>	if test "$ac_test_FFLAGS" = set; then
2865	>	FCFLAGS=$ac_save_FFLAGS
2866	>	elif test $ac_cv_prog_fc_g = yes; then
2867	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868	>	FCFLAGS="-g -O2"
2869	>	else
2870	>	FCFLAGS="-g"
2871	>	fi
2872	>	else
2873	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874	>	FCFLAGS="-O2"
2875	>	else
2876	>	FCFLAGS=
2877	>	fi
2878	>	fi
2879	>
2880	>	ac_ext=c
2881		ac_cpp='$CPP $CPPFLAGS'
2882		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885
2886	+	ac_ext=c
2887	+	ac_cpp='$CPP $CPPFLAGS'
2888	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891	+	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892	+	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893	+	# On Suns, sometimes $CPP names a directory.
2894	+	if test -n "$CPP" && test -d "$CPP"; then
2895	+	CPP=
2896	+	fi
2897	+	if test -z "$CPP"; then
2898	+	if test "${ac_cv_prog_CPP+set}" = set; then
2899	+	echo $ECHO_N "(cached) $ECHO_C" >&6
2900	+	else
2901	+	# Double quotes because CPP needs to be expanded
2902	+	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2903	+	do
2904	+	ac_preproc_ok=false
2905	+	for ac_c_preproc_warn_flag in '' yes
2906	+	do
2907	+	# Use a header file that comes with gcc, so configuring glibc
2908	+	# with a fresh cross-compiler works.
2909	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2910	+	# <limits.h> exists even on freestanding compilers.
2911	+	# On the NeXT, cc -E runs the code through the compiler's parser,
2912	+	# not just through cpp. "Syntax error" is here to catch this case.
2913	+	cat >conftest.$ac_ext <<_ACEOF
2914	+	/* confdefs.h.  */
2915	+	_ACEOF
2916	+	cat confdefs.h >>conftest.$ac_ext
2917	+	cat >>conftest.$ac_ext <<_ACEOF
2918	+	/* end confdefs.h.  */
2919	+	#ifdef __STDC__
2920	+	# include <limits.h>
2921	+	#else
2922	+	# include <assert.h>
2923	+	#endif
2924	+	Syntax error
2925	+	_ACEOF
2926	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2927	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2928	+	ac_status=$?
2929	+	grep -v '^ *+' conftest.er1 >conftest.err
2930	+	rm -f conftest.er1
2931	+	cat conftest.err >&5
2932	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933	+	(exit $ac_status); } >/dev/null; then
2934	+	if test -s conftest.err; then
2935	+	ac_cpp_err=$ac_c_preproc_warn_flag
2936	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2937	+	else
2938	+	ac_cpp_err=
2939	+	fi
2940	+	else
2941	+	ac_cpp_err=yes
2942	+	fi
2943	+	if test -z "$ac_cpp_err"; then
2944	+	:
2945	+	else
2946	+	echo "$as_me: failed program was:" >&5
2947	+	sed 's/^/| /' conftest.$ac_ext >&5
2948
2949	<	if test "$prepflagworks" = 1; then
2950	<	echo "$as_me:$LINENO: result: yes" >&5
2951	<	echo "${ECHO_T}yes" >&6
2949	>	# Broken: fails on valid input.
2950	>	continue
2951	>	fi
2952	>	rm -f conftest.err conftest.$ac_ext
2953
2954	+	# OK, works on sane cases.  Now check whether non-existent headers
2955	+	# can be detected and how.
2956	+	cat >conftest.$ac_ext <<_ACEOF
2957	+	/* confdefs.h.  */
2958	+	_ACEOF
2959	+	cat confdefs.h >>conftest.$ac_ext
2960	+	cat >>conftest.$ac_ext <<_ACEOF
2961	+	/* end confdefs.h.  */
2962	+	#include <ac_nonexistent.h>
2963	+	_ACEOF
2964	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2965	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2966	+	ac_status=$?
2967	+	grep -v '^ *+' conftest.er1 >conftest.err
2968	+	rm -f conftest.er1
2969	+	cat conftest.err >&5
2970	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2971	+	(exit $ac_status); } >/dev/null; then
2972	+	if test -s conftest.err; then
2973	+	ac_cpp_err=$ac_c_preproc_warn_flag
2974	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2975		else
2976	<	echo "$as_me:$LINENO: result: no" >&5
3348	<	echo "${ECHO_T}no" >&6
3349	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3350	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3351	<	{ (exit 1); exit 1; }; }
2976	>	ac_cpp_err=
2977		fi
2978	+	else
2979	+	ac_cpp_err=yes
2980		fi
2981	+	if test -z "$ac_cpp_err"; then
2982	+	# Broken: success on invalid input.
2983	+	continue
2984	+	else
2985	+	echo "$as_me: failed program was:" >&5
2986	+	sed 's/^/| /' conftest.$ac_ext >&5
2987
2988	+	# Passes both tests.
2989	+	ac_preproc_ok=:
2990	+	break
2991	+	fi
2992	+	rm -f conftest.err conftest.$ac_ext
2993
2994	<
2995	<
2996	<
2997	<	# Try to determine native compiler flags that allow us to use F90 suffix
2998	<	# for preprocessed f90 source with -D type defines
3361	<
3362	<	if test "$ac_test_PREPDEFFLAG" != "set"; then
3363	<	PREPDEFFLAG=""
3364	<	case "${host_cpu}-${host_os}" in
3365	<
3366	<	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3367	<	PREPDEFFLAG=" "
3368	<	fi;;
3369	<	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3370	<	PREPDEFFLAG="-WF,"
3371	<	fi;;
3372	<	*darwin*)
3373	<	if test "$F90" = f90 -o "$F90" = xlf90; then
3374	<	PREPDEFFLAG="-WF,"
3375	<	fi;;
3376	<	esac
3377	<
3378	<	if test -z "$PREPDEFFLAG"; then
3379	<	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3380	<	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3381	<	PREPDEFFLAG=" "
3382	<	fi
3383	<
3384	<	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3385	<	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3386	<
3387	<
3388	<	ac_ext=f90
3389	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3390	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3391	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3392	<
3393	<	ac_save_ext=$ac_ext
3394	<	ac_ext=F90
3395	<	ac_save_F90FLAGS=$F90FLAGS
3396	<
3397	<	if test "$PREPDEFFLAG"; then
3398	<	F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
2994	>	done
2995	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2996	>	rm -f conftest.err conftest.$ac_ext
2997	>	if $ac_preproc_ok; then
2998	>	break
2999		fi
3000
3001	<	cat >conftest.$ac_ext <<_ACEOF
3001	>	done
3002	>	ac_cv_prog_CPP=$CPP
3003
3004	<
3005	<	program main
3006	<
3007	<	integer :: i
3008	<	#ifdef TEST
3009	<	i = 1
3004	>	fi
3005	>	CPP=$ac_cv_prog_CPP
3006	>	else
3007	>	ac_cv_prog_CPP=$CPP
3008	>	fi
3009	>	echo "$as_me:$LINENO: result: $CPP" >&5
3010	>	echo "${ECHO_T}$CPP" >&6
3011	>	ac_preproc_ok=false
3012	>	for ac_c_preproc_warn_flag in '' yes
3013	>	do
3014	>	# Use a header file that comes with gcc, so configuring glibc
3015	>	# with a fresh cross-compiler works.
3016	>	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3017	>	# <limits.h> exists even on freestanding compilers.
3018	>	# On the NeXT, cc -E runs the code through the compiler's parser,
3019	>	# not just through cpp. "Syntax error" is here to catch this case.
3020	>	cat >conftest.$ac_ext <<_ACEOF
3021	>	/* confdefs.h.  */
3022	>	_ACEOF
3023	>	cat confdefs.h >>conftest.$ac_ext
3024	>	cat >>conftest.$ac_ext <<_ACEOF
3025	>	/* end confdefs.h.  */
3026	>	#ifdef __STDC__
3027	>	# include <limits.h>
3028		#else
3029	<	choke me
3029	>	# include <assert.h>
3030		#endif
3031	+	Syntax error
3032	+	_ACEOF
3033	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3034	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3035	+	ac_status=$?
3036	+	grep -v '^ *+' conftest.er1 >conftest.err
3037	+	rm -f conftest.er1
3038	+	cat conftest.err >&5
3039	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3040	+	(exit $ac_status); } >/dev/null; then
3041	+	if test -s conftest.err; then
3042	+	ac_cpp_err=$ac_c_preproc_warn_flag
3043	+	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3044	+	else
3045	+	ac_cpp_err=
3046	+	fi
3047	+	else
3048	+	ac_cpp_err=yes
3049	+	fi
3050	+	if test -z "$ac_cpp_err"; then
3051	+	:
3052	+	else
3053	+	echo "$as_me: failed program was:" >&5
3054	+	sed 's/^/| /' conftest.$ac_ext >&5
3055
3056	+	# Broken: fails on valid input.
3057	+	continue
3058	+	fi
3059	+	rm -f conftest.err conftest.$ac_ext
3060
3061	<	end program main
3062	<
3061	>	# OK, works on sane cases.  Now check whether non-existent headers
3062	>	# can be detected and how.
3063	>	cat >conftest.$ac_ext <<_ACEOF
3064	>	/* confdefs.h.  */
3065		_ACEOF
3066	<	rm -f conftest.$ac_objext
3067	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3068	<	(eval $ac_compile) 2>conftest.er1
3066	>	cat confdefs.h >>conftest.$ac_ext
3067	>	cat >>conftest.$ac_ext <<_ACEOF
3068	>	/* end confdefs.h.  */
3069	>	#include <ac_nonexistent.h>
3070	>	_ACEOF
3071	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3072	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3073		ac_status=$?
3074		grep -v '^ *+' conftest.er1 >conftest.err
3075		rm -f conftest.er1
3076		cat conftest.err >&5
3077		echo "$as_me:$LINENO: \$? = $ac_status" >&5
3078	<	(exit $ac_status); } &&
3079	<	{ ac_try='test -z "$ac_f90_werror_flag"
3080	<	|| test ! -s conftest.err'
3081	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3082	<	(eval $ac_try) 2>&5
3083	<	ac_status=$?
3084	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3432	<	(exit $ac_status); }; } &&
3433	<	{ ac_try='test -s conftest.$ac_objext'
3434	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3435	<	(eval $ac_try) 2>&5
3436	<	ac_status=$?
3437	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3438	<	(exit $ac_status); }; }; then
3439	<	prepdefflagworks=1
3078	>	(exit $ac_status); } >/dev/null; then
3079	>	if test -s conftest.err; then
3080	>	ac_cpp_err=$ac_c_preproc_warn_flag
3081	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3082	>	else
3083	>	ac_cpp_err=
3084	>	fi
3085		else
3086	+	ac_cpp_err=yes
3087	+	fi
3088	+	if test -z "$ac_cpp_err"; then
3089	+	# Broken: success on invalid input.
3090	+	continue
3091	+	else
3092		echo "$as_me: failed program was:" >&5
3093		sed 's/^/| /' conftest.$ac_ext >&5
3094
3095	<	prepdefflagworks=0
3095	>	# Passes both tests.
3096	>	ac_preproc_ok=:
3097	>	break
3098		fi
3099	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3099	>	rm -f conftest.err conftest.$ac_ext
3100
3101	<	F90FLAGS=$ac_save_F90FLAGS
3102	<	ac_ext=$ac_save_ext
3103	<	ac_ext=c
3101	>	done
3102	>	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3103	>	rm -f conftest.err conftest.$ac_ext
3104	>	if $ac_preproc_ok; then
3105	>	:
3106	>	else
3107	>	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3108	>	See \`config.log' for more details." >&5
3109	>	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3110	>	See \`config.log' for more details." >&2;}
3111	>	{ (exit 1); exit 1; }; }
3112	>	fi
3113	>
3114	>	ac_ext=c
3115		ac_cpp='$CPP $CPPFLAGS'
3116		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3117		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119
3120	+	echo "$as_me:$LINENO: checking for egrep" >&5
3121	+	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122	+	if test "${ac_cv_prog_egrep+set}" = set; then
3123	+	echo $ECHO_N "(cached) $ECHO_C" >&6
3124	+	else
3125	+	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3126	+	then ac_cv_prog_egrep='grep -E'
3127	+	else ac_cv_prog_egrep='egrep'
3128	+	fi
3129	+	fi
3130	+	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3131	+	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132	+	EGREP=$ac_cv_prog_egrep
3133
3134
3135	<	if test "$prepdefflagworks" = 1; then
3136	<	echo "$as_me:$LINENO: result: yes" >&5
3135	>	echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136	>	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137	>	LN_S=$as_ln_s
3138	>	if test "$LN_S" = "ln -s"; then
3139	>	echo "$as_me:$LINENO: result: yes" >&5
3140		echo "${ECHO_T}yes" >&6
3141	+	else
3142	+	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143	+	echo "${ECHO_T}no, using $LN_S" >&6
3144	+	fi
3145
3146	<	else
3147	<	echo "$as_me:$LINENO: result: no" >&5
3146	>	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147	>	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148	>	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149	>	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3151	>	else
3152	>	cat >conftest.make <<\_ACEOF
3153	>	all:
3154	>	@echo 'ac_maketemp="$(MAKE)"'
3155	>	_ACEOF
3156	>	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157	>	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158	>	if test -n "$ac_maketemp"; then
3159	>	eval ac_cv_prog_make_${ac_make}_set=yes
3160	>	else
3161	>	eval ac_cv_prog_make_${ac_make}_set=no
3162	>	fi
3163	>	rm -f conftest.make
3164	>	fi
3165	>	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166	>	echo "$as_me:$LINENO: result: yes" >&5
3167	>	echo "${ECHO_T}yes" >&6
3168	>	SET_MAKE=
3169	>	else
3170	>	echo "$as_me:$LINENO: result: no" >&5
3171		echo "${ECHO_T}no" >&6
3172	<	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3466	<	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3467	<	{ (exit 1); exit 1; }; }
3468	<	fi
3172	>	SET_MAKE="MAKE=${MAKE-make}"
3173		fi
3174
3175	<	ac_ext=f90
3176	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3177	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3178	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
3476	–
3477	–
3478	–	ac_ext=f90
3479	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3480	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3481	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3482	–	echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3483	–	echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3484	–	if test "${ac_cv_prog_f90_v+set}" = set; then
3485	–	echo $ECHO_N "(cached) $ECHO_C" >&6
3486	–	else
3487	–
3488	–	cat >conftest.$ac_ext <<_ACEOF
3489	–
3490	–	program main
3491	–
3492	–
3493	–	end program main
3494	–
3495	–	_ACEOF
3496	–	rm -f conftest.$ac_objext
3497	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3498	–	(eval $ac_compile) 2>conftest.er1
3499	–	ac_status=$?
3500	–	grep -v '^ *+' conftest.er1 >conftest.err
3501	–	rm -f conftest.er1
3502	–	cat conftest.err >&5
3503	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3504	–	(exit $ac_status); } &&
3505	–	{ ac_try='test -z "$ac_f90_werror_flag"
3506	–	|| test ! -s conftest.err'
3507	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3508	–	(eval $ac_try) 2>&5
3509	–	ac_status=$?
3510	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3511	–	(exit $ac_status); }; } &&
3512	–	{ ac_try='test -s conftest.$ac_objext'
3513	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3514	–	(eval $ac_try) 2>&5
3515	–	ac_status=$?
3516	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3517	–	(exit $ac_status); }; }; then
3518	–	ac_cv_prog_f90_v=
3519	–	# Try some options frequently used verbose output
3520	–	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3521	–	ac_ext=f90
3522	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3523	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3524	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3525	–
3526	–	cat >conftest.$ac_ext <<_ACEOF
3527	–
3528	–	program main
3529	–
3530	–
3531	–	end program main
3532	–
3533	–	_ACEOF
3534	–
3535	–	# Compile and link our simple test program by passing a flag (argument
3536	–	# 1 to this macro) to the Fortran 90 compiler in order to get
3537	–	# "verbose" output that we can then parse for the Fortran 90 linker
3538	–	# flags.
3539	–	ac_save_F90FLAGS=$F90FLAGS
3540	–	F90FLAGS="$F90FLAGS $ac_verb"
3541	–
3542	–	(eval echo $as_me:3542: \"$ac_link\") >&5
3543	–	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3544	–	echo "$ac_f90_v_output" >&5
3545	–	F90FLAGS=$ac_save_F90FLAGS
3546	–
3547	–	rm -f conftest.*
3548	–	ac_ext=f90
3549	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3550	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3551	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3552	–
3553	–	# If we are using xlf then replace all the commas with spaces.
3554	–	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3555	–	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3200		fi
3557	–
3558	–	# If we are using Cray Fortran then delete quotes.
3559	–	# Use "\"" instead of '"' for font-lock-mode.
3560	–	# FIXME: a more general fix for quoted arguments with spaces?
3561	–	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3562	–	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3201		fi
3202	<	# look for -l* and *.a constructs in the output
3203	<	for ac_arg in $ac_f90_v_output; do
3204	<	case $ac_arg in
3205	<	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3568	<	ac_cv_prog_f90_v=$ac_verb
3569	<	break 2 ;;
3570	<	esac
3571	<	done
3572	<	done
3573	<	if test -z "$ac_cv_prog_f90_v"; then
3574	<	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3575	<	echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3576	<	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: failed program was:" >&5
3208	<	sed 's/^/| /' conftest.$ac_ext >&5
3580	<
3581	<	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3582	<	echo "$as_me: WARNING: compilation failed" >&2;}
3207	>	echo "$as_me:$LINENO: result: no" >&5
3208	>	echo "${ECHO_T}no" >&6
3209		fi
3584	–	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3210
3211		fi
3212	<	echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3213	<	echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3214	<	echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3215	<	echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3216	<	if test "${ac_cv_flibs+set}" = set; then
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 "x$F90LIBS" != "x"; then
3222	<	ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3221	>	if test -n "$ac_ct_RANLIB"; then
3222	>	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223		else
3224	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225	+	for as_dir in $PATH
3226	+	do
3227	+	IFS=$as_save_IFS
3228	+	test -z "$as_dir" && as_dir=.
3229	+	for ac_exec_ext in '' $ac_executable_extensions; do
3230	+	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231	+	ac_cv_prog_ac_ct_RANLIB="ranlib"
3232	+	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233	+	break 2
3234	+	fi
3235	+	done
3236	+	done
3237
3238	<	ac_ext=f90
3239	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3240	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3241	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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	<	cat >conftest.$ac_ext <<_ACEOF
3250	>	RANLIB=$ac_ct_RANLIB
3251	>	else
3252	>	RANLIB="$ac_cv_prog_RANLIB"
3253	>	fi
3254
3605	–	program main
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	+	done
3280	+	done
3281
3282	<	end program main
3283	<
3284	<	_ACEOF
3611	<
3612	<	# Compile and link our simple test program by passing a flag (argument
3613	<	# 1 to this macro) to the Fortran 90 compiler in order to get
3614	<	# "verbose" output that we can then parse for the Fortran 90 linker
3615	<	# flags.
3616	<	ac_save_F90FLAGS=$F90FLAGS
3617	<	F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3618	<
3619	<	(eval echo $as_me:3619: \"$ac_link\") >&5
3620	<	ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3621	<	echo "$ac_f90_v_output" >&5
3622	<	F90FLAGS=$ac_save_F90FLAGS
3623	<
3624	<	rm -f conftest.*
3625	<	ac_ext=f90
3626	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3627	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3628	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3629	<
3630	<	# If we are using xlf then replace all the commas with spaces.
3631	<	if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3632	<	ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3282	>	test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283	>	;;
3284	>	esac
3285		fi
3286	+	PERLINTERP=$ac_cv_path_PERLINTERP
3287
3288	<	# If we are using Cray Fortran then delete quotes.
3289	<	# Use "\"" instead of '"' for font-lock-mode.
3290	<	# FIXME: a more general fix for quoted arguments with spaces?
3291	<	if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3292	<	ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3288	>	if test -n "$PERLINTERP"; then
3289	>	echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290	>	echo "${ECHO_T}$PERLINTERP" >&6
3291	>	else
3292	>	echo "$as_me:$LINENO: result: no" >&5
3293	>	echo "${ECHO_T}no" >&6
3294		fi
3295
3296	<	ac_cv_f90libs=
3296	>	ac_cv_path_perlinterp="$PERLINTERP"
3297	>	_sHpB='#!'
3298
3644	–	# Save positional arguments (if any)
3645	–	ac_save_positional="$@"
3299
3300	<	set X $ac_f90_v_output
3301	<	while test $# != 1; do
3302	<	shift
3303	<	ac_arg=$1
3304	<	case $ac_arg in
3305	<	[\\/]*.a | ?:[\\/]*.a)
3306	<	ac_exists=false
3307	<	for ac_i in $ac_cv_f90libs; do
3308	<	if test x"$ac_arg" = x"$ac_i"; then
3309	<	ac_exists=true
3310	<	break
3311	<	fi
3312	<	done
3313	<
3314	<	if test x"$ac_exists" = xtrue; then
3315	<	:
3316	<	else
3317	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3318	<	fi
3319	<
3320	<	;;
3321	<	-bI:*)
3322	<	ac_exists=false
3323	<	for ac_i in $ac_cv_f90libs; do
3324	<	if test x"$ac_arg" = x"$ac_i"; then
3325	<	ac_exists=true
3326	<	break
3327	<	fi
3328	<	done
3329	<
3330	<	if test x"$ac_exists" = xtrue; then
3331	<	:
3332	<	else
3333	<	if test "$ac_compiler_gnu" = yes; then
3334	<	for ac_link_opt in $ac_arg; do
3335	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
3336	<	done
3337	<	else
3338	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3339	<	fi
3340	<	fi
3341	<
3342	<	;;
3343	<	# Ignore these flags.
3344	<	-lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
3345	<	;;
3346	<	-lkernel32)
3347	<	test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3348	<	;;
3349	<	-[LRuY])
3350	<	# These flags, when seen by themselves, take an argument.
3351	<	# We remove the space between option and argument and re-iterate
3352	<	# unless we find an empty arg or a new option (starting with -)
3353	<	case $2 in
3354	<	"" | -*);;
3355	<	*)
3356	<	ac_arg="$ac_arg$2"
3357	<
3358	<	shift; shift
3359	<	set X $ac_arg "$@"
3360	<	;;
3361	<	esac
3362	<	;;
3363	<	-YP,*)
3364	<	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
3365	<	ac_exists=false
3366	<	for ac_i in $ac_cv_f90libs; do
3367	<	if test x"$ac_j" = x"$ac_i"; then
3368	<	ac_exists=true
3369	<	break
3370	<	fi
3371	<	done
3372	<
3373	<	if test x"$ac_exists" = xtrue; then
3374	<	:
3375	<	else
3376	<	ac_arg="$ac_arg $ac_j"
3377	<	ac_cv_f90libs="$ac_cv_f90libs $ac_j"
3378	<	fi
3379	<
3380	<	done
3381	<	;;
3382	<	-[lLR]*)
3383	<	ac_exists=false
3384	<	for ac_i in $ac_cv_f90libs; do
3385	<	if test x"$ac_arg" = x"$ac_i"; then
3386	<	ac_exists=true
3387	<	break
3388	<	fi
3389	<	done
3390	<
3391	<	if test x"$ac_exists" = xtrue; then
3392	<	:
3393	<	else
3394	<	ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3395	<	fi
3396	<
3397	<	;;
3398	<	# Ignore everything else.
3399	<	esac
3400	<	done
3401	<	# restore positional arguments
3402	<	set X $ac_save_positional; shift
3403	<
3404	<	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
3405	<	# then we insist that the "run path" must be an absolute path (i.e. it
3406	<	# must begin with a "/").
3407	<	case `(uname -sr) 2>/dev/null` in
3408	<	"SunOS 5"*)
3409	<	ac_ld_run_path=`echo $ac_f90_v_output |
3410	<	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
3411	<	test "x$ac_ld_run_path" != x &&
3412	<
3413	<	if test "$ac_compiler_gnu" = yes; then
3414	<	for ac_link_opt in $ac_ld_run_path; do
3415	<	ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
3416	<	done
3417	<	else
3418	<	ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
3419	<	fi
3420	<	;;
3421	<	esac
3422	<	fi # test "x$F90LIBS" = "x"
3423	<
3424	<	fi
3425	<	echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
3426	<	echo "${ECHO_T}$ac_cv_flibs" >&6
3427	<	F90LIBS="$ac_cv_f90libs"
3428	<
3429	<	ac_ext=f90
3430	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3431	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3432	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3433	<
3434	<
3435	<	echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
3436	<	echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
3437	<	if test "${ac_cv_f90_mangling+set}" = set; then
3438	<	echo $ECHO_N "(cached) $ECHO_C" >&6
3439	<	else
3440	<	ac_ext=f90
3441	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3442	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3443	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3444	<	cat >conftest.$ac_ext <<_ACEOF
3445	<	subroutine foobar()
3446	<	return
3447	<	end
3448	<	subroutine foo_bar()
3449	<	return
3450	<	end
3451	<	_ACEOF
3452	<	rm -f conftest.$ac_objext
3453	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3454	<	(eval $ac_compile) 2>conftest.er1
3455	<	ac_status=$?
3456	<	grep -v '^ *+' conftest.er1 >conftest.err
3457	<	rm -f conftest.er1
3458	<	cat conftest.err >&5
3459	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3460	<	(exit $ac_status); } &&
3461	<	{ ac_try='test -z "$ac_f90_werror_flag"
3462	<	|| test ! -s conftest.err'
3463	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3464	<	(eval $ac_try) 2>&5
3465	<	ac_status=$?
3466	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3467	<	(exit $ac_status); }; } &&
3468	<	{ ac_try='test -s conftest.$ac_objext'
3469	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3470	<	(eval $ac_try) 2>&5
3471	<	ac_status=$?
3472	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3473	<	(exit $ac_status); }; }; then
3474	<	mv conftest.$ac_objext cf90_test.$ac_objext
3475	<
3476	<	ac_ext=c
3477	<	ac_cpp='$CPP $CPPFLAGS'
3478	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3479	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3480	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3481	<
3482	<	ac_save_LIBS=$LIBS
3483	<	LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3484	<
3485	<	ac_success=no
3486	<	for ac_foobar in foobar FOOBAR; do
3487	<	for ac_underscore in "" "_"; do
3488	<	ac_func="$ac_foobar$ac_underscore"
3489	<	cat >conftest.$ac_ext <<_ACEOF
3490	<	/* confdefs.h.  */
3491	<	_ACEOF
3492	<	cat confdefs.h >>conftest.$ac_ext
3493	<	cat >>conftest.$ac_ext <<_ACEOF
3494	<	/* end confdefs.h.  */
3495	<
3496	<	/* Override any gcc2 internal prototype to avoid an error.  */
3497	<	#ifdef __cplusplus
3498	<	extern "C"
3300	>	# Check whether --with-perl-shebang or --without-perl-shebang was given.
3301	>	if test "${with_perl_shebang+set}" = set; then
3302	>	withval="$with_perl_shebang"
3303	>	opt_perl_shebang="$withval"
3304	>	else
3305	>	opt_perl_shebang="not_set"
3306	>	fi;
3307	>	echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308	>	echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309	>	if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3311	>	else
3312	>	case "$opt_perl_shebang" in
3313	>	not_set  ) ax_cv_opt_perl_shebang=''
3314	>	;;
3315	>	*     )
3316	>	ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317	>	esac
3318	>
3319	>	fi
3320	>	echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321	>	echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322	>	if test "A$ax_cv_opt_perl_shebang" != "A"
3323	>	then
3324	>	ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326	>	{ echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327	>	echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328	>
3329	>	# Automatic detection of sharpbang formula starts here
3330	>	else
3331	>	_somian_shbangperl=`$PERLINTERP -V:startperl`
3332	>	negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333	>	echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334	>	echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335	>	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3337	>	else
3338	>	_somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339	>	if test "x$_somian_kspb_perl" == x
3340	>	then _somian_ksbp_warn_empty='durnit'
3341	>	else
3342	>	case "A$_somian_kspb_perl" in
3343	>	A#!*perl* )
3344	>	ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345	>	;;
3346	>	A*    )  _somian_ksbp_warn_defau='trouble'
3347	>	ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348	>	esac
3349	>	fi
3350	>
3351	>	fi
3352	>	echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353	>	echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354	>	# The above prints Checking ... result message to user.
3355	>	PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356	>
3357	>	if test A${_somian_ksbp_warn_empty+set} == Aset
3358	>	then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359	>	echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360	>	fi
3361	>	# Inform user after printing result value
3362	>	if test A${_somian_ksbp_warn_defau+set} == Aset
3363	>	then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364	>	echo "$as_me: Maybe Not good -" >&6;}
3365	>	{ echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366	>	echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367	>	else { echo "$as_me:$LINENO: OK Good result - " >&5
3368	>	echo "$as_me: OK Good result - " >&6;}
3369	>	{ echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370	>	echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371	>	fi
3372	>	fi
3373	>
3374	>	# Find a good install program.  We prefer a C program (faster),
3375	>	# so one script is as good as another.  But avoid the broken or
3376	>	# incompatible versions:
3377	>	# SysV /etc/install, /usr/sbin/install
3378	>	# SunOS /usr/etc/install
3379	>	# IRIX /sbin/install
3380	>	# AIX /bin/install
3381	>	# AmigaOS /C/install, which installs bootblocks on floppy discs
3382	>	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383	>	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384	>	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385	>	# OS/2's system install, which has a completely different semantic
3386	>	# ./install, which can be erroneously created by make from ./install.sh.
3387	>	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388	>	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389	>	if test -z "$INSTALL"; then
3390	>	if test "${ac_cv_path_install+set}" = set; then
3391	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3392	>	else
3393	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394	>	for as_dir in $PATH
3395	>	do
3396	>	IFS=$as_save_IFS
3397	>	test -z "$as_dir" && as_dir=.
3398	>	# Account for people who put trailing slashes in PATH elements.
3399	>	case $as_dir/ in
3400	>	./ | .// | /cC/* | \
3401	>	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402	>	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403	>	/usr/ucb/* ) ;;
3404	>	*)
3405	>	# OSF1 and SCO ODT 3.0 have their own names for install.
3406	>	# Don't use installbsd from OSF since it installs stuff as root
3407	>	# by default.
3408	>	for ac_prog in ginstall scoinst install; do
3409	>	for ac_exec_ext in '' $ac_executable_extensions; do
3410	>	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411	>	if test $ac_prog = install &&
3412	>	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413	>	# AIX install.  It has an incompatible calling convention.
3414	>	:
3415	>	elif test $ac_prog = install &&
3416	>	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417	>	# program-specific install script used by HP pwplus--don't use.
3418	>	:
3419	>	else
3420	>	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421	>	break 3
3422	>	fi
3423	>	fi
3424	>	done
3425	>	done
3426	>	;;
3427	>	esac
3428	>	done
3429	>
3430	>
3431	>	fi
3432	>	if test "${ac_cv_path_install+set}" = set; then
3433	>	INSTALL=$ac_cv_path_install
3434	>	else
3435	>	# As a last resort, use the slow shell script.  We don't cache a
3436	>	# path for INSTALL within a source directory, because that will
3437	>	# break other packages using the cache if that directory is
3438	>	# removed, or if the path is relative.
3439	>	INSTALL=$ac_install_sh
3440	>	fi
3441	>	fi
3442	>	echo "$as_me:$LINENO: result: $INSTALL" >&5
3443	>	echo "${ECHO_T}$INSTALL" >&6
3444	>
3445	>	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446	>	# It thinks the first close brace ends the variable substitution.
3447	>	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448	>
3449	>	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450	>
3451	>	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452	>
3453	>	case "x$INSTALL" in
3454	>	x/*) ;;
3455	>	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456	>	esac
3457	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458	>	# Extract the first word of "ar", so it can be a program name with args.
3459	>	set dummy ar; ac_word=$2
3460	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3461	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462	>	if test "${ac_cv_prog_AR+set}" = set; then
3463	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3464	>	else
3465	>	if test -n "$AR"; then
3466	>	ac_cv_prog_AR="$AR" # Let the user override the test.
3467	>	else
3468	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469	>	for as_dir in $PATH
3470	>	do
3471	>	IFS=$as_save_IFS
3472	>	test -z "$as_dir" && as_dir=.
3473	>	for ac_exec_ext in '' $ac_executable_extensions; do
3474	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475	>	ac_cv_prog_AR="ar"
3476	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477	>	break 2
3478	>	fi
3479	>	done
3480	>	done
3481	>
3482	>	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483	>	fi
3484	>	fi
3485	>	AR=$ac_cv_prog_AR
3486	>	if test -n "$AR"; then
3487	>	echo "$as_me:$LINENO: result: $AR" >&5
3488	>	echo "${ECHO_T}$AR" >&6
3489	>	else
3490	>	echo "$as_me:$LINENO: result: no" >&5
3491	>	echo "${ECHO_T}no" >&6
3492	>	fi
3493	>
3494	>	if test "$AR" = "NONE"; then
3495	>	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496	>	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497	>	{ (exit 1); exit 1; }; }
3498	>	cat >confcache <<\_ACEOF
3499	>	# This file is a shell script that caches the results of configure
3500	>	# tests run on this system so they can be shared between configure
3501	>	# scripts and configure runs, see configure's option --config-cache.
3502	>	# It is not useful on other systems.  If it contains results you don't
3503	>	# want to keep, you may remove or edit it.
3504	>	#
3505	>	# config.status only pays attention to the cache file if you give it
3506	>	# the --recheck option to rerun configure.
3507	>	#
3508	>	# `ac_cv_env_foo' variables (set or unset) will be overridden when
3509	>	# loading this file, other *unset* `ac_cv_foo' will be assigned the
3510	>	# following values.
3511	>
3512	>	_ACEOF
3513	>
3514	>	# The following way of writing the cache mishandles newlines in values,
3515	>	# but we know of no workaround that is simple, portable, and efficient.
3516	>	# So, don't put newlines in cache variables' values.
3517	>	# Ultrix sh set writes to stderr and can't be redirected directly,
3518	>	# and sets the high bit in the cache file unless we assign to the vars.
3519	>	{
3520	>	(set) 2>&1 |
3521	>	case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522	>	*ac_space=\ *)
3523	>	# `set' does not quote correctly, so add quotes (double-quote
3524	>	# substitution turns \\\\ into \\, and sed turns \\ into \).
3525	>	sed -n \
3526	>	"s/'/'\\\\''/g;
3527	>	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528	>	;;
3529	>	*)
3530	>	# `set' quotes correctly as required by POSIX, so do not add quotes.
3531	>	sed -n \
3532	>	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533	>	;;
3534	>	esac;
3535	>	} |
3536	>	sed '
3537	>	t clear
3538	>	: clear
3539	>	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540	>	t end
3541	>	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542	>	: end' >>confcache
3543	>	if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544	>	if test -w $cache_file; then
3545	>	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546	>	cat confcache >$cache_file
3547	>	else
3548	>	echo "not updating unwritable cache $cache_file"
3549	>	fi
3550	>	fi
3551	>	rm -f confcache
3552	>	exit 1
3553	>	fi
3554	>	# Extract the first word of "ps", so it can be a program name with args.
3555	>	set dummy ps; ac_word=$2
3556	>	echo "$as_me:$LINENO: checking for $ac_word" >&5
3557	>	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558	>	if test "${ac_cv_path_PS+set}" = set; then
3559	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3560	>	else
3561	>	case $PS in
3562	>	[\\/]* | ?:[\\/]*)
3563	>	ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564	>	;;
3565	>	*)
3566	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567	>	for as_dir in $PATH
3568	>	do
3569	>	IFS=$as_save_IFS
3570	>	test -z "$as_dir" && as_dir=.
3571	>	for ac_exec_ext in '' $ac_executable_extensions; do
3572	>	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573	>	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574	>	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575	>	break 2
3576	>	fi
3577	>	done
3578	>	done
3579	>
3580	>	;;
3581	>	esac
3582	>	fi
3583	>	PS=$ac_cv_path_PS
3584	>
3585	>	if test -n "$PS"; then
3586	>	echo "$as_me:$LINENO: result: $PS" >&5
3587	>	echo "${ECHO_T}$PS" >&6
3588	>	else
3589	>	echo "$as_me:$LINENO: result: no" >&5
3590	>	echo "${ECHO_T}no" >&6
3591	>	fi
3592	>
3593	>	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594	>	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595	>	if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3597	>	else
3598	>
3599	>	if $PS ax -o rss > /dev/null 2>&1; then
3600	>	ac_cv_prog_ps_ax=yes
3601	>	else
3602	>	ac_cv_prog_ps_ax=no
3603	>	fi
3604	>	if $PS -ef -o rss > /dev/null 2>&1; then
3605	>	ac_cv_prog_ps_ef=yes
3606	>	else
3607	>	ac_cv_prog_ps_ef=no
3608	>	fi
3609	>	if test "$ac_cv_prog_ps_ax" = yes; then
3610	>	ac_cv_prog_ps_syntax=BSD
3611	>	else
3612	>	if test "$ac_cv_prog_ps_ef" = yes; then
3613	>	ac_cv_prog_ps_syntax=POSIX
3614	>	else
3615	>	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616	>	echo "$as_me: error: Could not determine ps syntax" >&2;}
3617	>	{ (exit 1); exit 1; }; }
3618	>	fi
3619	>	fi
3620	>
3621	>	fi
3622	>	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623	>	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624	>
3625	>	cat >>confdefs.h <<_ACEOF
3626	>	#define PSCOMMAND $PS
3627	>	_ACEOF
3628	>
3629	>	if test "$ac_cv_prog_ps_syntax" = BSD; then
3630	>
3631	>	cat >>confdefs.h <<\_ACEOF
3632	>	#define PSTYPE_IS_BSD 1
3633	>	_ACEOF
3634	>
3635	>	else
3636	>	if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637	>
3638	>	cat >>confdefs.h <<\_ACEOF
3639	>	#define PSTYPE_IS_POSIX 1
3640	>	_ACEOF
3641	>
3642	>	else
3643	>	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644	>	echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645	>	{ (exit 1); exit 1; }; }
3646	>	fi
3647	>	fi
3648	>
3649	>	ac_ext=${FC_SRCEXT-f}
3650	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653	>
3654	>
3655	>	echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656	>	echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657	>	if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3659	>	else
3660	>	ac_ext=F90
3661	>	ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662	>	FCFLAGS_SRCEXT=""
3663	>	ac_cv_fc_srcext_F90=unknown
3664	>	for ac_flag in none -qsuffix=f=F90 -Tf; do
3665	>	test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666	>	cat >conftest.$ac_ext <<_ACEOF
3667	>	program main
3668	>
3669	>	end
3670	>	_ACEOF
3671	>	rm -f conftest.$ac_objext
3672	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3673	>	(eval $ac_compile) 2>conftest.er1
3674	>	ac_status=$?
3675	>	grep -v '^ *+' conftest.er1 >conftest.err
3676	>	rm -f conftest.er1
3677	>	cat conftest.err >&5
3678	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679	>	(exit $ac_status); } &&
3680	>	{ ac_try='test -z "$ac_fc_werror_flag"
3681	>	|| test ! -s conftest.err'
3682	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683	>	(eval $ac_try) 2>&5
3684	>	ac_status=$?
3685	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3686	>	(exit $ac_status); }; } &&
3687	>	{ ac_try='test -s conftest.$ac_objext'
3688	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3689	>	(eval $ac_try) 2>&5
3690	>	ac_status=$?
3691	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692	>	(exit $ac_status); }; }; then
3693	>	ac_cv_fc_srcext_F90=$ac_flag; break
3694	>	else
3695	>	echo "$as_me: failed program was:" >&5
3696	>	sed 's/^/| /' conftest.$ac_ext >&5
3697	>
3698	>	fi
3699	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700	>	done
3701	>	rm -f conftest.$ac_objext conftest.F90
3702	>	FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703	>
3704	>	fi
3705	>	echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706	>	echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707	>	if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708	>	{ { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709	>	echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710	>	{ (exit 1); exit 1; }; }
3711	>	else
3712	>	FC_SRCEXT=F90
3713	>	if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714	>	FCFLAGS_SRCEXT=""
3715	>	FCFLAGS_F90=""
3716	>	else
3717	>	FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718	>	FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719	>	fi
3720	>
3721	>
3722	>	fi
3723	>
3724	>
3725	>
3726	>
3727	>
3728	>	# Try to determine native compiler flags that allow us to use F90 suffix
3729	>	# for preprocessed f90 source.
3730	>
3731	>	if test "$ac_test_PREPFLAG" != "set"; then
3732	>	PREPFLAG=""
3733	>	case "${host_cpu}-${host_os}" in
3734	>
3735	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736	>	PREPFLAG="-fpp1 "
3737	>	fi;;
3738	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739	>	PREPFLAG="-qsuffix=cpp=F90 "
3740	>	fi;;
3741	>	*darwin*)
3742	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743	>	PREPFLAG="-qsuffix=cpp=F90 "
3744	>	fi;;
3745	>	esac
3746	>
3747	>	if test -z "$PREPFLAG"; then
3748	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3749	>	echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3750	>	PREPFLAG=""
3751	>	fi
3752	>
3753	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3754	>	echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755	>
3756	>
3757	>	ac_ext=${FC_SRCEXT-f}
3758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761	>
3762	>	ac_save_ext=$ac_ext
3763	>	ac_ext=F90
3764	>	ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765	>
3766	>	if test "$PREPFLAG"; then
3767	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3768	>	fi
3769	>
3770	>	cat >conftest.$ac_ext <<_ACEOF
3771	>
3772	>
3773	>	program conftest
3774	>	integer :: i
3775	>	i = 1
3776	>	end program conftest
3777	>
3778	>	_ACEOF
3779	>	rm -f conftest.$ac_objext
3780	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3781	>	(eval $ac_compile) 2>conftest.er1
3782	>	ac_status=$?
3783	>	grep -v '^ *+' conftest.er1 >conftest.err
3784	>	rm -f conftest.er1
3785	>	cat conftest.err >&5
3786	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787	>	(exit $ac_status); } &&
3788	>	{ ac_try='test -z "$ac_fc_werror_flag"
3789	>	|| test ! -s conftest.err'
3790	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791	>	(eval $ac_try) 2>&5
3792	>	ac_status=$?
3793	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794	>	(exit $ac_status); }; } &&
3795	>	{ ac_try='test -s conftest.$ac_objext'
3796	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797	>	(eval $ac_try) 2>&5
3798	>	ac_status=$?
3799	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800	>	(exit $ac_status); }; }; then
3801	>	prepflagworks=1
3802	>	else
3803	>	echo "$as_me: failed program was:" >&5
3804	>	sed 's/^/| /' conftest.$ac_ext >&5
3805	>
3806	>	prepflagworks=0
3807	>	fi
3808	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809	>
3810	>	FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811	>	ac_ext=$ac_save_ext
3812	>	ac_ext=${FC_SRCEXT-f}
3813	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816	>
3817	>
3818	>	if test "$prepflagworks" = 1; then
3819	>	echo "$as_me:$LINENO: result: yes" >&5
3820	>	echo "${ECHO_T}yes" >&6
3821	>	FCFLAGS_SRCEXT="${PREPFLAG}"
3822	>
3823	>	else
3824	>	echo "$as_me:$LINENO: result: no" >&5
3825	>	echo "${ECHO_T}no" >&6
3826	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3827	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3828	>	{ (exit 1); exit 1; }; }
3829	>	fi
3830	>	fi
3831	>
3832	>
3833	>
3834	>
3835	>
3836	>	# Try to determine native compiler flags that allow us to use F90 suffix
3837	>	# for preprocessed f90 source with -D type defines
3838	>
3839	>	if test "$ac_test_PREPDEFFLAG" != "set"; then
3840	>	PREPDEFFLAG=""
3841	>	case "${host_cpu}-${host_os}" in
3842	>
3843	>	*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844	>	PREPDEFFLAG=" "
3845	>	fi;;
3846	>	*aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847	>	PREPDEFFLAG="-WF,"
3848	>	fi;;
3849	>	*darwin*)
3850	>	if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851	>	PREPDEFFLAG="-WF,"
3852	>	fi;;
3853	>	esac
3854	>
3855	>	if test -z "$PREPDEFFLAG"; then
3856	>	{ echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3857	>	echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3858	>	PREPDEFFLAG=" "
3859	>	fi
3860	>
3861	>	echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3862	>	echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863	>
3864	>
3865	>	ac_ext=${FC_SRCEXT-f}
3866	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869	>
3870	>	ac_save_ext=$ac_ext
3871	>	ac_ext=F90
3872	>	ac_save_FCFLAGS=$FCFLAGS
3873	>
3874	>	if test "$PREPDEFFLAG"; then
3875	>	FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876	>	fi
3877	>
3878	>	cat >conftest.$ac_ext <<_ACEOF
3879	>
3880	>
3881	>	program conftest
3882	>	integer :: i
3883	>	#ifdef TEST
3884	>	i = 1
3885	>	#else
3886	>	choke me
3887	>	#endif
3888	>	end program conftest
3889	>
3890	>	_ACEOF
3891	>	rm -f conftest.$ac_objext
3892	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3893	>	(eval $ac_compile) 2>conftest.er1
3894	>	ac_status=$?
3895	>	grep -v '^ *+' conftest.er1 >conftest.err
3896	>	rm -f conftest.er1
3897	>	cat conftest.err >&5
3898	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899	>	(exit $ac_status); } &&
3900	>	{ ac_try='test -z "$ac_fc_werror_flag"
3901	>	|| test ! -s conftest.err'
3902	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903	>	(eval $ac_try) 2>&5
3904	>	ac_status=$?
3905	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906	>	(exit $ac_status); }; } &&
3907	>	{ ac_try='test -s conftest.$ac_objext'
3908	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3909	>	(eval $ac_try) 2>&5
3910	>	ac_status=$?
3911	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912	>	(exit $ac_status); }; }; then
3913	>	prepdefflagworks=1
3914	>	else
3915	>	echo "$as_me: failed program was:" >&5
3916	>	sed 's/^/| /' conftest.$ac_ext >&5
3917	>
3918	>	prepdefflagworks=0
3919	>	fi
3920	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921	>
3922	>	FCFLAGS=$ac_save_FCFLAGS
3923	>	ac_ext=$ac_save_ext
3924	>	ac_ext=${FC_SRCEXT-f}
3925	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928	>
3929	>
3930	>	if test "$prepdefflagworks" = 1; then
3931	>	echo "$as_me:$LINENO: result: yes" >&5
3932	>	echo "${ECHO_T}yes" >&6
3933	>
3934	>	else
3935	>	echo "$as_me:$LINENO: result: no" >&5
3936	>	echo "${ECHO_T}no" >&6
3937	>	{ { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3938	>	echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3939	>	{ (exit 1); exit 1; }; }
3940	>	fi
3941	>	fi
3942	>
3943	>	ac_ext=${FC_SRCEXT-f}
3944	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949	>	if test "${ac_cv_prog_fc_v+set}" = set; then
3950	>	echo $ECHO_N "(cached) $ECHO_C" >&6
3951	>	else
3952	>	cat >conftest.$ac_ext <<_ACEOF
3953	>	program main
3954	>
3955	>	end
3956	>	_ACEOF
3957	>	rm -f conftest.$ac_objext
3958	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959	>	(eval $ac_compile) 2>conftest.er1
3960	>	ac_status=$?
3961	>	grep -v '^ *+' conftest.er1 >conftest.err
3962	>	rm -f conftest.er1
3963	>	cat conftest.err >&5
3964	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965	>	(exit $ac_status); } &&
3966	>	{ ac_try='test -z "$ac_fc_werror_flag"
3967	>	|| test ! -s conftest.err'
3968	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969	>	(eval $ac_try) 2>&5
3970	>	ac_status=$?
3971	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972	>	(exit $ac_status); }; } &&
3973	>	{ ac_try='test -s conftest.$ac_objext'
3974	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975	>	(eval $ac_try) 2>&5
3976	>	ac_status=$?
3977	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978	>	(exit $ac_status); }; }; then
3979	>	ac_cv_prog_fc_v=
3980	>	# Try some options frequently used verbose output
3981	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982	>	cat >conftest.$ac_ext <<_ACEOF
3983	>	program main
3984	>
3985	>	end
3986	>	_ACEOF
3987	>
3988	>	# Compile and link our simple test program by passing a flag (argument
3989	>	# 1 to this macro) to the Fortran compiler in order to get
3990	>	# "verbose" output that we can then parse for the Fortran linker
3991	>	# flags.
3992	>	ac_save_FFLAGS=$FCFLAGS
3993	>	FCFLAGS="$FCFLAGS $ac_verb"
3994	>	(eval echo $as_me:3994: \"$ac_link\") >&5
3995	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996	>	echo "$ac_fc_v_output" >&5
3997	>	FCFLAGS=$ac_save_FFLAGS
3998	>
3999	>	rm -f conftest*
4000	>
4001	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4003	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004	>	ac_fc_v_output="`echo $ac_fc_v_output |
4005	>	grep 'LPATH is:' |
4006	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007	>
4008	>	case $ac_fc_v_output in
4009	>	# If we are using xlf then replace all the commas with spaces.
4010	>	*xlfentry*)
4011	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012	>
4013	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4015	>	*mGLOB_options_string*)
4016	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017	>
4018	>	# If we are using Cray Fortran then delete quotes.
4019	>	# Use "\"" instead of '"' for font-lock-mode.
4020	>	# FIXME: a more general fix for quoted arguments with spaces?
4021	>	*cft90*)
4022	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023	>	esac
4024	>
4025	>
4026	>	# look for -l* and *.a constructs in the output
4027	>	for ac_arg in $ac_fc_v_output; do
4028	>	case $ac_arg in
4029	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030	>	ac_cv_prog_fc_v=$ac_verb
4031	>	break 2 ;;
4032	>	esac
4033	>	done
4034	>	done
4035	>	if test -z "$ac_cv_prog_fc_v"; then
4036	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038	>	fi
4039	>	else
4040	>	echo "$as_me: failed program was:" >&5
4041	>	sed 's/^/| /' conftest.$ac_ext >&5
4042	>
4043	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4044	>	echo "$as_me: WARNING: compilation failed" >&2;}
4045	>	fi
4046	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047	>
4048	>	fi
4049	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053	>	if test "${ac_cv_fc_libs+set}" = set; then
4054	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4055	>	else
4056	>	if test "x$FCLIBS" != "x"; then
4057	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058	>	else
4059	>
4060	>	cat >conftest.$ac_ext <<_ACEOF
4061	>	program main
4062	>
4063	>	end
4064	>	_ACEOF
4065	>
4066	>	# Compile and link our simple test program by passing a flag (argument
4067	>	# 1 to this macro) to the Fortran compiler in order to get
4068	>	# "verbose" output that we can then parse for the Fortran linker
4069	>	# flags.
4070	>	ac_save_FFLAGS=$FCFLAGS
4071	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072	>	(eval echo $as_me:4072: \"$ac_link\") >&5
4073	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074	>	echo "$ac_fc_v_output" >&5
4075	>	FCFLAGS=$ac_save_FFLAGS
4076	>
4077	>	rm -f conftest*
4078	>
4079	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4081	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082	>	ac_fc_v_output="`echo $ac_fc_v_output |
4083	>	grep 'LPATH is:' |
4084	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085	>
4086	>	case $ac_fc_v_output in
4087	>	# If we are using xlf then replace all the commas with spaces.
4088	>	*xlfentry*)
4089	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090	>
4091	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4093	>	*mGLOB_options_string*)
4094	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095	>
4096	>	# If we are using Cray Fortran then delete quotes.
4097	>	# Use "\"" instead of '"' for font-lock-mode.
4098	>	# FIXME: a more general fix for quoted arguments with spaces?
4099	>	*cft90*)
4100	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101	>	esac
4102	>
4103	>
4104	>
4105	>	ac_cv_fc_libs=
4106	>
4107	>	# Save positional arguments (if any)
4108	>	ac_save_positional="$@"
4109	>
4110	>	set X $ac_fc_v_output
4111	>	while test $# != 1; do
4112	>	shift
4113	>	ac_arg=$1
4114	>	case $ac_arg in
4115	>	[\\/]*.a | ?:[\\/]*.a)
4116	>	ac_exists=false
4117	>	for ac_i in $ac_cv_fc_libs; do
4118	>	if test x"$ac_arg" = x"$ac_i"; then
4119	>	ac_exists=true
4120	>	break
4121	>	fi
4122	>	done
4123	>
4124	>	if test x"$ac_exists" = xtrue; then
4125	>	:
4126	>	else
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_fc_libs; do
4134	>	if test x"$ac_arg" = x"$ac_i"; then
4135	>	ac_exists=true
4136	>	break
4137	>	fi
4138	>	done
4139	>
4140	>	if test x"$ac_exists" = xtrue; then
4141	>	:
4142	>	else
4143	>	if test "$ac_compiler_gnu" = yes; then
4144	>	for ac_link_opt in $ac_arg; do
4145	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146	>	done
4147	>	else
4148	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149	>	fi
4150	>	fi
4151	>
4152	>	;;
4153	>	# Ignore these flags.
4154	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155	>	;;
4156	>	-lkernel32)
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	>	*)
4166	>	ac_arg="$ac_arg$2"
4167	>	shift; shift
4168	>	set X $ac_arg "$@"
4169	>	;;
4170	>	esac
4171	>	;;
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_fc_libs; do
4176	>	if test x"$ac_j" = x"$ac_i"; then
4177	>	ac_exists=true
4178	>	break
4179	>	fi
4180	>	done
4181	>
4182	>	if test x"$ac_exists" = xtrue; then
4183	>	:
4184	>	else
4185	>	ac_arg="$ac_arg $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_fc_libs; do
4194	>	if test x"$ac_arg" = x"$ac_i"; then
4195	>	ac_exists=true
4196	>	break
4197	>	fi
4198	>	done
4199	>
4200	>	if test x"$ac_exists" = xtrue; then
4201	>	:
4202	>	else
4203	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204	>	fi
4205	>
4206	>	;;
4207	>	# Ignore everything else.
4208	>	esac
4209	>	done
4210	>	# restore positional arguments
4211	>	set X $ac_save_positional; shift
4212	>
4213	>	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4214	>	# then we insist that the "run path" must be an absolute path (i.e. it
4215	>	# must begin with a "/").
4216	>	case `(uname -sr) 2>/dev/null` in
4217	>	"SunOS 5"*)
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 &&
4221	>	if test "$ac_compiler_gnu" = yes; then
4222	>	for ac_link_opt in $ac_ld_run_path; do
4223	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224	>	done
4225	>	else
4226	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227	>	fi
4228	>	;;
4229	>	esac
4230	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231	>
4232	>	fi
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	>
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	>
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_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
4437	>	ac_status=$?
4438	>	grep -v '^ *+' conftest.er1 >conftest.err
4439	>	rm -f conftest.er1
4440	>	cat conftest.err >&5
4441	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442	>	(exit $ac_status); } &&
4443	>	{ ac_try='test -z "$ac_fc_werror_flag"
4444	>	|| test ! -s conftest.err'
4445	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446	>	(eval $ac_try) 2>&5
4447	>	ac_status=$?
4448	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4449	>	(exit $ac_status); }; } &&
4450	>	{ ac_try='test -s conftest.$ac_objext'
4451	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4452	>	(eval $ac_try) 2>&5
4453	>	ac_status=$?
4454	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455	>	(exit $ac_status); }; }; then
4456	>	mv conftest.$ac_objext cfortran_test.$ac_objext
4457	>
4458	>	ac_save_LIBS=$LIBS
4459	>	LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460	>
4461	>	ac_ext=c
4462	>	ac_cpp='$CPP $CPPFLAGS'
4463	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4466	>	ac_success=no
4467	>	for ac_foobar in foobar FOOBAR; do
4468	>	for ac_underscore in "" "_"; do
4469	>	ac_func="$ac_foobar$ac_underscore"
4470	>	cat >conftest.$ac_ext <<_ACEOF
4471	>	/* confdefs.h.  */
4472	>	_ACEOF
4473	>	cat confdefs.h >>conftest.$ac_ext
4474	>	cat >>conftest.$ac_ext <<_ACEOF
4475	>	/* end confdefs.h.  */
4476	>
4477	>	/* Override any gcc2 internal prototype to avoid an error.  */
4478	>	#ifdef __cplusplus
4479	>	extern "C"
4480	>	#endif
4481	>	/* We use char because int might match the return type of a gcc2
4482	>	builtin and then its argument prototype would still apply.  */
4483	>	char $ac_func ();
4484	>	#ifdef FC_DUMMY_MAIN
4485	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4486	>	#  ifdef __cplusplus
4487	>	extern "C"
4488	>	#  endif
4489	>	int FC_DUMMY_MAIN() { return 1; }
4490	>	#endif
4491	>	#endif
4492	>	int
4493	>	main ()
4494	>	{
4495	>	$ac_func ();
4496	>	;
4497	>	return 0;
4498	>	}
4499	>	_ACEOF
4500	>	rm -f conftest.$ac_objext conftest$ac_exeext
4501	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4502	>	(eval $ac_link) 2>conftest.er1
4503	>	ac_status=$?
4504	>	grep -v '^ *+' conftest.er1 >conftest.err
4505	>	rm -f conftest.er1
4506	>	cat conftest.err >&5
4507	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508	>	(exit $ac_status); } &&
4509	>	{ ac_try='test -z "$ac_c_werror_flag"
4510	>	|| test ! -s conftest.err'
4511	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512	>	(eval $ac_try) 2>&5
4513	>	ac_status=$?
4514	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515	>	(exit $ac_status); }; } &&
4516	>	{ ac_try='test -s conftest$ac_exeext'
4517	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518	>	(eval $ac_try) 2>&5
4519	>	ac_status=$?
4520	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521	>	(exit $ac_status); }; }; then
4522	>	ac_success=yes; break 2
4523	>	else
4524	>	echo "$as_me: failed program was:" >&5
4525	>	sed 's/^/| /' conftest.$ac_ext >&5
4526	>
4527	>	fi
4528	>	rm -f conftest.err conftest.$ac_objext \
4529	>	conftest$ac_exeext conftest.$ac_ext
4530	>	done
4531	>	done
4532	>	ac_ext=${FC_SRCEXT-f}
4533	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536	>
4537	>	if test "$ac_success" = "yes"; then
4538	>	case $ac_foobar in
4539	>	foobar)
4540	>	ac_case=lower
4541	>	ac_foo_bar=foo_bar
4542	>	;;
4543	>	FOOBAR)
4544	>	ac_case=upper
4545	>	ac_foo_bar=FOO_BAR
4546	>	;;
4547	>	esac
4548	>
4549	>	ac_ext=c
4550	>	ac_cpp='$CPP $CPPFLAGS'
4551	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554	>	ac_success_extra=no
4555	>	for ac_extra in "" "_"; do
4556	>	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557	>	cat >conftest.$ac_ext <<_ACEOF
4558	>	/* confdefs.h.  */
4559	>	_ACEOF
4560	>	cat confdefs.h >>conftest.$ac_ext
4561	>	cat >>conftest.$ac_ext <<_ACEOF
4562	>	/* end confdefs.h.  */
4563	>
4564	>	/* Override any gcc2 internal prototype to avoid an error.  */
4565	>	#ifdef __cplusplus
4566	>	extern "C"
4567	>	#endif
4568	>	/* We use char because int might match the return type of a gcc2
4569	>	builtin and then its argument prototype would still apply.  */
4570	>	char $ac_func ();
4571	>	#ifdef FC_DUMMY_MAIN
4572	>	#ifndef FC_DUMMY_MAIN_EQ_F77
4573	>	#  ifdef __cplusplus
4574	>	extern "C"
4575	>	#  endif
4576	>	int FC_DUMMY_MAIN() { return 1; }
4577	>	#endif
4578	>	#endif
4579	>	int
4580	>	main ()
4581	>	{
4582	>	$ac_func ();
4583	>	;
4584	>	return 0;
4585	>	}
4586	>	_ACEOF
4587	>	rm -f conftest.$ac_objext conftest$ac_exeext
4588	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4589	>	(eval $ac_link) 2>conftest.er1
4590	>	ac_status=$?
4591	>	grep -v '^ *+' conftest.er1 >conftest.err
4592	>	rm -f conftest.er1
4593	>	cat conftest.err >&5
4594	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595	>	(exit $ac_status); } &&
4596	>	{ ac_try='test -z "$ac_c_werror_flag"
4597	>	|| test ! -s conftest.err'
4598	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4599	>	(eval $ac_try) 2>&5
4600	>	ac_status=$?
4601	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602	>	(exit $ac_status); }; } &&
4603	>	{ ac_try='test -s conftest$ac_exeext'
4604	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4605	>	(eval $ac_try) 2>&5
4606	>	ac_status=$?
4607	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4608	>	(exit $ac_status); }; }; then
4609	>	ac_success_extra=yes; break
4610	>	else
4611	>	echo "$as_me: failed program was:" >&5
4612	>	sed 's/^/| /' conftest.$ac_ext >&5
4613	>
4614	>	fi
4615	>	rm -f conftest.err conftest.$ac_objext \
4616	>	conftest$ac_exeext conftest.$ac_ext
4617	>	done
4618	>	ac_ext=${FC_SRCEXT-f}
4619	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622	>
4623	>	if test "$ac_success_extra" = "yes"; then
4624	>	ac_cv_fc_mangling="$ac_case case"
4625	>	if test -z "$ac_underscore"; then
4626	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627	>	else
4628	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629	>	fi
4630	>	if test -z "$ac_extra"; then
4631	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632	>	else
4633	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634	>	fi
4635	>	else
4636	>	ac_cv_fc_mangling="unknown"
4637	>	fi
4638	>	else
4639	>	ac_cv_fc_mangling="unknown"
4640	>	fi
4641	>
4642	>	LIBS=$ac_save_LIBS
4643	>	rm -f cfortran_test* conftest*
4644	>	else
4645	>	echo "$as_me: failed program was:" >&5
4646	>	sed 's/^/| /' conftest.$ac_ext >&5
4647	>
4648	>	{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649	>	See \`config.log' for more details." >&5
4650	>	echo "$as_me: error: cannot compile a simple Fortran program
4651	>	See \`config.log' for more details." >&2;}
4652	>	{ (exit 1); exit 1; }; }
4653	>	fi
4654	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4655	>
4656	>	fi
4657	>	echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658	>	echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659	>
4660	>	ac_ext=${FC_SRCEXT-f}
4661	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664	>
4665	>	ac_ext=${FC_SRCEXT-f}
4666	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669	>
4670	>
4671	>	case $ac_cv_fc_mangling in
4672	>	"lower case, no underscore, no extra underscore")
4673	>	cat >>confdefs.h <<\_ACEOF
4674	>	#define FC_FUNC(name,NAME) name
4675	>	_ACEOF
4676	>
4677	>	cat >>confdefs.h <<\_ACEOF
4678	>	#define FC_FUNC_(name,NAME) name
4679	>	_ACEOF
4680	>	;;
4681	>	"lower case, no underscore, extra underscore")
4682	>	cat >>confdefs.h <<\_ACEOF
4683	>	#define FC_FUNC(name,NAME) name
4684	>	_ACEOF
4685	>
4686	>	cat >>confdefs.h <<\_ACEOF
4687	>	#define FC_FUNC_(name,NAME) name ## _
4688	>	_ACEOF
4689	>	;;
4690	>	"lower case, underscore, no extra underscore")
4691	>	cat >>confdefs.h <<\_ACEOF
4692	>	#define FC_FUNC(name,NAME) name ## _
4693	>	_ACEOF
4694	>
4695	>	cat >>confdefs.h <<\_ACEOF
4696	>	#define FC_FUNC_(name,NAME) name ## _
4697	>	_ACEOF
4698	>	;;
4699	>	"lower case, underscore, extra underscore")
4700	>	cat >>confdefs.h <<\_ACEOF
4701	>	#define FC_FUNC(name,NAME) name ## _
4702	>	_ACEOF
4703	>
4704	>	cat >>confdefs.h <<\_ACEOF
4705	>	#define FC_FUNC_(name,NAME) name ## __
4706	>	_ACEOF
4707	>	;;
4708	>	"upper case, no underscore, no extra underscore")
4709	>	cat >>confdefs.h <<\_ACEOF
4710	>	#define FC_FUNC(name,NAME) NAME
4711	>	_ACEOF
4712	>
4713	>	cat >>confdefs.h <<\_ACEOF
4714	>	#define FC_FUNC_(name,NAME) NAME
4715	>	_ACEOF
4716	>	;;
4717	>	"upper case, no underscore, extra underscore")
4718	>	cat >>confdefs.h <<\_ACEOF
4719	>	#define FC_FUNC(name,NAME) NAME
4720	>	_ACEOF
4721	>
4722	>	cat >>confdefs.h <<\_ACEOF
4723	>	#define FC_FUNC_(name,NAME) NAME ## _
4724	>	_ACEOF
4725	>	;;
4726	>	"upper case, underscore, no extra underscore")
4727	>	cat >>confdefs.h <<\_ACEOF
4728	>	#define FC_FUNC(name,NAME) NAME ## _
4729	>	_ACEOF
4730	>
4731	>	cat >>confdefs.h <<\_ACEOF
4732	>	#define FC_FUNC_(name,NAME) NAME ## _
4733	>	_ACEOF
4734	>	;;
4735	>	"upper case, underscore, extra underscore")
4736	>	cat >>confdefs.h <<\_ACEOF
4737	>	#define FC_FUNC(name,NAME) NAME ## _
4738	>	_ACEOF
4739	>
4740	>	cat >>confdefs.h <<\_ACEOF
4741	>	#define FC_FUNC_(name,NAME) NAME ## __
4742	>	_ACEOF
4743	>	;;
4744	>	*)
4745	>	{ echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746	>	echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747	>	;;
4748	>	esac
4749	>
4750	>	ac_ext=${FC_SRCEXT-f}
4751	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754	>
4755	>
4756	>
4757	>	ac_ext=${FC_SRCEXT-f}
4758	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761	>	echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762	>	echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763	>	if test "${ac_cv_prog_fc_v+set}" = set; then
4764	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4765	>	else
4766	>	cat >conftest.$ac_ext <<_ACEOF
4767	>	program main
4768	>
4769	>	end
4770	>	_ACEOF
4771	>	rm -f conftest.$ac_objext
4772	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773	>	(eval $ac_compile) 2>conftest.er1
4774	>	ac_status=$?
4775	>	grep -v '^ *+' conftest.er1 >conftest.err
4776	>	rm -f conftest.er1
4777	>	cat conftest.err >&5
4778	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779	>	(exit $ac_status); } &&
4780	>	{ ac_try='test -z "$ac_fc_werror_flag"
4781	>	|| test ! -s conftest.err'
4782	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783	>	(eval $ac_try) 2>&5
4784	>	ac_status=$?
4785	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786	>	(exit $ac_status); }; } &&
4787	>	{ ac_try='test -s conftest.$ac_objext'
4788	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789	>	(eval $ac_try) 2>&5
4790	>	ac_status=$?
4791	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792	>	(exit $ac_status); }; }; then
4793	>	ac_cv_prog_fc_v=
4794	>	# Try some options frequently used verbose output
4795	>	for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796	>	cat >conftest.$ac_ext <<_ACEOF
4797	>	program main
4798	>
4799	>	end
4800	>	_ACEOF
4801	>
4802	>	# Compile and link our simple test program by passing a flag (argument
4803	>	# 1 to this macro) to the Fortran compiler in order to get
4804	>	# "verbose" output that we can then parse for the Fortran linker
4805	>	# flags.
4806	>	ac_save_FFLAGS=$FCFLAGS
4807	>	FCFLAGS="$FCFLAGS $ac_verb"
4808	>	(eval echo $as_me:4808: \"$ac_link\") >&5
4809	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810	>	echo "$ac_fc_v_output" >&5
4811	>	FCFLAGS=$ac_save_FFLAGS
4812	>
4813	>	rm -f conftest*
4814	>
4815	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4817	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818	>	ac_fc_v_output="`echo $ac_fc_v_output |
4819	>	grep 'LPATH is:' |
4820	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821	>
4822	>	case $ac_fc_v_output in
4823	>	# If we are using xlf then replace all the commas with spaces.
4824	>	*xlfentry*)
4825	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826	>
4827	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4829	>	*mGLOB_options_string*)
4830	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831	>
4832	>	# If we are using Cray Fortran then delete quotes.
4833	>	# Use "\"" instead of '"' for font-lock-mode.
4834	>	# FIXME: a more general fix for quoted arguments with spaces?
4835	>	*cft90*)
4836	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837	>	esac
4838	>
4839	>
4840	>	# look for -l* and *.a constructs in the output
4841	>	for ac_arg in $ac_fc_v_output; do
4842	>	case $ac_arg in
4843	>	[\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844	>	ac_cv_prog_fc_v=$ac_verb
4845	>	break 2 ;;
4846	>	esac
4847	>	done
4848	>	done
4849	>	if test -z "$ac_cv_prog_fc_v"; then
4850	>	{ echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851	>	echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852	>	fi
4853	>	else
4854	>	echo "$as_me: failed program was:" >&5
4855	>	sed 's/^/| /' conftest.$ac_ext >&5
4856	>
4857	>	{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858	>	echo "$as_me: WARNING: compilation failed" >&2;}
4859	>	fi
4860	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861	>
4862	>	fi
4863	>	echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864	>	echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865	>	echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866	>	echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867	>	if test "${ac_cv_fc_libs+set}" = set; then
4868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
4869	>	else
4870	>	if test "x$FCLIBS" != "x"; then
4871	>	ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872	>	else
4873	>
4874	>	cat >conftest.$ac_ext <<_ACEOF
4875	>	program main
4876	>
4877	>	end
4878	>	_ACEOF
4879	>
4880	>	# Compile and link our simple test program by passing a flag (argument
4881	>	# 1 to this macro) to the Fortran compiler in order to get
4882	>	# "verbose" output that we can then parse for the Fortran linker
4883	>	# flags.
4884	>	ac_save_FFLAGS=$FCFLAGS
4885	>	FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886	>	(eval echo $as_me:4886: \"$ac_link\") >&5
4887	>	ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888	>	echo "$ac_fc_v_output" >&5
4889	>	FCFLAGS=$ac_save_FFLAGS
4890	>
4891	>	rm -f conftest*
4892	>
4893	>	# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894	>	# /foo, /bar, and /baz are search directories for the Fortran linker.
4895	>	# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896	>	ac_fc_v_output="`echo $ac_fc_v_output |
4897	>	grep 'LPATH is:' |
4898	>	sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899	>
4900	>	case $ac_fc_v_output in
4901	>	# If we are using xlf then replace all the commas with spaces.
4902	>	*xlfentry*)
4903	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904	>
4905	>	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906	>	# $LIBS confuse us, and the libraries appear later in the output anyway).
4907	>	*mGLOB_options_string*)
4908	>	ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909	>
4910	>	# If we are using Cray Fortran then delete quotes.
4911	>	# Use "\"" instead of '"' for font-lock-mode.
4912	>	# FIXME: a more general fix for quoted arguments with spaces?
4913	>	*cft90*)
4914	>	ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915	>	esac
4916	>
4917	>
4918	>
4919	>	ac_cv_fc_libs=
4920	>
4921	>	# Save positional arguments (if any)
4922	>	ac_save_positional="$@"
4923	>
4924	>	set X $ac_fc_v_output
4925	>	while test $# != 1; do
4926	>	shift
4927	>	ac_arg=$1
4928	>	case $ac_arg in
4929	>	[\\/]*.a | ?:[\\/]*.a)
4930	>	ac_exists=false
4931	>	for ac_i in $ac_cv_fc_libs; do
4932	>	if test x"$ac_arg" = x"$ac_i"; then
4933	>	ac_exists=true
4934	>	break
4935	>	fi
4936	>	done
4937	>
4938	>	if test x"$ac_exists" = xtrue; then
4939	>	:
4940	>	else
4941	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942	>	fi
4943	>
4944	>	;;
4945	>	-bI:*)
4946	>	ac_exists=false
4947	>	for ac_i in $ac_cv_fc_libs; do
4948	>	if test x"$ac_arg" = x"$ac_i"; then
4949	>	ac_exists=true
4950	>	break
4951	>	fi
4952	>	done
4953	>
4954	>	if test x"$ac_exists" = xtrue; then
4955	>	:
4956	>	else
4957	>	if test "$ac_compiler_gnu" = yes; then
4958	>	for ac_link_opt in $ac_arg; do
4959	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960	>	done
4961	>	else
4962	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963	>	fi
4964	>	fi
4965	>
4966	>	;;
4967	>	# Ignore these flags.
4968	>	-lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969	>	;;
4970	>	-lkernel32)
4971	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972	>	;;
4973	>	-[LRuY])
4974	>	# These flags, when seen by themselves, take an argument.
4975	>	# We remove the space between option and argument and re-iterate
4976	>	# unless we find an empty arg or a new option (starting with -)
4977	>	case $2 in
4978	>	"" | -*);;
4979	>	*)
4980	>	ac_arg="$ac_arg$2"
4981	>	shift; shift
4982	>	set X $ac_arg "$@"
4983	>	;;
4984	>	esac
4985	>	;;
4986	>	-YP,*)
4987	>	for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988	>	ac_exists=false
4989	>	for ac_i in $ac_cv_fc_libs; do
4990	>	if test x"$ac_j" = x"$ac_i"; then
4991	>	ac_exists=true
4992	>	break
4993	>	fi
4994	>	done
4995	>
4996	>	if test x"$ac_exists" = xtrue; then
4997	>	:
4998	>	else
4999	>	ac_arg="$ac_arg $ac_j"
5000	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001	>	fi
5002	>
5003	>	done
5004	>	;;
5005	>	-[lLR]*)
5006	>	ac_exists=false
5007	>	for ac_i in $ac_cv_fc_libs; do
5008	>	if test x"$ac_arg" = x"$ac_i"; then
5009	>	ac_exists=true
5010	>	break
5011	>	fi
5012	>	done
5013	>
5014	>	if test x"$ac_exists" = xtrue; then
5015	>	:
5016	>	else
5017	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018	>	fi
5019	>
5020	>	;;
5021	>	# Ignore everything else.
5022	>	esac
5023	>	done
5024	>	# restore positional arguments
5025	>	set X $ac_save_positional; shift
5026	>
5027	>	# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028	>	# then we insist that the "run path" must be an absolute path (i.e. it
5029	>	# must begin with a "/").
5030	>	case `(uname -sr) 2>/dev/null` in
5031	>	"SunOS 5"*)
5032	>	ac_ld_run_path=`echo $ac_fc_v_output |
5033	>	sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034	>	test "x$ac_ld_run_path" != x &&
5035	>	if test "$ac_compiler_gnu" = yes; then
5036	>	for ac_link_opt in $ac_ld_run_path; do
5037	>	ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038	>	done
5039	>	else
5040	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041	>	fi
5042	>	;;
5043	>	esac
5044	>	fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045	>
5046	>	fi
5047	>	echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048	>	echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049	>	FCLIBS="$ac_cv_fc_libs"
5050	>
5051	>
5052	>	ac_ext=${FC_SRCEXT-f}
5053	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056	>
5057	>
5058	>
5059	>	echo "$as_me:$LINENO: checking for module suffix" >&5
5060	>	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061	>	rm -f conftest*
5062	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063	>	rm -f work*
5064	>	cat >conftest.$ac_ext <<EOF
5065	>	module conftest
5066	>	integer n
5067	>	parameter (n=1)
5068	>	end module conftest
5069	>	EOF
5070	>	# SGI and absoft compilers generates module name in upper case!
5071	>	testname="conftest"
5072	>	modcase="lower"
5073	>	if (eval $ac_compile) 2>/dev/null ; then
5074	>	MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075	>	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076	>	if test -z "$MOD" ; then
5077	>	MOD=`ls CONFTEST* 2>/dev/null \
5078	>	| grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079	>	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080	>	if test -n "$MOD" ; then
5081	>	testname="CONFTEST"
5082	>	modcase="upper"
5083	>	fi
5084	>	fi
5085	>	if test -z "$MOD" ; then
5086	>	echo "$as_me:$LINENO: result: unknown" >&5
5087	>	echo "${ECHO_T}unknown" >&6
5088	>	# Use mod if we can't figure it out
5089	>	MOD="mod"
5090	>	else
5091	>	echo "$as_me:$LINENO: result: $MOD" >&5
5092	>	echo "${ECHO_T}$MOD" >&6
5093	>	fi
5094	>	if test -s work.pcl ; then
5095	>	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5096	>	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5097	>	fi
5098	>	else
5099	>	echo "$as_me:$LINENO: result: unknown" >&5
5100	>	echo "${ECHO_T}unknown" >&6
5101	>	fi
5102	>
5103	>
5104	>
5105	>
5106	>
5107	>	# Check for module include path (some use -I, some (Solaris) use -M, some
5108	>	# (absoft) use -p).
5109	>	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5110	>	# specified, work.pcl and work.pc are created.  However, if you specify
5111	>	# a file, it must contain a the name of a file ending in .pc .  Ugh!
5112	>	# Use the module made above
5113	>	echo "$as_me:$LINENO: checking for module directory path flag" >&5
5114	>	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5115	>	rm -f conftest*
5116	>	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117	>	rm -f work*
5118	>	cat >conftest.$ac_ext <<EOF
5119	>	module conftest
5120	>	integer n
5121	>	parameter (n=1)
5122	>	end module conftest
5123	>	EOF
5124	>	# SGI and absoft compilers generates module name in upper case!
5125	>	testname="conftest"
5126	>	if (eval $ac_compile) 2>/dev/null ; then
5127	>	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128	>	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129	>	if test -n "$mod" ; then
5130	>	testname="CONFTEST"
5131	>	fi
5132	>	madedir=0
5133	>	if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134	>	cp $testname.$MOD conf
5135	>	rm -f conftest* CONFTEST*
5136	>	cat >conftest1.$ac_ext <<EOF
5137	>	program main
5138	>	use conftest
5139	>	print *, n
5140	>	end
5141	>	EOF
5142	>	F90_WORK_FILES_ARG=""
5143	>	F90MODINCSPEC=""
5144	>	if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145	>	MODDIRFLAG="-I"
5146	>	F90MODINCSPEC="-I<dir>"
5147	>	echo "$as_me:$LINENO: result: -I" >&5
5148	>	echo "${ECHO_T}-I" >&6
5149	>	elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150	>	MODDIRFLAG="-M"
5151	>	F90MODINCSPEC="-M<dir>"
5152	>	echo "$as_me:$LINENO: result: -M" >&5
5153	>	echo "${ECHO_T}-M" >&6
5154	>	elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155	>	MODDIRFLAG="-p"
5156	>	F90MODINCSPEC="-p<dir>"
5157	>	echo "$as_me:$LINENO: result: -p" >&5
5158	>	echo "${ECHO_T}-p" >&6
5159	>	elif test -s work.pc ; then
5160	>	cp work.pc conf/mpimod.pc
5161	>	echo "mpimod.pc" > conf/mpimod.pcl
5162	>	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163	>	if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164	>	MODDIRFLAG='-cl,mpimod.pcl'
5165	>	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166	>	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5167	>	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5168	>	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5169	>
5170	>	else
5171	>	# The version of the Intel compiler that I have refuses to let
5172	>	# you put the "work catalog" list anywhere but the current
5173	>	# directory. For example, you cannot in
5174	>	:
5175	>	fi
5176	>	fi
5177	>	if test -z "MODDIRFLAG" ; then
5178	>	echo "$as_me:$LINENO: result: unknown" >&5
5179	>	echo "${ECHO_T}unknown" >&6
5180	>	fi
5181	>
5182	>
5183	>	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5184	>	if test $madedir = 1 ; then rmdir conf ; fi
5185	>	fi
5186	>
5187	>
5188	>	echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5189	>	echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5190	>	if test "${ac_cv_f90_module_names+set}" = set; then
5191	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5192	>	else
5193	>	ac_ext=${FC_SRCEXT-f}
5194	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197	>
5198	>	# carry out the test in a new directory, so that we don't miss anything
5199	>	mkdir conftest
5200	>	cd conftest
5201	>	cat >conftest.$ac_ext <<_ACEOF
5202	>	MODULE Bar
5203	>	END MODULE Bar
5204	>	_ACEOF
5205	>	rm -f conftest.$ac_objext
5206	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5207	>	(eval $ac_compile) 2>conftest.er1
5208	>	ac_status=$?
5209	>	grep -v '^ *+' conftest.er1 >conftest.err
5210	>	rm -f conftest.er1
5211	>	cat conftest.err >&5
5212	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213	>	(exit $ac_status); } &&
5214	>	{ ac_try='test -z "$ac_fc_werror_flag"
5215	>	|| test ! -s conftest.err'
5216	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217	>	(eval $ac_try) 2>&5
5218	>	ac_status=$?
5219	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5220	>	(exit $ac_status); }; } &&
5221	>	{ ac_try='test -s conftest.$ac_objext'
5222	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5223	>	(eval $ac_try) 2>&5
5224	>	ac_status=$?
5225	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5226	>	(exit $ac_status); }; }; then
5227	>	ac_cv_f90_module_names=
5228	>	ac_file_list=*
5229	>	for ac_file in $ac_file_list; do
5230	>	case $ac_file in
5231	>	# don't care for original source and object files
5232	>	conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5233	>	:
5234	>	;;
5235	>	# look for new files derived from the file name
5236	>	*conftest*)
5237	>	ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5238	>	ac_exists=false
5239	>	for ac_i in $ac_cv_f90_module_names; do
5240	>	if test x"$ac_pat" = x"$ac_i"; then
5241	>	ac_exists=true
5242	>	break
5243	>	fi
5244	>	done
5245	>
5246	>	if test x"$ac_exists" = xtrue; then
5247	>	:
5248	>	else
5249	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5250	>	fi
5251	>
5252	>	;;
5253	>	# look for new files derived from the module name,
5254	>	# with different case translation schemes
5255	>	*Bar*)
5256	>	ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5257	>	ac_exists=false
5258	>	for ac_i in $ac_cv_f90_module_names; do
5259	>	if test x"$ac_pat" = x"$ac_i"; then
5260	>	ac_exists=true
5261	>	break
5262	>	fi
5263	>	done
5264	>
5265	>	if test x"$ac_exists" = xtrue; then
5266	>	:
5267	>	else
5268	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5269	>	fi
5270	>
5271	>	;;
5272	>	*bar*)
5273	>	ac_pat=`echo $ac_file | sed s/bar/%module%/`
5274	>	ac_exists=false
5275	>	for ac_i in $ac_cv_f90_module_names; do
5276	>	if test x"$ac_pat" = x"$ac_i"; then
5277	>	ac_exists=true
5278	>	break
5279	>	fi
5280	>	done
5281	>
5282	>	if test x"$ac_exists" = xtrue; then
5283	>	:
5284	>	else
5285	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5286	>	fi
5287	>
5288	>	;;
5289	>	*BAR*)
5290	>	ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5291	>	ac_exists=false
5292	>	for ac_i in $ac_cv_f90_module_names; do
5293	>	if test x"$ac_pat" = x"$ac_i"; then
5294	>	ac_exists=true
5295	>	break
5296	>	fi
5297	>	done
5298	>
5299	>	if test x"$ac_exists" = xtrue; then
5300	>	:
5301	>	else
5302	>	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5303	>	fi
5304	>
5305	>	;;
5306	>	# Other files - we have no idea how they are generated
5307	>	*)
5308	>	{ echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5309	>	echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5310	>	;;
5311	>	esac
5312	>	done
5313	>	if test "x$ac_cv_f90_module_names" = "x"; then
5314	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5315	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5316	>	fi
5317	>
5318	>	else
5319	>	echo "$as_me: failed program was:" >&5
5320	>	sed 's/^/| /' conftest.$ac_ext >&5
5321	>
5322	>	ac_cv_f90_module_names=
5323	>	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5324	>	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5325	>	fi
5326	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5327	>	cd ..
5328	>	# cleanup
5329	>	rm -rf conftest
5330	>	ac_ext=${FC_SRCEXT-f}
5331	>	ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334	>
5335	>	fi
5336	>	echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5337	>	echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5338	>
5339	>	# We now generate a shell script that will help us to figure out the correct
5340	>	# module file names, using the value of ac_cv_f90_module_names
5341	>
5342	>	echo "Generating shell script modnam"
5343	>
5344	>	cat > scripts/modnam << EOF
5345	>	#! /bin/sh
5346	>	# This script is auto-generated by configure
5347	>	#
5348	>	usage="\\
5349	>	Usage: \$0 [FILES]
5350	>
5351	>	[FILES] are Fortran 90 source files.
5352	>	The output is a list of module file names that the Fortran 90 compiler
5353	>	generates when compiling [FILES]."
5354	>
5355	>	list=
5356	>	empty=
5357	>
5358	>	if test \$# -eq 0; then
5359	>	echo "\$usage"; exit 0
5360	>	fi
5361	>
5362	>	while test \$# != 0; do
5363	>
5364	>	file=\$1
5365	>	shift
5366	>
5367	>	# strip suffix
5368	>	base=\`echo \$file | sed 's/[.][^.]*$//'\`
5369	>
5370	>	test ! -f \$file && continue
5371	>
5372	>	# Look for module definitions and transform them to upper / lower case
5373	>	mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5374	>	upper=\`echo \$mods | tr a-z A-Z\`
5375	>	lower=\`echo \$mods | tr A-Z a-z\`
5376	>
5377	>	# Here, the patterns for generating module file names were inserted by configure
5378	>	for trans in $ac_cv_f90_module_names; do
5379	>
5380	>	pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5381	>	var=empty
5382	>	case \$pat in
5383	>	%MODULE%)
5384	>	var=upper ;;
5385	>	%Module%)
5386	>	var=mods ;;
5387	>	%module%)
5388	>	var=lower ;;
5389	>	%FILE%)
5390	>	test -n "\$mods" && var=base ;;
5391	>	esac
5392	>	new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5393	>	list="\$list \$new"
5394	>	done
5395	>	done
5396	>
5397	>	echo \$list
5398	>	# end of configure-generated script
5399	>	EOF
5400	>	chmod 755 scripts/modnam
5401	>
5402	>	pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5403	>	F90_MODULE_NAMES=empty
5404	>	case $pat in
5405	>	%MODULE%)
5406	>	F90_MODULE_NAMES=UPPER ;;
5407	>	%Module%)
5408	>	F90_MODULE_NAMES=Mixed ;;
5409	>	%module%)
5410	>	F90_MODULE_NAMES=lower ;;
5411	>	*)
5412	>	F90_MODULE_NAMES=unknown ;;
5413	>	esac
5414	>
5415	>	ac_ext=c
5416	>	ac_cpp='$CPP $CPPFLAGS'
5417	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5418	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5419	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420	>
5421	>
5422	>	ac_ext=c
5423	>	ac_cpp='$CPP $CPPFLAGS'
5424	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427	>
5428	>
5429	>
5430	>	echo "$as_me:$LINENO: checking for asin in -lm" >&5
5431	>	echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5432	>	if test "${ac_cv_lib_m_asin+set}" = set; then
5433	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5434	>	else
5435	>	ac_check_lib_save_LIBS=$LIBS
5436	>	LIBS="-lm  $LIBS"
5437	>	cat >conftest.$ac_ext <<_ACEOF
5438	>	/* confdefs.h.  */
5439	>	_ACEOF
5440	>	cat confdefs.h >>conftest.$ac_ext
5441	>	cat >>conftest.$ac_ext <<_ACEOF
5442	>	/* end confdefs.h.  */
5443	>
5444	>	/* Override any gcc2 internal prototype to avoid an error.  */
5445	>	#ifdef __cplusplus
5446	>	extern "C"
5447	>	#endif
5448	>	/* We use char because int might match the return type of a gcc2
5449	>	builtin and then its argument prototype would still apply.  */
5450	>	char asin ();
5451	>	#ifdef FC_DUMMY_MAIN
5452	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5453	>	#  ifdef __cplusplus
5454	>	extern "C"
5455	>	#  endif
5456	>	int FC_DUMMY_MAIN() { return 1; }
5457	>	#endif
5458	>	#endif
5459	>	int
5460	>	main ()
5461	>	{
5462	>	asin ();
5463	>	;
5464	>	return 0;
5465	>	}
5466	>	_ACEOF
5467	>	rm -f conftest.$ac_objext conftest$ac_exeext
5468	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5469	>	(eval $ac_link) 2>conftest.er1
5470	>	ac_status=$?
5471	>	grep -v '^ *+' conftest.er1 >conftest.err
5472	>	rm -f conftest.er1
5473	>	cat conftest.err >&5
5474	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475	>	(exit $ac_status); } &&
5476	>	{ ac_try='test -z "$ac_c_werror_flag"
5477	>	|| test ! -s conftest.err'
5478	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479	>	(eval $ac_try) 2>&5
5480	>	ac_status=$?
5481	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482	>	(exit $ac_status); }; } &&
5483	>	{ ac_try='test -s conftest$ac_exeext'
5484	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5485	>	(eval $ac_try) 2>&5
5486	>	ac_status=$?
5487	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5488	>	(exit $ac_status); }; }; then
5489	>	ac_cv_lib_m_asin=yes
5490	>	else
5491	>	echo "$as_me: failed program was:" >&5
5492	>	sed 's/^/| /' conftest.$ac_ext >&5
5493	>
5494	>	ac_cv_lib_m_asin=no
5495	>	fi
5496	>	rm -f conftest.err conftest.$ac_objext \
5497	>	conftest$ac_exeext conftest.$ac_ext
5498	>	LIBS=$ac_check_lib_save_LIBS
5499	>	fi
5500	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5501	>	echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5502	>	if test $ac_cv_lib_m_asin = yes; then
5503	>	cat >>confdefs.h <<_ACEOF
5504	>	#define HAVE_LIBM 1
5505	>	_ACEOF
5506	>
5507	>	LIBS="-lm $LIBS"
5508	>
5509	>	else
5510	>	exit
5511	>	fi
5512	>
5513	>
5514	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5515	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5516	>	if test "${ac_cv_header_stdc+set}" = set; then
5517	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5518	>	else
5519	>	cat >conftest.$ac_ext <<_ACEOF
5520	>	/* confdefs.h.  */
5521	>	_ACEOF
5522	>	cat confdefs.h >>conftest.$ac_ext
5523	>	cat >>conftest.$ac_ext <<_ACEOF
5524	>	/* end confdefs.h.  */
5525	>	#include <stdlib.h>
5526	>	#include <stdarg.h>
5527	>	#include <string.h>
5528	>	#include <float.h>
5529	>
5530	>	#ifdef FC_DUMMY_MAIN
5531	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5532	>	#  ifdef __cplusplus
5533	>	extern "C"
5534	>	#  endif
5535	>	int FC_DUMMY_MAIN() { return 1; }
5536	>	#endif
5537	>	#endif
5538	>	int
5539	>	main ()
5540	>	{
5541	>
5542	>	;
5543	>	return 0;
5544	>	}
5545	>	_ACEOF
5546	>	rm -f conftest.$ac_objext
5547	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5548	>	(eval $ac_compile) 2>conftest.er1
5549	>	ac_status=$?
5550	>	grep -v '^ *+' conftest.er1 >conftest.err
5551	>	rm -f conftest.er1
5552	>	cat conftest.err >&5
5553	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554	>	(exit $ac_status); } &&
5555	>	{ ac_try='test -z "$ac_c_werror_flag"
5556	>	|| test ! -s conftest.err'
5557	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5558	>	(eval $ac_try) 2>&5
5559	>	ac_status=$?
5560	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5561	>	(exit $ac_status); }; } &&
5562	>	{ ac_try='test -s conftest.$ac_objext'
5563	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5564	>	(eval $ac_try) 2>&5
5565	>	ac_status=$?
5566	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5567	>	(exit $ac_status); }; }; then
5568	>	ac_cv_header_stdc=yes
5569	>	else
5570	>	echo "$as_me: failed program was:" >&5
5571	>	sed 's/^/| /' conftest.$ac_ext >&5
5572	>
5573	>	ac_cv_header_stdc=no
5574	>	fi
5575	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5576	>
5577	>	if test $ac_cv_header_stdc = yes; then
5578	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5579	>	cat >conftest.$ac_ext <<_ACEOF
5580	>	/* confdefs.h.  */
5581	>	_ACEOF
5582	>	cat confdefs.h >>conftest.$ac_ext
5583	>	cat >>conftest.$ac_ext <<_ACEOF
5584	>	/* end confdefs.h.  */
5585	>	#include <string.h>
5586	>
5587	>	_ACEOF
5588	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5589	>	$EGREP "memchr" >/dev/null 2>&1; then
5590	>	:
5591	>	else
5592	>	ac_cv_header_stdc=no
5593	>	fi
5594	>	rm -f conftest*
5595	>
5596	>	fi
5597	>
5598	>	if test $ac_cv_header_stdc = yes; then
5599	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5600	>	cat >conftest.$ac_ext <<_ACEOF
5601	>	/* confdefs.h.  */
5602	>	_ACEOF
5603	>	cat confdefs.h >>conftest.$ac_ext
5604	>	cat >>conftest.$ac_ext <<_ACEOF
5605	>	/* end confdefs.h.  */
5606	>	#include <stdlib.h>
5607	>
5608	>	_ACEOF
5609	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5610	>	$EGREP "free" >/dev/null 2>&1; then
5611	>	:
5612	>	else
5613	>	ac_cv_header_stdc=no
5614	>	fi
5615	>	rm -f conftest*
5616	>
5617	>	fi
5618	>
5619	>	if test $ac_cv_header_stdc = yes; then
5620	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5621	>	if test "$cross_compiling" = yes; then
5622	>	:
5623	>	else
5624	>	cat >conftest.$ac_ext <<_ACEOF
5625	>	/* confdefs.h.  */
5626	>	_ACEOF
5627	>	cat confdefs.h >>conftest.$ac_ext
5628	>	cat >>conftest.$ac_ext <<_ACEOF
5629	>	/* end confdefs.h.  */
5630	>	#include <ctype.h>
5631	>	#if ((' ' & 0x0FF) == 0x020)
5632	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5633	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5634	>	#else
5635	>	# define ISLOWER(c) \
5636	>	(('a' <= (c) && (c) <= 'i') \
5637	>	|| ('j' <= (c) && (c) <= 'r') \
5638	>	|| ('s' <= (c) && (c) <= 'z'))
5639	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5640	>	#endif
5641	>
5642	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5643	>	int
5644	>	main ()
5645	>	{
5646	>	int i;
5647	>	for (i = 0; i < 256; i++)
5648	>	if (XOR (islower (i), ISLOWER (i))
5649	>	|| toupper (i) != TOUPPER (i))
5650	>	exit(2);
5651	>	exit (0);
5652	>	}
5653	>	_ACEOF
5654	>	rm -f conftest$ac_exeext
5655	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5656	>	(eval $ac_link) 2>&5
5657	>	ac_status=$?
5658	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5659	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5660	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5661	>	(eval $ac_try) 2>&5
5662	>	ac_status=$?
5663	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5664	>	(exit $ac_status); }; }; then
5665	>	:
5666	>	else
5667	>	echo "$as_me: program exited with status $ac_status" >&5
5668	>	echo "$as_me: failed program was:" >&5
5669	>	sed 's/^/| /' conftest.$ac_ext >&5
5670	>
5671	>	( exit $ac_status )
5672	>	ac_cv_header_stdc=no
5673	>	fi
5674	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5675	>	fi
5676	>	fi
5677	>	fi
5678	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5679	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
5680	>	if test $ac_cv_header_stdc = yes; then
5681	>
5682	>	cat >>confdefs.h <<\_ACEOF
5683	>	#define STDC_HEADERS 1
5684	>	_ACEOF
5685	>
5686	>	fi
5687	>
5688	>	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
5689	>
5690	>
5691	>
5692	>
5693	>
5694	>
5695	>
5696	>
5697	>
5698	>	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5699	>	inttypes.h stdint.h unistd.h
5700	>	do
5701	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5702	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
5703	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5704	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
5705	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5706	>	else
5707	>	cat >conftest.$ac_ext <<_ACEOF
5708	>	/* confdefs.h.  */
5709	>	_ACEOF
5710	>	cat confdefs.h >>conftest.$ac_ext
5711	>	cat >>conftest.$ac_ext <<_ACEOF
5712	>	/* end confdefs.h.  */
5713	>	$ac_includes_default
5714	>
5715	>	#include <$ac_header>
5716	>	_ACEOF
5717	>	rm -f conftest.$ac_objext
5718	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5719	>	(eval $ac_compile) 2>conftest.er1
5720	>	ac_status=$?
5721	>	grep -v '^ *+' conftest.er1 >conftest.err
5722	>	rm -f conftest.er1
5723	>	cat conftest.err >&5
5724	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725	>	(exit $ac_status); } &&
5726	>	{ ac_try='test -z "$ac_c_werror_flag"
5727	>	|| test ! -s conftest.err'
5728	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5729	>	(eval $ac_try) 2>&5
5730	>	ac_status=$?
5731	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732	>	(exit $ac_status); }; } &&
5733	>	{ ac_try='test -s conftest.$ac_objext'
5734	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5735	>	(eval $ac_try) 2>&5
5736	>	ac_status=$?
5737	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5738	>	(exit $ac_status); }; }; then
5739	>	eval "$as_ac_Header=yes"
5740	>	else
5741	>	echo "$as_me: failed program was:" >&5
5742	>	sed 's/^/| /' conftest.$ac_ext >&5
5743	>
5744	>	eval "$as_ac_Header=no"
5745	>	fi
5746	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5747	>	fi
5748	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5749	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5750	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
5751	>	cat >>confdefs.h <<_ACEOF
5752	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5753	>	_ACEOF
5754	>
5755	>	fi
5756	>
5757	>	done
5758	>
5759	>
5760	>	#
5761	>	# Handle user hints
5762	>	#
5763	>	echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5764	>	echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5765	>
5766	>	# Check whether --with-zlib or --without-zlib was given.
5767	>	if test "${with_zlib+set}" = set; then
5768	>	withval="$with_zlib"
5769	>	if test "$withval" != no ; then
5770	>	echo "$as_me:$LINENO: result: yes" >&5
5771	>	echo "${ECHO_T}yes" >&6
5772	>	if test -d "$withval"
5773	>	then
5774	>	ZLIB_HOME="$withval"
5775	>	else
5776	>	{ echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5777	>	echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5778	>	fi
5779	>	else
5780	>	echo "$as_me:$LINENO: result: no" >&5
5781	>	echo "${ECHO_T}no" >&6
5782	>	fi
5783	>	fi;
5784	>
5785	>	ZLIB_HOME=/usr/local
5786	>	if test ! -f "${ZLIB_HOME}/include/zlib.h"
5787	>	then
5788	>	ZLIB_HOME=/usr
5789	>	fi
5790	>
5791	>	#
5792	>	# Locate zlib, if wanted
5793	>	#
5794	>	if test -n "${ZLIB_HOME}"
5795	>	then
5796	>	ZLIB_OLD_LDFLAGS=$LDFLAGS
5797	>	ZLIB_OLD_CPPFLAGS=$LDFLAGS
5798	>	LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5799	>	CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5800	>
5801	>
5802	>	ac_ext=c
5803	>	ac_cpp='$CPP $CPPFLAGS'
5804	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5805	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5806	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5807	>
5808	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5809	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5810	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5811	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5812	>	else
5813	>	ac_check_lib_save_LIBS=$LIBS
5814	>	LIBS="-lz  $LIBS"
5815	>	cat >conftest.$ac_ext <<_ACEOF
5816	>	/* confdefs.h.  */
5817	>	_ACEOF
5818	>	cat confdefs.h >>conftest.$ac_ext
5819	>	cat >>conftest.$ac_ext <<_ACEOF
5820	>	/* end confdefs.h.  */
5821	>
5822	>	/* Override any gcc2 internal prototype to avoid an error.  */
5823	>	#ifdef __cplusplus
5824	>	extern "C"
5825	>	#endif
5826	>	/* We use char because int might match the return type of a gcc2
5827	>	builtin and then its argument prototype would still apply.  */
5828	>	char inflateEnd ();
5829	>	#ifdef FC_DUMMY_MAIN
5830	>	#ifndef FC_DUMMY_MAIN_EQ_F77
5831	>	#  ifdef __cplusplus
5832	>	extern "C"
5833	>	#  endif
5834	>	int FC_DUMMY_MAIN() { return 1; }
5835	>	#endif
5836	>	#endif
5837	>	int
5838	>	main ()
5839	>	{
5840	>	inflateEnd ();
5841	>	;
5842	>	return 0;
5843	>	}
5844	>	_ACEOF
5845	>	rm -f conftest.$ac_objext conftest$ac_exeext
5846	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847	>	(eval $ac_link) 2>conftest.er1
5848	>	ac_status=$?
5849	>	grep -v '^ *+' conftest.er1 >conftest.err
5850	>	rm -f conftest.er1
5851	>	cat conftest.err >&5
5852	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853	>	(exit $ac_status); } &&
5854	>	{ ac_try='test -z "$ac_c_werror_flag"
5855	>	|| test ! -s conftest.err'
5856	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857	>	(eval $ac_try) 2>&5
5858	>	ac_status=$?
5859	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860	>	(exit $ac_status); }; } &&
5861	>	{ ac_try='test -s conftest$ac_exeext'
5862	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863	>	(eval $ac_try) 2>&5
5864	>	ac_status=$?
5865	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866	>	(exit $ac_status); }; }; then
5867	>	ac_cv_lib_z_inflateEnd=yes
5868	>	else
5869	>	echo "$as_me: failed program was:" >&5
5870	>	sed 's/^/| /' conftest.$ac_ext >&5
5871	>
5872	>	ac_cv_lib_z_inflateEnd=no
5873	>	fi
5874	>	rm -f conftest.err conftest.$ac_objext \
5875	>	conftest$ac_exeext conftest.$ac_ext
5876	>	LIBS=$ac_check_lib_save_LIBS
5877	>	fi
5878	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880	>	if test $ac_cv_lib_z_inflateEnd = yes; then
5881	>	zlib_cv_libz=yes
5882	>	else
5883	>	zlib_cv_libz=no
5884	>	fi
5885	>
5886	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5887	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
5888	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889	>	if test "${ac_cv_header_zlib_h+set}" = set; then
5890	>	echo $ECHO_N "(cached) $ECHO_C" >&6
5891	>	fi
5892	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894	>	else
5895	>	# Is the header compilable?
5896	>	echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897	>	echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898	>	cat >conftest.$ac_ext <<_ACEOF
5899	>	/* confdefs.h.  */
5900	>	_ACEOF
5901	>	cat confdefs.h >>conftest.$ac_ext
5902	>	cat >>conftest.$ac_ext <<_ACEOF
5903	>	/* end confdefs.h.  */
5904	>	$ac_includes_default
5905	>	#include <zlib.h>
5906	>	_ACEOF
5907	>	rm -f conftest.$ac_objext
5908	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5909	>	(eval $ac_compile) 2>conftest.er1
5910	>	ac_status=$?
5911	>	grep -v '^ *+' conftest.er1 >conftest.err
5912	>	rm -f conftest.er1
5913	>	cat conftest.err >&5
5914	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915	>	(exit $ac_status); } &&
5916	>	{ ac_try='test -z "$ac_c_werror_flag"
5917	>	|| test ! -s conftest.err'
5918	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919	>	(eval $ac_try) 2>&5
5920	>	ac_status=$?
5921	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5922	>	(exit $ac_status); }; } &&
5923	>	{ ac_try='test -s conftest.$ac_objext'
5924	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5925	>	(eval $ac_try) 2>&5
5926	>	ac_status=$?
5927	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5928	>	(exit $ac_status); }; }; then
5929	>	ac_header_compiler=yes
5930	>	else
5931	>	echo "$as_me: failed program was:" >&5
5932	>	sed 's/^/| /' conftest.$ac_ext >&5
5933	>
5934	>	ac_header_compiler=no
5935	>	fi
5936	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5937	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5938	>	echo "${ECHO_T}$ac_header_compiler" >&6
5939	>
5940	>	# Is the header present?
5941	>	echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942	>	echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943	>	cat >conftest.$ac_ext <<_ACEOF
5944	>	/* confdefs.h.  */
5945	>	_ACEOF
5946	>	cat confdefs.h >>conftest.$ac_ext
5947	>	cat >>conftest.$ac_ext <<_ACEOF
5948	>	/* end confdefs.h.  */
5949	>	#include <zlib.h>
5950	>	_ACEOF
5951	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5953	>	ac_status=$?
5954	>	grep -v '^ *+' conftest.er1 >conftest.err
5955	>	rm -f conftest.er1
5956	>	cat conftest.err >&5
5957	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958	>	(exit $ac_status); } >/dev/null; then
5959	>	if test -s conftest.err; then
5960	>	ac_cpp_err=$ac_c_preproc_warn_flag
5961	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962	>	else
5963	>	ac_cpp_err=
5964	>	fi
5965	>	else
5966	>	ac_cpp_err=yes
5967	>	fi
5968	>	if test -z "$ac_cpp_err"; then
5969	>	ac_header_preproc=yes
5970	>	else
5971	>	echo "$as_me: failed program was:" >&5
5972	>	sed 's/^/| /' conftest.$ac_ext >&5
5973	>
5974	>	ac_header_preproc=no
5975	>	fi
5976	>	rm -f conftest.err conftest.$ac_ext
5977	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5978	>	echo "${ECHO_T}$ac_header_preproc" >&6
5979	>
5980	>	# So?  What about this header?
5981	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982	>	yes:no: )
5983	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984	>	echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986	>	echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987	>	ac_header_preproc=yes
5988	>	;;
5989	>	no:yes:* )
5990	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991	>	echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993	>	echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995	>	echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996	>	{ echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997	>	echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999	>	echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000	>	{ echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001	>	echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002	>	(
6003	>	cat <<\_ASBOX
6004	>	## ------------------------------ ##
6005	>	## Report this to gezelter@nd.edu ##
6006	>	## ------------------------------ ##
6007	>	_ASBOX
6008	>	) |
6009	>	sed "s/^/$as_me: WARNING:     /" >&2
6010	>	;;
6011	>	esac
6012	>	echo "$as_me:$LINENO: checking for zlib.h" >&5
6013	>	echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014	>	if test "${ac_cv_header_zlib_h+set}" = set; then
6015	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6016	>	else
6017	>	ac_cv_header_zlib_h=$ac_header_preproc
6018	>	fi
6019	>	echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020	>	echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021	>
6022	>	fi
6023	>	if test $ac_cv_header_zlib_h = yes; then
6024	>	zlib_cv_zlib_h=yes
6025	>	else
6026	>	zlib_cv_zlib_h=no
6027	>	fi
6028	>
6029	>
6030	>	ac_ext=c
6031	>	ac_cpp='$CPP $CPPFLAGS'
6032	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035	>
6036	>	if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037	>	then
6038	>	#
6039	>	# If both library and header were found, use them
6040	>	#
6041	>
6042	>	echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043	>	echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6046	>	else
6047	>	ac_check_lib_save_LIBS=$LIBS
6048	>	LIBS="-lz  $LIBS"
6049	>	cat >conftest.$ac_ext <<_ACEOF
6050	>	/* confdefs.h.  */
6051	>	_ACEOF
6052	>	cat confdefs.h >>conftest.$ac_ext
6053	>	cat >>conftest.$ac_ext <<_ACEOF
6054	>	/* end confdefs.h.  */
6055	>
6056	>	/* Override any gcc2 internal prototype to avoid an error.  */
6057	>	#ifdef __cplusplus
6058	>	extern "C"
6059	>	#endif
6060	>	/* We use char because int might match the return type of a gcc2
6061	>	builtin and then its argument prototype would still apply.  */
6062	>	char inflateEnd ();
6063	>	#ifdef FC_DUMMY_MAIN
6064	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6065	>	#  ifdef __cplusplus
6066	>	extern "C"
6067	>	#  endif
6068	>	int FC_DUMMY_MAIN() { return 1; }
6069	>	#endif
6070	>	#endif
6071	>	int
6072	>	main ()
6073	>	{
6074	>	inflateEnd ();
6075	>	;
6076	>	return 0;
6077	>	}
6078	>	_ACEOF
6079	>	rm -f conftest.$ac_objext conftest$ac_exeext
6080	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081	>	(eval $ac_link) 2>conftest.er1
6082	>	ac_status=$?
6083	>	grep -v '^ *+' conftest.er1 >conftest.err
6084	>	rm -f conftest.er1
6085	>	cat conftest.err >&5
6086	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087	>	(exit $ac_status); } &&
6088	>	{ ac_try='test -z "$ac_c_werror_flag"
6089	>	|| test ! -s conftest.err'
6090	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091	>	(eval $ac_try) 2>&5
6092	>	ac_status=$?
6093	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094	>	(exit $ac_status); }; } &&
6095	>	{ ac_try='test -s conftest$ac_exeext'
6096	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097	>	(eval $ac_try) 2>&5
6098	>	ac_status=$?
6099	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100	>	(exit $ac_status); }; }; then
6101	>	ac_cv_lib_z_inflateEnd=yes
6102	>	else
6103	>	echo "$as_me: failed program was:" >&5
6104	>	sed 's/^/| /' conftest.$ac_ext >&5
6105	>
6106	>	ac_cv_lib_z_inflateEnd=no
6107	>	fi
6108	>	rm -f conftest.err conftest.$ac_objext \
6109	>	conftest$ac_exeext conftest.$ac_ext
6110	>	LIBS=$ac_check_lib_save_LIBS
6111	>	fi
6112	>	echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113	>	echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114	>	if test $ac_cv_lib_z_inflateEnd = yes; then
6115	>	cat >>confdefs.h <<_ACEOF
6116	>	#define HAVE_LIBZ 1
6117	>	_ACEOF
6118	>
6119	>	LIBS="-lz $LIBS"
6120	>
6121	>	fi
6122	>
6123	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125	>	echo "$as_me:$LINENO: result: ok" >&5
6126	>	echo "${ECHO_T}ok" >&6
6127	>	else
6128	>	#
6129	>	# If either header or library was not found, revert and bomb
6130	>	#
6131	>	echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132	>	echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133	>	LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134	>	CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135	>	echo "$as_me:$LINENO: result: failed" >&5
6136	>	echo "${ECHO_T}failed" >&6
6137	>	{ { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138	>	echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139	>	{ (exit 1); exit 1; }; }
6140	>	fi
6141	>	fi
6142	>
6143	>
6144	>
6145	>	# Check whether --with-fftw or --without-fftw was given.
6146	>	if test "${with_fftw+set}" = set; then
6147	>	withval="$with_fftw"
6148	>
6149	>	else
6150	>	with_fftw=yes
6151	>	fi;
6152	>	if test "$with_fftw" = "no"; then
6153	>
6154	>	cat >>confdefs.h <<\_ACEOF
6155	>	#define WITHOUT_FFTW
6156	>	_ACEOF
6157	>
6158	>	fi
6159	>	if test "$with_fftw" = "yes"; then
6160	>	sizeof_real=8
6161	>
6162	>
6163	>	if test -z "$ac_fftw_firstname"; then
6164	>
6165	>	sizeof_real=$sizeof_real
6166	>	if test $sizeof_real = 8; then
6167	>	prec="double"
6168	>	fftwcheckprefix=d
6169	>	else
6170	>	prec="single"
6171	>	fftwcheckprefix=s
6172	>	fi
6173	>
6174	>	xfftwname=${fftwcheckprefix}fftw3
6175	>
6176	>	ok="no"
6177	>	# check header doesn't work, since we must use mpicc to get includes,
6178	>	# we cant trust cpp.
6179	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181	>	cat >conftest.$ac_ext <<_ACEOF
6182	>	/* confdefs.h.  */
6183	>	_ACEOF
6184	>	cat confdefs.h >>conftest.$ac_ext
6185	>	cat >>conftest.$ac_ext <<_ACEOF
6186	>	/* end confdefs.h.  */
6187	>	#include <$xfftwname.h>
6188	>	#ifdef FC_DUMMY_MAIN
6189	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6190	>	#  ifdef __cplusplus
6191	>	extern "C"
6192	>	#  endif
6193	>	int FC_DUMMY_MAIN() { return 1; }
6194	>	#endif
6195	>	#endif
6196	>	int
6197	>	main ()
6198	>	{
6199	>
6200	>	;
6201	>	return 0;
6202	>	}
6203	>	_ACEOF
6204	>	rm -f conftest.$ac_objext
6205	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206	>	(eval $ac_compile) 2>conftest.er1
6207	>	ac_status=$?
6208	>	grep -v '^ *+' conftest.er1 >conftest.err
6209	>	rm -f conftest.er1
6210	>	cat conftest.err >&5
6211	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212	>	(exit $ac_status); } &&
6213	>	{ ac_try='test -z "$ac_c_werror_flag"
6214	>	|| test ! -s conftest.err'
6215	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216	>	(eval $ac_try) 2>&5
6217	>	ac_status=$?
6218	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6219	>	(exit $ac_status); }; } &&
6220	>	{ ac_try='test -s conftest.$ac_objext'
6221	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6222	>	(eval $ac_try) 2>&5
6223	>	ac_status=$?
6224	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225	>	(exit $ac_status); }; }; then
6226	>
6227	>	fftwname=$xfftwname
6228	>	echo "$as_me:$LINENO: result: yes" >&5
6229	>	echo "${ECHO_T}yes" >&6
6230	>
6231	>	else
6232	>	echo "$as_me: failed program was:" >&5
6233	>	sed 's/^/| /' conftest.$ac_ext >&5
6234	>
6235	>	echo "$as_me:$LINENO: result: no" >&5
6236	>	echo "${ECHO_T}no" >&6
6237	>	fi
6238	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6239	>
6240	>	# fftwname was set if we found a header
6241	>
6242	>	if test -n "$fftwname"; then
6243	>	# we cannot run the code since an MPI program might not be allowed
6244	>	# on a login node of a supercomputer
6245	>	cat >conftest.$ac_ext <<_ACEOF
6246	>	/* confdefs.h.  */
6247	>	_ACEOF
6248	>	cat confdefs.h >>conftest.$ac_ext
6249	>	cat >>conftest.$ac_ext <<_ACEOF
6250	>	/* end confdefs.h.  */
6251	>	#include <$fftwname.h>
6252	>	#ifdef FC_DUMMY_MAIN
6253	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6254	>	#  ifdef __cplusplus
6255	>	extern "C"
6256	>	#  endif
6257	>	int FC_DUMMY_MAIN() { return 1; }
6258	>	#endif
6259	>	#endif
6260	>	int
6261	>	main ()
6262	>	{
6263	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264	>	;
6265	>	return 0;
6266	>	}
6267	>	_ACEOF
6268	>	rm -f conftest.$ac_objext
6269	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270	>	(eval $ac_compile) 2>conftest.er1
6271	>	ac_status=$?
6272	>	grep -v '^ *+' conftest.er1 >conftest.err
6273	>	rm -f conftest.er1
6274	>	cat conftest.err >&5
6275	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276	>	(exit $ac_status); } &&
6277	>	{ ac_try='test -z "$ac_c_werror_flag"
6278	>	|| test ! -s conftest.err'
6279	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280	>	(eval $ac_try) 2>&5
6281	>	ac_status=$?
6282	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283	>	(exit $ac_status); }; } &&
6284	>	{ ac_try='test -s conftest.$ac_objext'
6285	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286	>	(eval $ac_try) 2>&5
6287	>	ac_status=$?
6288	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289	>	(exit $ac_status); }; }; then
6290	>
6291	>	ok=yes
6292	>	usedprefix=$fftwcheckprefix
6293	>
6294	>	else
6295	>	echo "$as_me: failed program was:" >&5
6296	>	sed 's/^/| /' conftest.$ac_ext >&5
6297	>
6298	>	ok=no
6299	>	fi
6300	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301	>	fi
6302	>
6303	>	if test "$ok" != "yes"; then
6304	>	echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305	>	echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306	>	cat >conftest.$ac_ext <<_ACEOF
6307	>	/* confdefs.h.  */
6308	>	_ACEOF
6309	>	cat confdefs.h >>conftest.$ac_ext
6310	>	cat >>conftest.$ac_ext <<_ACEOF
6311	>	/* end confdefs.h.  */
6312	>	#include <fftw3.h>
6313	>	#ifdef FC_DUMMY_MAIN
6314	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6315	>	#  ifdef __cplusplus
6316	>	extern "C"
6317	>	#  endif
6318	>	int FC_DUMMY_MAIN() { return 1; }
6319	>	#endif
6320	>	#endif
6321	>	int
6322	>	main ()
6323	>	{
6324	>
6325	>	;
6326	>	return 0;
6327	>	}
6328	>	_ACEOF
6329	>	rm -f conftest.$ac_objext
6330	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6331	>	(eval $ac_compile) 2>conftest.er1
6332	>	ac_status=$?
6333	>	grep -v '^ *+' conftest.er1 >conftest.err
6334	>	rm -f conftest.er1
6335	>	cat conftest.err >&5
6336	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337	>	(exit $ac_status); } &&
6338	>	{ ac_try='test -z "$ac_c_werror_flag"
6339	>	|| test ! -s conftest.err'
6340	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341	>	(eval $ac_try) 2>&5
6342	>	ac_status=$?
6343	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6344	>	(exit $ac_status); }; } &&
6345	>	{ ac_try='test -s conftest.$ac_objext'
6346	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6347	>	(eval $ac_try) 2>&5
6348	>	ac_status=$?
6349	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350	>	(exit $ac_status); }; }; then
6351	>	echo "$as_me:$LINENO: result: yes" >&5
6352	>	echo "${ECHO_T}yes" >&6
6353	>	else
6354	>	echo "$as_me: failed program was:" >&5
6355	>	sed 's/^/| /' conftest.$ac_ext >&5
6356	>
6357	>
6358	>	echo "$as_me:$LINENO: result: no" >&5
6359	>	echo "${ECHO_T}no" >&6
6360	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361	>	Do you have $prec precision FFTW installed? If you are using packages,
6362	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363	>	software at www.fftw.org.
6364	>	If you compiled FFTW yourself:
6365	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6366	>	use --with-mpi. It is a good idea to install both single & double.
6367	>	If you have installed FFTW in a non-standard location, you should
6368	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369	>	variables before running configure.
6370	>	That is also necessary to do if your compiler doesn't search
6371	>	/usr/local/include and /usr/local/lib by default." >&5
6372	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373	>	Do you have $prec precision FFTW installed? If you are using packages,
6374	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375	>	software at www.fftw.org.
6376	>	If you compiled FFTW yourself:
6377	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6378	>	use --with-mpi. It is a good idea to install both single & double.
6379	>	If you have installed FFTW in a non-standard location, you should
6380	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381	>	variables before running configure.
6382	>	That is also necessary to do if your compiler doesn't search
6383	>	/usr/local/include and /usr/local/lib by default." >&2;}
6384	>	{ (exit 1); exit 1; }; }
6385	>
6386	>	fi
6387	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6388	>	cat >conftest.$ac_ext <<_ACEOF
6389	>	/* confdefs.h.  */
6390	>	_ACEOF
6391	>	cat confdefs.h >>conftest.$ac_ext
6392	>	cat >>conftest.$ac_ext <<_ACEOF
6393	>	/* end confdefs.h.  */
6394	>	#include <fftw3.h>
6395	>	#ifdef FC_DUMMY_MAIN
6396	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6397	>	#  ifdef __cplusplus
6398	>	extern "C"
6399	>	#  endif
6400	>	int FC_DUMMY_MAIN() { return 1; }
6401	>	#endif
6402	>	#endif
6403	>	int
6404	>	main ()
6405	>	{
6406	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407	>	;
6408	>	return 0;
6409	>	}
6410	>	_ACEOF
6411	>	rm -f conftest.$ac_objext
6412	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413	>	(eval $ac_compile) 2>conftest.er1
6414	>	ac_status=$?
6415	>	grep -v '^ *+' conftest.er1 >conftest.err
6416	>	rm -f conftest.er1
6417	>	cat conftest.err >&5
6418	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419	>	(exit $ac_status); } &&
6420	>	{ ac_try='test -z "$ac_c_werror_flag"
6421	>	|| test ! -s conftest.err'
6422	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423	>	(eval $ac_try) 2>&5
6424	>	ac_status=$?
6425	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426	>	(exit $ac_status); }; } &&
6427	>	{ ac_try='test -s conftest.$ac_objext'
6428	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429	>	(eval $ac_try) 2>&5
6430	>	ac_status=$?
6431	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432	>	(exit $ac_status); }; }; then
6433	>
6434	>	usedprefix=""
6435	>	fftwname=fftw3
6436	>
6437	>	else
6438	>	echo "$as_me: failed program was:" >&5
6439	>	sed 's/^/| /' conftest.$ac_ext >&5
6440	>
6441	>
6442	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443	>	Do you have $prec precision FFTW installed? If you are using packages,
6444	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445	>	software at www.fftw.org.
6446	>	If you compiled FFTW yourself:
6447	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6448	>	use --with-mpi. It is a good idea to install both single & double.
6449	>	If you have installed FFTW in a non-standard location, you should
6450	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451	>	variables before running configure.
6452	>	That is also necessary to do if your compiler doesn't search
6453	>	/usr/local/include and /usr/local/lib by default." >&5
6454	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455	>	Do you have $prec precision FFTW installed? If you are using packages,
6456	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457	>	software at www.fftw.org.
6458	>	If you compiled FFTW yourself:
6459	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6460	>	use --with-mpi. It is a good idea to install both single & double.
6461	>	If you have installed FFTW in a non-standard location, you should
6462	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463	>	variables before running configure.
6464	>	That is also necessary to do if your compiler doesn't search
6465	>	/usr/local/include and /usr/local/lib by default." >&2;}
6466	>	{ (exit 1); exit 1; }; }
6467	>	fi
6468	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469	>	fi
6470	>
6471	>
6472	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6477	>	else
6478	>	ac_check_lib_save_LIBS=$LIBS
6479	>	LIBS="-l$fftwname  $LIBS"
6480	>	cat >conftest.$ac_ext <<_ACEOF
6481	>	/* confdefs.h.  */
6482	>	_ACEOF
6483	>	cat confdefs.h >>conftest.$ac_ext
6484	>	cat >>conftest.$ac_ext <<_ACEOF
6485	>	/* end confdefs.h.  */
6486	>
6487	>
6488	>	#ifdef FC_DUMMY_MAIN
6489	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6490	>	#  ifdef __cplusplus
6491	>	extern "C"
6492	>	#  endif
6493	>	int FC_DUMMY_MAIN() { return 1; }
6494	>	#endif
6495	>	#endif
6496	>	int
6497	>	main ()
6498	>	{
6499	>	main ();
6500	>	;
6501	>	return 0;
6502	>	}
6503	>	_ACEOF
6504	>	rm -f conftest.$ac_objext conftest$ac_exeext
6505	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506	>	(eval $ac_link) 2>conftest.er1
6507	>	ac_status=$?
6508	>	grep -v '^ *+' conftest.er1 >conftest.err
6509	>	rm -f conftest.er1
6510	>	cat conftest.err >&5
6511	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512	>	(exit $ac_status); } &&
6513	>	{ ac_try='test -z "$ac_c_werror_flag"
6514	>	|| test ! -s conftest.err'
6515	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516	>	(eval $ac_try) 2>&5
6517	>	ac_status=$?
6518	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519	>	(exit $ac_status); }; } &&
6520	>	{ ac_try='test -s conftest$ac_exeext'
6521	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522	>	(eval $ac_try) 2>&5
6523	>	ac_status=$?
6524	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525	>	(exit $ac_status); }; }; then
6526	>	eval "$as_ac_Lib=yes"
6527	>	else
6528	>	echo "$as_me: failed program was:" >&5
6529	>	sed 's/^/| /' conftest.$ac_ext >&5
6530	>
6531	>	eval "$as_ac_Lib=no"
6532	>	fi
6533	>	rm -f conftest.err conftest.$ac_objext \
6534	>	conftest$ac_exeext conftest.$ac_ext
6535	>	LIBS=$ac_check_lib_save_LIBS
6536	>	fi
6537	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540	>	cat >>confdefs.h <<_ACEOF
6541	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542	>	_ACEOF
6543	>
6544	>	LIBS="-l$fftwname $LIBS"
6545	>
6546	>	else
6547	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549	>	{ (exit 1); exit 1; }; }
6550	>	fi
6551	>
6552	>	ac_fftw_savedprefix=$usedprefix
6553	>	ac_fftw_firstname=$fftwname
6554	>
6555	>	else
6556	>
6557	>	fftwname=${ac_fftw_savedprefix}fftw3
6558	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560	>	cat >conftest.$ac_ext <<_ACEOF
6561	>	/* confdefs.h.  */
6562	>	_ACEOF
6563	>	cat confdefs.h >>conftest.$ac_ext
6564	>	cat >>conftest.$ac_ext <<_ACEOF
6565	>	/* end confdefs.h.  */
6566	>	#include <$fftwname.h>
6567	>	#ifdef FC_DUMMY_MAIN
6568	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6569	>	#  ifdef __cplusplus
6570	>	extern "C"
6571	>	#  endif
6572	>	int FC_DUMMY_MAIN() { return 1; }
6573	>	#endif
6574	>	#endif
6575	>	int
6576	>	main ()
6577	>	{
6578	>
6579	>	;
6580	>	return 0;
6581	>	}
6582	>	_ACEOF
6583	>	rm -f conftest.$ac_objext
6584	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585	>	(eval $ac_compile) 2>conftest.er1
6586	>	ac_status=$?
6587	>	grep -v '^ *+' conftest.er1 >conftest.err
6588	>	rm -f conftest.er1
6589	>	cat conftest.err >&5
6590	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591	>	(exit $ac_status); } &&
6592	>	{ ac_try='test -z "$ac_c_werror_flag"
6593	>	|| test ! -s conftest.err'
6594	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595	>	(eval $ac_try) 2>&5
6596	>	ac_status=$?
6597	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598	>	(exit $ac_status); }; } &&
6599	>	{ ac_try='test -s conftest.$ac_objext'
6600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601	>	(eval $ac_try) 2>&5
6602	>	ac_status=$?
6603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604	>	(exit $ac_status); }; }; then
6605	>	echo "$as_me:$LINENO: result: yes" >&5
6606	>	echo "${ECHO_T}yes" >&6
6607	>	LIBS="-l$fftwname $LIBS"
6608	>	cat >conftest.$ac_ext <<_ACEOF
6609	>	/* confdefs.h.  */
6610	>	_ACEOF
6611	>	cat confdefs.h >>conftest.$ac_ext
6612	>	cat >>conftest.$ac_ext <<_ACEOF
6613	>	/* end confdefs.h.  */
6614	>
6615	>
6616	>	#ifdef FC_DUMMY_MAIN
6617	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6618	>	#  ifdef __cplusplus
6619	>	extern "C"
6620	>	#  endif
6621	>	int FC_DUMMY_MAIN() { return 1; }
6622	>	#endif
6623	>	#endif
6624	>	int
6625	>	main ()
6626	>	{
6627	>	main ();
6628	>	;
6629	>	return 0;
6630	>	}
6631	>	_ACEOF
6632	>	rm -f conftest.$ac_objext conftest$ac_exeext
6633	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634	>	(eval $ac_link) 2>conftest.er1
6635	>	ac_status=$?
6636	>	grep -v '^ *+' conftest.er1 >conftest.err
6637	>	rm -f conftest.er1
6638	>	cat conftest.err >&5
6639	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640	>	(exit $ac_status); } &&
6641	>	{ ac_try='test -z "$ac_c_werror_flag"
6642	>	|| test ! -s conftest.err'
6643	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644	>	(eval $ac_try) 2>&5
6645	>	ac_status=$?
6646	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647	>	(exit $ac_status); }; } &&
6648	>	{ ac_try='test -s conftest$ac_exeext'
6649	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650	>	(eval $ac_try) 2>&5
6651	>	ac_status=$?
6652	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653	>	(exit $ac_status); }; }; then
6654	>	:
6655	>	else
6656	>	echo "$as_me: failed program was:" >&5
6657	>	sed 's/^/| /' conftest.$ac_ext >&5
6658	>
6659	>	fi
6660	>	rm -f conftest.err conftest.$ac_objext \
6661	>	conftest$ac_exeext conftest.$ac_ext
6662	>	else
6663	>	echo "$as_me: failed program was:" >&5
6664	>	sed 's/^/| /' conftest.$ac_ext >&5
6665	>
6666	>
6667	>	echo "$as_me:$LINENO: result: no" >&5
6668	>	echo "${ECHO_T}no" >&6
6669	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673	>	{ (exit 1); exit 1; }; }
6674	>
6675	>	fi
6676	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677	>
6678	>	fi
6679	>
6680	>
6681	>
6682	>	if test "$with_mpi" = "yes"; then
6683	>
6684	>	if test -z "$ac_fftw_firstname"; then
6685	>
6686	>	sizeof_real=$sizeof_real
6687	>	if test $sizeof_real = 8; then
6688	>	prec="double"
6689	>	fftwcheckprefix=d
6690	>	else
6691	>	prec="single"
6692	>	fftwcheckprefix=s
6693	>	fi
6694	>
6695	>	xfftwname=${fftwcheckprefix}fftw3_mpi
6696	>
6697	>	ok="no"
6698	>	# check header doesn't work, since we must use mpicc to get includes,
6699	>	# we cant trust cpp.
6700	>	echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701	>	echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702	>	cat >conftest.$ac_ext <<_ACEOF
6703	>	/* confdefs.h.  */
6704	>	_ACEOF
6705	>	cat confdefs.h >>conftest.$ac_ext
6706	>	cat >>conftest.$ac_ext <<_ACEOF
6707	>	/* end confdefs.h.  */
6708	>	#include <$xfftwname.h>
6709	>	#ifdef FC_DUMMY_MAIN
6710	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6711	>	#  ifdef __cplusplus
6712	>	extern "C"
6713	>	#  endif
6714	>	int FC_DUMMY_MAIN() { return 1; }
6715	>	#endif
6716	>	#endif
6717	>	int
6718	>	main ()
6719	>	{
6720	>
6721	>	;
6722	>	return 0;
6723	>	}
6724	>	_ACEOF
6725	>	rm -f conftest.$ac_objext
6726	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727	>	(eval $ac_compile) 2>conftest.er1
6728	>	ac_status=$?
6729	>	grep -v '^ *+' conftest.er1 >conftest.err
6730	>	rm -f conftest.er1
6731	>	cat conftest.err >&5
6732	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733	>	(exit $ac_status); } &&
6734	>	{ ac_try='test -z "$ac_c_werror_flag"
6735	>	|| test ! -s conftest.err'
6736	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737	>	(eval $ac_try) 2>&5
6738	>	ac_status=$?
6739	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740	>	(exit $ac_status); }; } &&
6741	>	{ ac_try='test -s conftest.$ac_objext'
6742	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743	>	(eval $ac_try) 2>&5
6744	>	ac_status=$?
6745	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746	>	(exit $ac_status); }; }; then
6747	>
6748	>	fftwname=$xfftwname
6749	>	echo "$as_me:$LINENO: result: yes" >&5
6750	>	echo "${ECHO_T}yes" >&6
6751	>
6752	>	else
6753	>	echo "$as_me: failed program was:" >&5
6754	>	sed 's/^/| /' conftest.$ac_ext >&5
6755	>
6756	>	echo "$as_me:$LINENO: result: no" >&5
6757	>	echo "${ECHO_T}no" >&6
6758	>	fi
6759	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760	>
6761	>	# fftwname was set if we found a header
6762	>
6763	>	if test -n "$fftwname"; then
6764	>	# we cannot run the code since an MPI program might not be allowed
6765	>	# on a login node of a supercomputer
6766	>	cat >conftest.$ac_ext <<_ACEOF
6767	>	/* confdefs.h.  */
6768	>	_ACEOF
6769	>	cat confdefs.h >>conftest.$ac_ext
6770	>	cat >>conftest.$ac_ext <<_ACEOF
6771	>	/* end confdefs.h.  */
6772	>	#include <$fftwname.h>
6773	>	#ifdef FC_DUMMY_MAIN
6774	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6775	>	#  ifdef __cplusplus
6776	>	extern "C"
6777	>	#  endif
6778	>	int FC_DUMMY_MAIN() { return 1; }
6779	>	#endif
6780	>	#endif
6781	>	int
6782	>	main ()
6783	>	{
6784	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785	>	;
6786	>	return 0;
6787	>	}
6788	>	_ACEOF
6789	>	rm -f conftest.$ac_objext
6790	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791	>	(eval $ac_compile) 2>conftest.er1
6792	>	ac_status=$?
6793	>	grep -v '^ *+' conftest.er1 >conftest.err
6794	>	rm -f conftest.er1
6795	>	cat conftest.err >&5
6796	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797	>	(exit $ac_status); } &&
6798	>	{ ac_try='test -z "$ac_c_werror_flag"
6799	>	|| test ! -s conftest.err'
6800	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801	>	(eval $ac_try) 2>&5
6802	>	ac_status=$?
6803	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804	>	(exit $ac_status); }; } &&
6805	>	{ ac_try='test -s conftest.$ac_objext'
6806	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807	>	(eval $ac_try) 2>&5
6808	>	ac_status=$?
6809	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810	>	(exit $ac_status); }; }; then
6811	>
6812	>	ok=yes
6813	>	usedprefix=$fftwcheckprefix
6814	>
6815	>	else
6816	>	echo "$as_me: failed program was:" >&5
6817	>	sed 's/^/| /' conftest.$ac_ext >&5
6818	>
6819	>	ok=no
6820	>	fi
6821	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822	>	fi
6823	>
6824	>	if test "$ok" != "yes"; then
6825	>	echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826	>	echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827	>	cat >conftest.$ac_ext <<_ACEOF
6828	>	/* confdefs.h.  */
6829	>	_ACEOF
6830	>	cat confdefs.h >>conftest.$ac_ext
6831	>	cat >>conftest.$ac_ext <<_ACEOF
6832	>	/* end confdefs.h.  */
6833	>	#include <fftw3_mpi.h>
6834	>	#ifdef FC_DUMMY_MAIN
6835	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6836	>	#  ifdef __cplusplus
6837	>	extern "C"
6838	>	#  endif
6839	>	int FC_DUMMY_MAIN() { return 1; }
6840	>	#endif
6841	>	#endif
6842	>	int
6843	>	main ()
6844	>	{
6845	>
6846	>	;
6847	>	return 0;
6848	>	}
6849	>	_ACEOF
6850	>	rm -f conftest.$ac_objext
6851	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852	>	(eval $ac_compile) 2>conftest.er1
6853	>	ac_status=$?
6854	>	grep -v '^ *+' conftest.er1 >conftest.err
6855	>	rm -f conftest.er1
6856	>	cat conftest.err >&5
6857	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858	>	(exit $ac_status); } &&
6859	>	{ ac_try='test -z "$ac_c_werror_flag"
6860	>	|| test ! -s conftest.err'
6861	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862	>	(eval $ac_try) 2>&5
6863	>	ac_status=$?
6864	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865	>	(exit $ac_status); }; } &&
6866	>	{ ac_try='test -s conftest.$ac_objext'
6867	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868	>	(eval $ac_try) 2>&5
6869	>	ac_status=$?
6870	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871	>	(exit $ac_status); }; }; then
6872	>	echo "$as_me:$LINENO: result: yes" >&5
6873	>	echo "${ECHO_T}yes" >&6
6874	>	else
6875	>	echo "$as_me: failed program was:" >&5
6876	>	sed 's/^/| /' conftest.$ac_ext >&5
6877	>
6878	>
6879	>	echo "$as_me:$LINENO: result: no" >&5
6880	>	echo "${ECHO_T}no" >&6
6881	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882	>	Do you have $prec precision FFTW installed? If you are using packages,
6883	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884	>	software at www.fftw.org.
6885	>	If you compiled FFTW yourself:
6886	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6887	>	use --with-mpi. It is a good idea to install both single & double.
6888	>	If you have installed FFTW in a non-standard location, you should
6889	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890	>	variables before running configure.
6891	>	That is also necessary to do if your compiler doesn't search
6892	>	/usr/local/include and /usr/local/lib by default." >&5
6893	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894	>	Do you have $prec precision FFTW installed? If you are using packages,
6895	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896	>	software at www.fftw.org.
6897	>	If you compiled FFTW yourself:
6898	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6899	>	use --with-mpi. It is a good idea to install both single & double.
6900	>	If you have installed FFTW in a non-standard location, you should
6901	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902	>	variables before running configure.
6903	>	That is also necessary to do if your compiler doesn't search
6904	>	/usr/local/include and /usr/local/lib by default." >&2;}
6905	>	{ (exit 1); exit 1; }; }
6906	>
6907	>	fi
6908	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909	>	cat >conftest.$ac_ext <<_ACEOF
6910	>	/* confdefs.h.  */
6911	>	_ACEOF
6912	>	cat confdefs.h >>conftest.$ac_ext
6913	>	cat >>conftest.$ac_ext <<_ACEOF
6914	>	/* end confdefs.h.  */
6915	>	#include <fftw3_mpi.h>
6916	>	#ifdef FC_DUMMY_MAIN
6917	>	#ifndef FC_DUMMY_MAIN_EQ_F77
6918	>	#  ifdef __cplusplus
6919	>	extern "C"
6920	>	#  endif
6921	>	int FC_DUMMY_MAIN() { return 1; }
6922	>	#endif
6923	>	#endif
6924	>	int
6925	>	main ()
6926	>	{
6927	>	int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928	>	;
6929	>	return 0;
6930	>	}
6931	>	_ACEOF
6932	>	rm -f conftest.$ac_objext
6933	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934	>	(eval $ac_compile) 2>conftest.er1
6935	>	ac_status=$?
6936	>	grep -v '^ *+' conftest.er1 >conftest.err
6937	>	rm -f conftest.er1
6938	>	cat conftest.err >&5
6939	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940	>	(exit $ac_status); } &&
6941	>	{ ac_try='test -z "$ac_c_werror_flag"
6942	>	|| test ! -s conftest.err'
6943	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944	>	(eval $ac_try) 2>&5
6945	>	ac_status=$?
6946	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947	>	(exit $ac_status); }; } &&
6948	>	{ ac_try='test -s conftest.$ac_objext'
6949	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950	>	(eval $ac_try) 2>&5
6951	>	ac_status=$?
6952	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953	>	(exit $ac_status); }; }; then
6954	>
6955	>	usedprefix=""
6956	>	fftwname=fftw3_mpi
6957	>
6958	>	else
6959	>	echo "$as_me: failed program was:" >&5
6960	>	sed 's/^/| /' conftest.$ac_ext >&5
6961	>
6962	>
6963	>	{ { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964	>	Do you have $prec precision FFTW installed? If you are using packages,
6965	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966	>	software at www.fftw.org.
6967	>	If you compiled FFTW yourself:
6968	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6969	>	use --with-mpi. It is a good idea to install both single & double.
6970	>	If you have installed FFTW in a non-standard location, you should
6971	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972	>	variables before running configure.
6973	>	That is also necessary to do if your compiler doesn't search
6974	>	/usr/local/include and /usr/local/lib by default." >&5
6975	>	echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976	>	Do you have $prec precision FFTW installed? If you are using packages,
6977	>	note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978	>	software at www.fftw.org.
6979	>	If you compiled FFTW yourself:
6980	>	Note that the default FFTW setup is double precision.  If you want MPI support,
6981	>	use --with-mpi. It is a good idea to install both single & double.
6982	>	If you have installed FFTW in a non-standard location, you should
6983	>	provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984	>	variables before running configure.
6985	>	That is also necessary to do if your compiler doesn't search
6986	>	/usr/local/include and /usr/local/lib by default." >&2;}
6987	>	{ (exit 1); exit 1; }; }
6988	>	fi
6989	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990	>	fi
6991	>
6992	>
6993	>	as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994	>	echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995	>	echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996	>	if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997	>	echo $ECHO_N "(cached) $ECHO_C" >&6
6998	>	else
6999	>	ac_check_lib_save_LIBS=$LIBS
7000	>	LIBS="-l$fftwname  $LIBS"
7001	>	cat >conftest.$ac_ext <<_ACEOF
7002	>	/* confdefs.h.  */
7003	>	_ACEOF
7004	>	cat confdefs.h >>conftest.$ac_ext
7005	>	cat >>conftest.$ac_ext <<_ACEOF
7006	>	/* end confdefs.h.  */
7007	>
7008	>
7009	>	#ifdef FC_DUMMY_MAIN
7010	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7011	>	#  ifdef __cplusplus
7012	>	extern "C"
7013	>	#  endif
7014	>	int FC_DUMMY_MAIN() { return 1; }
7015	>	#endif
7016	>	#endif
7017	>	int
7018	>	main ()
7019	>	{
7020	>	main ();
7021	>	;
7022	>	return 0;
7023	>	}
7024	>	_ACEOF
7025	>	rm -f conftest.$ac_objext conftest$ac_exeext
7026	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027	>	(eval $ac_link) 2>conftest.er1
7028	>	ac_status=$?
7029	>	grep -v '^ *+' conftest.er1 >conftest.err
7030	>	rm -f conftest.er1
7031	>	cat conftest.err >&5
7032	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033	>	(exit $ac_status); } &&
7034	>	{ ac_try='test -z "$ac_c_werror_flag"
7035	>	|| test ! -s conftest.err'
7036	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037	>	(eval $ac_try) 2>&5
7038	>	ac_status=$?
7039	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040	>	(exit $ac_status); }; } &&
7041	>	{ ac_try='test -s conftest$ac_exeext'
7042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043	>	(eval $ac_try) 2>&5
7044	>	ac_status=$?
7045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046	>	(exit $ac_status); }; }; then
7047	>	eval "$as_ac_Lib=yes"
7048	>	else
7049	>	echo "$as_me: failed program was:" >&5
7050	>	sed 's/^/| /' conftest.$ac_ext >&5
7051	>
7052	>	eval "$as_ac_Lib=no"
7053	>	fi
7054	>	rm -f conftest.err conftest.$ac_objext \
7055	>	conftest$ac_exeext conftest.$ac_ext
7056	>	LIBS=$ac_check_lib_save_LIBS
7057	>	fi
7058	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059	>	echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060	>	if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061	>	cat >>confdefs.h <<_ACEOF
7062	>	#define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063	>	_ACEOF
7064	>
7065	>	LIBS="-l$fftwname $LIBS"
7066	>
7067	>	else
7068	>	{ { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069	>	echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070	>	{ (exit 1); exit 1; }; }
7071	>	fi
7072	>
7073	>	ac_fftw_savedprefix=$usedprefix
7074	>	ac_fftw_firstname=$fftwname
7075	>
7076	>	else
7077	>
7078	>	fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079	>	echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080	>	echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081	>	cat >conftest.$ac_ext <<_ACEOF
7082	>	/* confdefs.h.  */
7083	>	_ACEOF
7084	>	cat confdefs.h >>conftest.$ac_ext
7085	>	cat >>conftest.$ac_ext <<_ACEOF
7086	>	/* end confdefs.h.  */
7087	>	#include <$fftwname.h>
7088	>	#ifdef FC_DUMMY_MAIN
7089	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7090	>	#  ifdef __cplusplus
7091	>	extern "C"
7092	>	#  endif
7093	>	int FC_DUMMY_MAIN() { return 1; }
7094	>	#endif
7095	>	#endif
7096	>	int
7097	>	main ()
7098	>	{
7099	>
7100	>	;
7101	>	return 0;
7102	>	}
7103	>	_ACEOF
7104	>	rm -f conftest.$ac_objext
7105	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106	>	(eval $ac_compile) 2>conftest.er1
7107	>	ac_status=$?
7108	>	grep -v '^ *+' conftest.er1 >conftest.err
7109	>	rm -f conftest.er1
7110	>	cat conftest.err >&5
7111	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112	>	(exit $ac_status); } &&
7113	>	{ ac_try='test -z "$ac_c_werror_flag"
7114	>	|| test ! -s conftest.err'
7115	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116	>	(eval $ac_try) 2>&5
7117	>	ac_status=$?
7118	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119	>	(exit $ac_status); }; } &&
7120	>	{ ac_try='test -s conftest.$ac_objext'
7121	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122	>	(eval $ac_try) 2>&5
7123	>	ac_status=$?
7124	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125	>	(exit $ac_status); }; }; then
7126	>	echo "$as_me:$LINENO: result: yes" >&5
7127	>	echo "${ECHO_T}yes" >&6
7128	>	LIBS="-l$fftwname $LIBS"
7129	>	cat >conftest.$ac_ext <<_ACEOF
7130	>	/* confdefs.h.  */
7131	>	_ACEOF
7132	>	cat confdefs.h >>conftest.$ac_ext
7133	>	cat >>conftest.$ac_ext <<_ACEOF
7134	>	/* end confdefs.h.  */
7135	>
7136	>
7137	>	#ifdef FC_DUMMY_MAIN
7138	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7139	>	#  ifdef __cplusplus
7140	>	extern "C"
7141	>	#  endif
7142	>	int FC_DUMMY_MAIN() { return 1; }
7143	>	#endif
7144	>	#endif
7145	>	int
7146	>	main ()
7147	>	{
7148	>	main ();
7149	>	;
7150	>	return 0;
7151	>	}
7152	>	_ACEOF
7153	>	rm -f conftest.$ac_objext conftest$ac_exeext
7154	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155	>	(eval $ac_link) 2>conftest.er1
7156	>	ac_status=$?
7157	>	grep -v '^ *+' conftest.er1 >conftest.err
7158	>	rm -f conftest.er1
7159	>	cat conftest.err >&5
7160	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161	>	(exit $ac_status); } &&
7162	>	{ ac_try='test -z "$ac_c_werror_flag"
7163	>	|| test ! -s conftest.err'
7164	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165	>	(eval $ac_try) 2>&5
7166	>	ac_status=$?
7167	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168	>	(exit $ac_status); }; } &&
7169	>	{ ac_try='test -s conftest$ac_exeext'
7170	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171	>	(eval $ac_try) 2>&5
7172	>	ac_status=$?
7173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174	>	(exit $ac_status); }; }; then
7175	>	:
7176	>	else
7177	>	echo "$as_me: failed program was:" >&5
7178	>	sed 's/^/| /' conftest.$ac_ext >&5
7179	>
7180	>	fi
7181	>	rm -f conftest.err conftest.$ac_objext \
7182	>	conftest$ac_exeext conftest.$ac_ext
7183	>	else
7184	>	echo "$as_me: failed program was:" >&5
7185	>	sed 's/^/| /' conftest.$ac_ext >&5
7186	>
7187	>
7188	>	echo "$as_me:$LINENO: result: no" >&5
7189	>	echo "${ECHO_T}no" >&6
7190	>	{ { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192	>	echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193	>	fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194	>	{ (exit 1); exit 1; }; }
7195	>
7196	>	fi
7197	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198	>
7199	>	fi
7200	>
7201	>
7202	>	fi
7203	>
7204	>	case ${ac_fftw_savedprefix} in
7205	>	d)
7206	>	cat >>confdefs.h <<\_ACEOF
7207	>	#define FFTW_NAME_DFFTW
7208	>	_ACEOF
7209	>	;;
7210	>	*)
7211	>	cat >>confdefs.h <<\_ACEOF
7212	>	#define FFTW_NAME_FFTW
7213	>	_ACEOF
7214	>	;;
7215	>	esac
7216	>	else
7217	>	echo "*******************************************************************"
7218	>	echo "* FFTW libraries and include files are required for computing     *"
7219	>	echo "* undulation spectra with the staticProps program.  If you don't  *"
7220	>	echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221	>	echo "* analyze your trajectories for this property.                    *"
7222	>	echo "*******************************************************************"
7223	>	fi # end of fftw check
7224	>
7225	>	# Checks for header files.
7226	>	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227	>	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228	>	if test "${ac_cv_header_stdc+set}" = set; then
7229	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7230	>	else
7231	>	cat >conftest.$ac_ext <<_ACEOF
7232	>	/* confdefs.h.  */
7233	>	_ACEOF
7234	>	cat confdefs.h >>conftest.$ac_ext
7235	>	cat >>conftest.$ac_ext <<_ACEOF
7236	>	/* end confdefs.h.  */
7237	>	#include <stdlib.h>
7238	>	#include <stdarg.h>
7239	>	#include <string.h>
7240	>	#include <float.h>
7241	>
7242	>	#ifdef FC_DUMMY_MAIN
7243	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7244	>	#  ifdef __cplusplus
7245	>	extern "C"
7246	>	#  endif
7247	>	int FC_DUMMY_MAIN() { return 1; }
7248	>	#endif
7249	>	#endif
7250	>	int
7251	>	main ()
7252	>	{
7253	>
7254	>	;
7255	>	return 0;
7256	>	}
7257	>	_ACEOF
7258	>	rm -f conftest.$ac_objext
7259	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260	>	(eval $ac_compile) 2>conftest.er1
7261	>	ac_status=$?
7262	>	grep -v '^ *+' conftest.er1 >conftest.err
7263	>	rm -f conftest.er1
7264	>	cat conftest.err >&5
7265	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266	>	(exit $ac_status); } &&
7267	>	{ ac_try='test -z "$ac_c_werror_flag"
7268	>	|| test ! -s conftest.err'
7269	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270	>	(eval $ac_try) 2>&5
7271	>	ac_status=$?
7272	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273	>	(exit $ac_status); }; } &&
7274	>	{ ac_try='test -s conftest.$ac_objext'
7275	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276	>	(eval $ac_try) 2>&5
7277	>	ac_status=$?
7278	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279	>	(exit $ac_status); }; }; then
7280	>	ac_cv_header_stdc=yes
7281	>	else
7282	>	echo "$as_me: failed program was:" >&5
7283	>	sed 's/^/| /' conftest.$ac_ext >&5
7284	>
7285	>	ac_cv_header_stdc=no
7286	>	fi
7287	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288	>
7289	>	if test $ac_cv_header_stdc = yes; then
7290	>	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291	>	cat >conftest.$ac_ext <<_ACEOF
7292	>	/* confdefs.h.  */
7293	>	_ACEOF
7294	>	cat confdefs.h >>conftest.$ac_ext
7295	>	cat >>conftest.$ac_ext <<_ACEOF
7296	>	/* end confdefs.h.  */
7297	>	#include <string.h>
7298	>
7299	>	_ACEOF
7300	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301	>	$EGREP "memchr" >/dev/null 2>&1; then
7302	>	:
7303	>	else
7304	>	ac_cv_header_stdc=no
7305	>	fi
7306	>	rm -f conftest*
7307	>
7308	>	fi
7309	>
7310	>	if test $ac_cv_header_stdc = yes; then
7311	>	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312	>	cat >conftest.$ac_ext <<_ACEOF
7313	>	/* confdefs.h.  */
7314	>	_ACEOF
7315	>	cat confdefs.h >>conftest.$ac_ext
7316	>	cat >>conftest.$ac_ext <<_ACEOF
7317	>	/* end confdefs.h.  */
7318	>	#include <stdlib.h>
7319	>
7320	>	_ACEOF
7321	>	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322	>	$EGREP "free" >/dev/null 2>&1; then
7323	>	:
7324	>	else
7325	>	ac_cv_header_stdc=no
7326	>	fi
7327	>	rm -f conftest*
7328	>
7329	>	fi
7330	>
7331	>	if test $ac_cv_header_stdc = yes; then
7332	>	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333	>	if test "$cross_compiling" = yes; then
7334	>	:
7335	>	else
7336	>	cat >conftest.$ac_ext <<_ACEOF
7337	>	/* confdefs.h.  */
7338	>	_ACEOF
7339	>	cat confdefs.h >>conftest.$ac_ext
7340	>	cat >>conftest.$ac_ext <<_ACEOF
7341	>	/* end confdefs.h.  */
7342	>	#include <ctype.h>
7343	>	#if ((' ' & 0x0FF) == 0x020)
7344	>	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345	>	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346	>	#else
7347	>	# define ISLOWER(c) \
7348	>	(('a' <= (c) && (c) <= 'i') \
7349	>	|| ('j' <= (c) && (c) <= 'r') \
7350	>	|| ('s' <= (c) && (c) <= 'z'))
7351	>	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352	>	#endif
7353	>
7354	>	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355	>	int
7356	>	main ()
7357	>	{
7358	>	int i;
7359	>	for (i = 0; i < 256; i++)
7360	>	if (XOR (islower (i), ISLOWER (i))
7361	>	|| toupper (i) != TOUPPER (i))
7362	>	exit(2);
7363	>	exit (0);
7364	>	}
7365	>	_ACEOF
7366	>	rm -f conftest$ac_exeext
7367	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368	>	(eval $ac_link) 2>&5
7369	>	ac_status=$?
7370	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373	>	(eval $ac_try) 2>&5
7374	>	ac_status=$?
7375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376	>	(exit $ac_status); }; }; then
7377	>	:
7378	>	else
7379	>	echo "$as_me: program exited with status $ac_status" >&5
7380	>	echo "$as_me: failed program was:" >&5
7381	>	sed 's/^/| /' conftest.$ac_ext >&5
7382	>
7383	>	( exit $ac_status )
7384	>	ac_cv_header_stdc=no
7385	>	fi
7386	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387	>	fi
7388	>	fi
7389	>	fi
7390	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391	>	echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392	>	if test $ac_cv_header_stdc = yes; then
7393	>
7394	>	cat >>confdefs.h <<\_ACEOF
7395	>	#define STDC_HEADERS 1
7396	>	_ACEOF
7397	>
7398	>	fi
7399	>
7400	>
7401	>
7402	>
7403	>
7404	>
7405	>
7406	>
7407	>
7408	>
7409	>
7410	>
7411	>
7412	>
7413	>
7414	>
7415	>
7416	>
7417	>
7418	>
7419	>
7420	>
7421	>
7422	>
7423	>
7424	>
7425	>	for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7426	>	do
7427	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7430	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7433	>	fi
7434	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436	>	else
7437	>	# Is the header compilable?
7438	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440	>	cat >conftest.$ac_ext <<_ACEOF
7441	>	/* confdefs.h.  */
7442	>	_ACEOF
7443	>	cat confdefs.h >>conftest.$ac_ext
7444	>	cat >>conftest.$ac_ext <<_ACEOF
7445	>	/* end confdefs.h.  */
7446	>	$ac_includes_default
7447	>	#include <$ac_header>
7448	>	_ACEOF
7449	>	rm -f conftest.$ac_objext
7450	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451	>	(eval $ac_compile) 2>conftest.er1
7452	>	ac_status=$?
7453	>	grep -v '^ *+' conftest.er1 >conftest.err
7454	>	rm -f conftest.er1
7455	>	cat conftest.err >&5
7456	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457	>	(exit $ac_status); } &&
7458	>	{ ac_try='test -z "$ac_c_werror_flag"
7459	>	|| test ! -s conftest.err'
7460	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461	>	(eval $ac_try) 2>&5
7462	>	ac_status=$?
7463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464	>	(exit $ac_status); }; } &&
7465	>	{ ac_try='test -s conftest.$ac_objext'
7466	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467	>	(eval $ac_try) 2>&5
7468	>	ac_status=$?
7469	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470	>	(exit $ac_status); }; }; then
7471	>	ac_header_compiler=yes
7472	>	else
7473	>	echo "$as_me: failed program was:" >&5
7474	>	sed 's/^/| /' conftest.$ac_ext >&5
7475	>
7476	>	ac_header_compiler=no
7477	>	fi
7478	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480	>	echo "${ECHO_T}$ac_header_compiler" >&6
7481	>
7482	>	# Is the header present?
7483	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485	>	cat >conftest.$ac_ext <<_ACEOF
7486	>	/* confdefs.h.  */
7487	>	_ACEOF
7488	>	cat confdefs.h >>conftest.$ac_ext
7489	>	cat >>conftest.$ac_ext <<_ACEOF
7490	>	/* end confdefs.h.  */
7491	>	#include <$ac_header>
7492	>	_ACEOF
7493	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495	>	ac_status=$?
7496	>	grep -v '^ *+' conftest.er1 >conftest.err
7497	>	rm -f conftest.er1
7498	>	cat conftest.err >&5
7499	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500	>	(exit $ac_status); } >/dev/null; then
7501	>	if test -s conftest.err; then
7502	>	ac_cpp_err=$ac_c_preproc_warn_flag
7503	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504	>	else
7505	>	ac_cpp_err=
7506	>	fi
7507	>	else
7508	>	ac_cpp_err=yes
7509	>	fi
7510	>	if test -z "$ac_cpp_err"; then
7511	>	ac_header_preproc=yes
7512	>	else
7513	>	echo "$as_me: failed program was:" >&5
7514	>	sed 's/^/| /' conftest.$ac_ext >&5
7515	>
7516	>	ac_header_preproc=no
7517	>	fi
7518	>	rm -f conftest.err conftest.$ac_ext
7519	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520	>	echo "${ECHO_T}$ac_header_preproc" >&6
7521	>
7522	>	# So?  What about this header?
7523	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524	>	yes:no: )
7525	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529	>	ac_header_preproc=yes
7530	>	;;
7531	>	no:yes:* )
7532	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544	>	(
7545	>	cat <<\_ASBOX
7546	>	## ------------------------------ ##
7547	>	## Report this to gezelter@nd.edu ##
7548	>	## ------------------------------ ##
7549	>	_ASBOX
7550	>	) |
7551	>	sed "s/^/$as_me: WARNING:     /" >&2
7552	>	;;
7553	>	esac
7554	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
7555	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7558	>	else
7559	>	eval "$as_ac_Header=\$ac_header_preproc"
7560	>	fi
7561	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563	>
7564	>	fi
7565	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566	>	cat >>confdefs.h <<_ACEOF
7567	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568	>	_ACEOF
7569	>
7570	>	fi
7571	>
7572	>	done
7573	>
7574	>
7575	>	# Checks for typedefs, structures, and compiler characteristics.
7576	>	echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577	>	echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578	>	if test "${ac_cv_header_stdbool_h+set}" = set; then
7579	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7580	>	else
7581	>	cat >conftest.$ac_ext <<_ACEOF
7582	>	/* confdefs.h.  */
7583	>	_ACEOF
7584	>	cat confdefs.h >>conftest.$ac_ext
7585	>	cat >>conftest.$ac_ext <<_ACEOF
7586	>	/* end confdefs.h.  */
7587	>
7588	>	#include <stdbool.h>
7589	>	#ifndef bool
7590	>	# error bool is not defined
7591	>	#endif
7592	>	#ifndef false
7593	>	# error false is not defined
7594	>	#endif
7595	>	#if false
7596	>	# error false is not 0
7597	>	#endif
7598	>	#ifndef true
7599	>	# error true is not defined
7600	>	#endif
7601	>	#if true != 1
7602	>	# error true is not 1
7603	>	#endif
7604	>	#ifndef __bool_true_false_are_defined
7605	>	# error __bool_true_false_are_defined is not defined
7606	>	#endif
7607	>
7608	>	struct s { _Bool s: 1; _Bool t; } s;
7609	>
7610	>	char a[true == 1 ? 1 : -1];
7611	>	char b[false == 0 ? 1 : -1];
7612	>	char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613	>	char d[(bool) -0.5 == true ? 1 : -1];
7614	>	bool e = &s;
7615	>	char f[(_Bool) -0.0 == false ? 1 : -1];
7616	>	char g[true];
7617	>	char h[sizeof (_Bool)];
7618	>	char i[sizeof s.t];
7619	>
7620	>	#ifdef FC_DUMMY_MAIN
7621	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7622	>	#  ifdef __cplusplus
7623	>	extern "C"
7624	>	#  endif
7625	>	int FC_DUMMY_MAIN() { return 1; }
7626	>	#endif
7627	>	#endif
7628	>	int
7629	>	main ()
7630	>	{
7631	>	return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632	>	;
7633	>	return 0;
7634	>	}
7635	>	_ACEOF
7636	>	rm -f conftest.$ac_objext
7637	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638	>	(eval $ac_compile) 2>conftest.er1
7639	>	ac_status=$?
7640	>	grep -v '^ *+' conftest.er1 >conftest.err
7641	>	rm -f conftest.er1
7642	>	cat conftest.err >&5
7643	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644	>	(exit $ac_status); } &&
7645	>	{ ac_try='test -z "$ac_c_werror_flag"
7646	>	|| test ! -s conftest.err'
7647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648	>	(eval $ac_try) 2>&5
7649	>	ac_status=$?
7650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651	>	(exit $ac_status); }; } &&
7652	>	{ ac_try='test -s conftest.$ac_objext'
7653	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654	>	(eval $ac_try) 2>&5
7655	>	ac_status=$?
7656	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657	>	(exit $ac_status); }; }; then
7658	>	ac_cv_header_stdbool_h=yes
7659	>	else
7660	>	echo "$as_me: failed program was:" >&5
7661	>	sed 's/^/| /' conftest.$ac_ext >&5
7662	>
7663	>	ac_cv_header_stdbool_h=no
7664	>	fi
7665	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666	>	fi
7667	>	echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668	>	echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669	>	echo "$as_me:$LINENO: checking for _Bool" >&5
7670	>	echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671	>	if test "${ac_cv_type__Bool+set}" = set; then
7672	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7673	>	else
7674	>	cat >conftest.$ac_ext <<_ACEOF
7675	>	/* confdefs.h.  */
7676	>	_ACEOF
7677	>	cat confdefs.h >>conftest.$ac_ext
7678	>	cat >>conftest.$ac_ext <<_ACEOF
7679	>	/* end confdefs.h.  */
7680	>	$ac_includes_default
7681	>	#ifdef FC_DUMMY_MAIN
7682	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7683	>	#  ifdef __cplusplus
7684	>	extern "C"
7685	>	#  endif
7686	>	int FC_DUMMY_MAIN() { return 1; }
7687	>	#endif
7688	>	#endif
7689	>	int
7690	>	main ()
7691	>	{
7692	>	if ((_Bool *) 0)
7693	>	return 0;
7694	>	if (sizeof (_Bool))
7695	>	return 0;
7696	>	;
7697	>	return 0;
7698	>	}
7699	>	_ACEOF
7700	>	rm -f conftest.$ac_objext
7701	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702	>	(eval $ac_compile) 2>conftest.er1
7703	>	ac_status=$?
7704	>	grep -v '^ *+' conftest.er1 >conftest.err
7705	>	rm -f conftest.er1
7706	>	cat conftest.err >&5
7707	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708	>	(exit $ac_status); } &&
7709	>	{ ac_try='test -z "$ac_c_werror_flag"
7710	>	|| test ! -s conftest.err'
7711	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712	>	(eval $ac_try) 2>&5
7713	>	ac_status=$?
7714	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715	>	(exit $ac_status); }; } &&
7716	>	{ ac_try='test -s conftest.$ac_objext'
7717	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718	>	(eval $ac_try) 2>&5
7719	>	ac_status=$?
7720	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721	>	(exit $ac_status); }; }; then
7722	>	ac_cv_type__Bool=yes
7723	>	else
7724	>	echo "$as_me: failed program was:" >&5
7725	>	sed 's/^/| /' conftest.$ac_ext >&5
7726	>
7727	>	ac_cv_type__Bool=no
7728	>	fi
7729	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730	>	fi
7731	>	echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732	>	echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733	>	if test $ac_cv_type__Bool = yes; then
7734	>
7735	>	cat >>confdefs.h <<_ACEOF
7736	>	#define HAVE__BOOL 1
7737	>	_ACEOF
7738	>
7739	>
7740	>	fi
7741	>
7742	>	if test $ac_cv_header_stdbool_h = yes; then
7743	>
7744	>	cat >>confdefs.h <<\_ACEOF
7745	>	#define HAVE_STDBOOL_H 1
7746	>	_ACEOF
7747	>
7748	>	fi
7749	>
7750	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752	>	if test "${ac_cv_c_const+set}" = set; then
7753	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7754	>	else
7755	>	cat >conftest.$ac_ext <<_ACEOF
7756	>	/* confdefs.h.  */
7757	>	_ACEOF
7758	>	cat confdefs.h >>conftest.$ac_ext
7759	>	cat >>conftest.$ac_ext <<_ACEOF
7760	>	/* end confdefs.h.  */
7761	>
7762	>	#ifdef FC_DUMMY_MAIN
7763	>	#ifndef FC_DUMMY_MAIN_EQ_F77
7764	>	#  ifdef __cplusplus
7765	>	extern "C"
7766	>	#  endif
7767	>	int FC_DUMMY_MAIN() { return 1; }
7768	>	#endif
7769	>	#endif
7770	>	int
7771	>	main ()
7772	>	{
7773	>	/* FIXME: Include the comments suggested by Paul. */
7774	>	#ifndef __cplusplus
7775	>	/* Ultrix mips cc rejects this.  */
7776	>	typedef int charset[2];
7777	>	const charset x;
7778	>	/* SunOS 4.1.1 cc rejects this.  */
7779	>	char const *const *ccp;
7780	>	char **p;
7781	>	/* NEC SVR4.0.2 mips cc rejects this.  */
7782	>	struct point {int x, y;};
7783	>	static struct point const zero = {0,0};
7784	>	/* AIX XL C 1.02.0.0 rejects this.
7785	>	It does not let you subtract one const X* pointer from another in
7786	>	an arm of an if-expression whose if-part is not a constant
7787	>	expression */
7788	>	const char *g = "string";
7789	>	ccp = &g + (g ? g-g : 0);
7790	>	/* HPUX 7.0 cc rejects these. */
7791	>	++ccp;
7792	>	p = (char**) ccp;
7793	>	ccp = (char const *const *) p;
7794	>	{ /* SCO 3.2v4 cc rejects this.  */
7795	>	char *t;
7796	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
7797	>
7798	>	*t++ = 0;
7799	>	}
7800	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801	>	int x[] = {25, 17};
7802	>	const int *foo = &x[0];
7803	>	++foo;
7804	>	}
7805	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806	>	typedef const int *iptr;
7807	>	iptr p = 0;
7808	>	++p;
7809	>	}
7810	>	{ /* AIX XL C 1.02.0.0 rejects this saying
7811	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812	>	struct s { int j; const int *ap[3]; };
7813	>	struct s *b; b->j = 5;
7814	>	}
7815	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816	>	const int foo = 10;
7817	>	}
7818	>	#endif
7819	>
7820	>	;
7821	>	return 0;
7822	>	}
7823	>	_ACEOF
7824	>	rm -f conftest.$ac_objext
7825	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826	>	(eval $ac_compile) 2>conftest.er1
7827	>	ac_status=$?
7828	>	grep -v '^ *+' conftest.er1 >conftest.err
7829	>	rm -f conftest.er1
7830	>	cat conftest.err >&5
7831	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832	>	(exit $ac_status); } &&
7833	>	{ ac_try='test -z "$ac_c_werror_flag"
7834	>	|| test ! -s conftest.err'
7835	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836	>	(eval $ac_try) 2>&5
7837	>	ac_status=$?
7838	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839	>	(exit $ac_status); }; } &&
7840	>	{ ac_try='test -s conftest.$ac_objext'
7841	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842	>	(eval $ac_try) 2>&5
7843	>	ac_status=$?
7844	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845	>	(exit $ac_status); }; }; then
7846	>	ac_cv_c_const=yes
7847	>	else
7848	>	echo "$as_me: failed program was:" >&5
7849	>	sed 's/^/| /' conftest.$ac_ext >&5
7850	>
7851	>	ac_cv_c_const=no
7852	>	fi
7853	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854	>	fi
7855	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856	>	echo "${ECHO_T}$ac_cv_c_const" >&6
7857	>	if test $ac_cv_c_const = no; then
7858	>
7859	>	cat >>confdefs.h <<\_ACEOF
7860	>	#define const
7861	>	_ACEOF
7862	>
7863	>	fi
7864	>
7865	>	echo "$as_me:$LINENO: checking for inline" >&5
7866	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867	>	if test "${ac_cv_c_inline+set}" = set; then
7868	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7869	>	else
7870	>	ac_cv_c_inline=no
7871	>	for ac_kw in inline __inline__ __inline; do
7872	>	cat >conftest.$ac_ext <<_ACEOF
7873	>	/* confdefs.h.  */
7874	>	_ACEOF
7875	>	cat confdefs.h >>conftest.$ac_ext
7876	>	cat >>conftest.$ac_ext <<_ACEOF
7877	>	/* end confdefs.h.  */
7878	>	#ifndef __cplusplus
7879	>	typedef int foo_t;
7880	>	static $ac_kw foo_t static_foo () {return 0; }
7881	>	$ac_kw foo_t foo () {return 0; }
7882	>	#endif
7883	>
7884	>	_ACEOF
7885	>	rm -f conftest.$ac_objext
7886	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887	>	(eval $ac_compile) 2>conftest.er1
7888	>	ac_status=$?
7889	>	grep -v '^ *+' conftest.er1 >conftest.err
7890	>	rm -f conftest.er1
7891	>	cat conftest.err >&5
7892	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893	>	(exit $ac_status); } &&
7894	>	{ ac_try='test -z "$ac_c_werror_flag"
7895	>	|| test ! -s conftest.err'
7896	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897	>	(eval $ac_try) 2>&5
7898	>	ac_status=$?
7899	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900	>	(exit $ac_status); }; } &&
7901	>	{ ac_try='test -s conftest.$ac_objext'
7902	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903	>	(eval $ac_try) 2>&5
7904	>	ac_status=$?
7905	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906	>	(exit $ac_status); }; }; then
7907	>	ac_cv_c_inline=$ac_kw; break
7908	>	else
7909	>	echo "$as_me: failed program was:" >&5
7910	>	sed 's/^/| /' conftest.$ac_ext >&5
7911	>
7912	>	fi
7913	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914	>	done
7915	>
7916	>	fi
7917	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
7919	>
7920	>
7921	>	case $ac_cv_c_inline in
7922	>	inline | yes) ;;
7923	>	*)
7924	>	case $ac_cv_c_inline in
7925	>	no) ac_val=;;
7926	>	*) ac_val=$ac_cv_c_inline;;
7927	>	esac
7928	>	cat >>confdefs.h <<_ACEOF
7929	>	#ifndef __cplusplus
7930	>	#define inline $ac_val
7931	>	#endif
7932	>	_ACEOF
7933	>	;;
7934	>	esac
7935	>
7936	>	echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937	>	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938	>	if test "${ac_cv_c_restrict+set}" = set; then
7939	>	echo $ECHO_N "(cached) $ECHO_C" >&6
7940	>	else
7941	>	ac_cv_c_restrict=no
7942	>	# Try the official restrict keyword, then gcc's __restrict, and
7943	>	# the less common variants.
7944	>	for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945	>	cat >conftest.$ac_ext <<_ACEOF
7946	>	/* confdefs.h.  */
7947	>	_ACEOF
7948	>	cat confdefs.h >>conftest.$ac_ext
7949	>	cat >>conftest.$ac_ext <<_ACEOF
7950	>	/* end confdefs.h.  */
7951	>	float * $ac_kw x;
7952	>	_ACEOF
7953	>	rm -f conftest.$ac_objext
7954	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955	>	(eval $ac_compile) 2>conftest.er1
7956	>	ac_status=$?
7957	>	grep -v '^ *+' conftest.er1 >conftest.err
7958	>	rm -f conftest.er1
7959	>	cat conftest.err >&5
7960	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961	>	(exit $ac_status); } &&
7962	>	{ ac_try='test -z "$ac_c_werror_flag"
7963	>	|| test ! -s conftest.err'
7964	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965	>	(eval $ac_try) 2>&5
7966	>	ac_status=$?
7967	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968	>	(exit $ac_status); }; } &&
7969	>	{ ac_try='test -s conftest.$ac_objext'
7970	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971	>	(eval $ac_try) 2>&5
7972	>	ac_status=$?
7973	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974	>	(exit $ac_status); }; }; then
7975	>	ac_cv_c_restrict=$ac_kw; break
7976	>	else
7977	>	echo "$as_me: failed program was:" >&5
7978	>	sed 's/^/| /' conftest.$ac_ext >&5
7979	>
7980	>	fi
7981	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982	>	done
7983	>
7984	>	fi
7985	>	echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986	>	echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987	>	case $ac_cv_c_restrict in
7988	>	restrict) ;;
7989	>	no)
7990	>	cat >>confdefs.h <<\_ACEOF
7991	>	#define restrict
7992	>	_ACEOF
7993	>	;;
7994	>	*)  cat >>confdefs.h <<_ACEOF
7995	>	#define restrict $ac_cv_c_restrict
7996	>	_ACEOF
7997	>	;;
7998	>	esac
7999	>
8000	>	echo "$as_me:$LINENO: checking for size_t" >&5
8001	>	echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002	>	if test "${ac_cv_type_size_t+set}" = set; then
8003	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8004	>	else
8005	>	cat >conftest.$ac_ext <<_ACEOF
8006	>	/* confdefs.h.  */
8007	>	_ACEOF
8008	>	cat confdefs.h >>conftest.$ac_ext
8009	>	cat >>conftest.$ac_ext <<_ACEOF
8010	>	/* end confdefs.h.  */
8011	>	$ac_includes_default
8012	>	#ifdef FC_DUMMY_MAIN
8013	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8014	>	#  ifdef __cplusplus
8015	>	extern "C"
8016	>	#  endif
8017	>	int FC_DUMMY_MAIN() { return 1; }
8018	>	#endif
8019	>	#endif
8020	>	int
8021	>	main ()
8022	>	{
8023	>	if ((size_t *) 0)
8024	>	return 0;
8025	>	if (sizeof (size_t))
8026	>	return 0;
8027	>	;
8028	>	return 0;
8029	>	}
8030	>	_ACEOF
8031	>	rm -f conftest.$ac_objext
8032	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033	>	(eval $ac_compile) 2>conftest.er1
8034	>	ac_status=$?
8035	>	grep -v '^ *+' conftest.er1 >conftest.err
8036	>	rm -f conftest.er1
8037	>	cat conftest.err >&5
8038	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039	>	(exit $ac_status); } &&
8040	>	{ ac_try='test -z "$ac_c_werror_flag"
8041	>	|| test ! -s conftest.err'
8042	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043	>	(eval $ac_try) 2>&5
8044	>	ac_status=$?
8045	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046	>	(exit $ac_status); }; } &&
8047	>	{ ac_try='test -s conftest.$ac_objext'
8048	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049	>	(eval $ac_try) 2>&5
8050	>	ac_status=$?
8051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052	>	(exit $ac_status); }; }; then
8053	>	ac_cv_type_size_t=yes
8054	>	else
8055	>	echo "$as_me: failed program was:" >&5
8056	>	sed 's/^/| /' conftest.$ac_ext >&5
8057	>
8058	>	ac_cv_type_size_t=no
8059	>	fi
8060	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061	>	fi
8062	>	echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063	>	echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064	>	if test $ac_cv_type_size_t = yes; then
8065	>	:
8066	>	else
8067	>
8068	>	cat >>confdefs.h <<_ACEOF
8069	>	#define size_t unsigned
8070	>	_ACEOF
8071	>
8072	>	fi
8073	>
8074	>	echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075	>	echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076	>	if test "${ac_cv_header_time+set}" = set; then
8077	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8078	>	else
8079	>	cat >conftest.$ac_ext <<_ACEOF
8080	>	/* confdefs.h.  */
8081	>	_ACEOF
8082	>	cat confdefs.h >>conftest.$ac_ext
8083	>	cat >>conftest.$ac_ext <<_ACEOF
8084	>	/* end confdefs.h.  */
8085	>	#include <sys/types.h>
8086	>	#include <sys/time.h>
8087	>	#include <time.h>
8088	>
8089	>	#ifdef FC_DUMMY_MAIN
8090	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8091	>	#  ifdef __cplusplus
8092	>	extern "C"
8093	>	#  endif
8094	>	int FC_DUMMY_MAIN() { return 1; }
8095	>	#endif
8096	>	#endif
8097	>	int
8098	>	main ()
8099	>	{
8100	>	if ((struct tm *) 0)
8101	>	return 0;
8102	>	;
8103	>	return 0;
8104	>	}
8105	>	_ACEOF
8106	>	rm -f conftest.$ac_objext
8107	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108	>	(eval $ac_compile) 2>conftest.er1
8109	>	ac_status=$?
8110	>	grep -v '^ *+' conftest.er1 >conftest.err
8111	>	rm -f conftest.er1
8112	>	cat conftest.err >&5
8113	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114	>	(exit $ac_status); } &&
8115	>	{ ac_try='test -z "$ac_c_werror_flag"
8116	>	|| test ! -s conftest.err'
8117	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118	>	(eval $ac_try) 2>&5
8119	>	ac_status=$?
8120	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121	>	(exit $ac_status); }; } &&
8122	>	{ ac_try='test -s conftest.$ac_objext'
8123	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124	>	(eval $ac_try) 2>&5
8125	>	ac_status=$?
8126	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127	>	(exit $ac_status); }; }; then
8128	>	ac_cv_header_time=yes
8129	>	else
8130	>	echo "$as_me: failed program was:" >&5
8131	>	sed 's/^/| /' conftest.$ac_ext >&5
8132	>
8133	>	ac_cv_header_time=no
8134	>	fi
8135	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136	>	fi
8137	>	echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138	>	echo "${ECHO_T}$ac_cv_header_time" >&6
8139	>	if test $ac_cv_header_time = yes; then
8140	>
8141	>	cat >>confdefs.h <<\_ACEOF
8142	>	#define TIME_WITH_SYS_TIME 1
8143	>	_ACEOF
8144	>
8145	>	fi
8146	>
8147	>	echo "$as_me:$LINENO: checking for clock_t" >&5
8148	>	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149	>	if test "${ac_cv_type_clock_t+set}" = set; then
8150	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8151	>	else
8152	>	cat >conftest.$ac_ext <<_ACEOF
8153	>	/* confdefs.h.  */
8154	>	_ACEOF
8155	>	cat confdefs.h >>conftest.$ac_ext
8156	>	cat >>conftest.$ac_ext <<_ACEOF
8157	>	/* end confdefs.h.  */
8158	>	$ac_includes_default
8159	>	#ifdef FC_DUMMY_MAIN
8160	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8161	>	#  ifdef __cplusplus
8162	>	extern "C"
8163	>	#  endif
8164	>	int FC_DUMMY_MAIN() { return 1; }
8165	>	#endif
8166	>	#endif
8167	>	int
8168	>	main ()
8169	>	{
8170	>	if ((clock_t *) 0)
8171	>	return 0;
8172	>	if (sizeof (clock_t))
8173	>	return 0;
8174	>	;
8175	>	return 0;
8176	>	}
8177	>	_ACEOF
8178	>	rm -f conftest.$ac_objext
8179	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180	>	(eval $ac_compile) 2>conftest.er1
8181	>	ac_status=$?
8182	>	grep -v '^ *+' conftest.er1 >conftest.err
8183	>	rm -f conftest.er1
8184	>	cat conftest.err >&5
8185	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186	>	(exit $ac_status); } &&
8187	>	{ ac_try='test -z "$ac_c_werror_flag"
8188	>	|| test ! -s conftest.err'
8189	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190	>	(eval $ac_try) 2>&5
8191	>	ac_status=$?
8192	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193	>	(exit $ac_status); }; } &&
8194	>	{ ac_try='test -s conftest.$ac_objext'
8195	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196	>	(eval $ac_try) 2>&5
8197	>	ac_status=$?
8198	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199	>	(exit $ac_status); }; }; then
8200	>	ac_cv_type_clock_t=yes
8201	>	else
8202	>	echo "$as_me: failed program was:" >&5
8203	>	sed 's/^/| /' conftest.$ac_ext >&5
8204	>
8205	>	ac_cv_type_clock_t=no
8206	>	fi
8207	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208	>	fi
8209	>	echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210	>	echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211	>	if test $ac_cv_type_clock_t = yes; then
8212	>
8213	>	cat >>confdefs.h <<_ACEOF
8214	>	#define HAVE_CLOCK_T 1
8215	>	_ACEOF
8216	>
8217	>
8218	>	fi
8219	>
8220	>	echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221	>	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222	>	if test "${ac_cv_c_const+set}" = set; then
8223	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8224	>	else
8225	>	cat >conftest.$ac_ext <<_ACEOF
8226	>	/* confdefs.h.  */
8227	>	_ACEOF
8228	>	cat confdefs.h >>conftest.$ac_ext
8229	>	cat >>conftest.$ac_ext <<_ACEOF
8230	>	/* end confdefs.h.  */
8231	>
8232	>	#ifdef FC_DUMMY_MAIN
8233	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8234	>	#  ifdef __cplusplus
8235	>	extern "C"
8236	>	#  endif
8237	>	int FC_DUMMY_MAIN() { return 1; }
8238	>	#endif
8239	>	#endif
8240	>	int
8241	>	main ()
8242	>	{
8243	>	/* FIXME: Include the comments suggested by Paul. */
8244	>	#ifndef __cplusplus
8245	>	/* Ultrix mips cc rejects this.  */
8246	>	typedef int charset[2];
8247	>	const charset x;
8248	>	/* SunOS 4.1.1 cc rejects this.  */
8249	>	char const *const *ccp;
8250	>	char **p;
8251	>	/* NEC SVR4.0.2 mips cc rejects this.  */
8252	>	struct point {int x, y;};
8253	>	static struct point const zero = {0,0};
8254	>	/* AIX XL C 1.02.0.0 rejects this.
8255	>	It does not let you subtract one const X* pointer from another in
8256	>	an arm of an if-expression whose if-part is not a constant
8257	>	expression */
8258	>	const char *g = "string";
8259	>	ccp = &g + (g ? g-g : 0);
8260	>	/* HPUX 7.0 cc rejects these. */
8261	>	++ccp;
8262	>	p = (char**) ccp;
8263	>	ccp = (char const *const *) p;
8264	>	{ /* SCO 3.2v4 cc rejects this.  */
8265	>	char *t;
8266	>	char const *s = 0 ? (char *) 0 : (char const *) 0;
8267	>
8268	>	*t++ = 0;
8269	>	}
8270	>	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271	>	int x[] = {25, 17};
8272	>	const int *foo = &x[0];
8273	>	++foo;
8274	>	}
8275	>	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276	>	typedef const int *iptr;
8277	>	iptr p = 0;
8278	>	++p;
8279	>	}
8280	>	{ /* AIX XL C 1.02.0.0 rejects this saying
8281	>	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282	>	struct s { int j; const int *ap[3]; };
8283	>	struct s *b; b->j = 5;
8284	>	}
8285	>	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286	>	const int foo = 10;
8287	>	}
8288	>	#endif
8289	>
8290	>	;
8291	>	return 0;
8292	>	}
8293	>	_ACEOF
8294	>	rm -f conftest.$ac_objext
8295	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296	>	(eval $ac_compile) 2>conftest.er1
8297	>	ac_status=$?
8298	>	grep -v '^ *+' conftest.er1 >conftest.err
8299	>	rm -f conftest.er1
8300	>	cat conftest.err >&5
8301	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302	>	(exit $ac_status); } &&
8303	>	{ ac_try='test -z "$ac_c_werror_flag"
8304	>	|| test ! -s conftest.err'
8305	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306	>	(eval $ac_try) 2>&5
8307	>	ac_status=$?
8308	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309	>	(exit $ac_status); }; } &&
8310	>	{ ac_try='test -s conftest.$ac_objext'
8311	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312	>	(eval $ac_try) 2>&5
8313	>	ac_status=$?
8314	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315	>	(exit $ac_status); }; }; then
8316	>	ac_cv_c_const=yes
8317	>	else
8318	>	echo "$as_me: failed program was:" >&5
8319	>	sed 's/^/| /' conftest.$ac_ext >&5
8320	>
8321	>	ac_cv_c_const=no
8322	>	fi
8323	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324	>	fi
8325	>	echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326	>	echo "${ECHO_T}$ac_cv_c_const" >&6
8327	>	if test $ac_cv_c_const = no; then
8328	>
8329	>	cat >>confdefs.h <<\_ACEOF
8330	>	#define const
8331	>	_ACEOF
8332	>
8333	>	fi
8334	>
8335	>	echo "$as_me:$LINENO: checking for inline" >&5
8336	>	echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337	>	if test "${ac_cv_c_inline+set}" = set; then
8338	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8339	>	else
8340	>	ac_cv_c_inline=no
8341	>	for ac_kw in inline __inline__ __inline; do
8342	>	cat >conftest.$ac_ext <<_ACEOF
8343	>	/* confdefs.h.  */
8344	>	_ACEOF
8345	>	cat confdefs.h >>conftest.$ac_ext
8346	>	cat >>conftest.$ac_ext <<_ACEOF
8347	>	/* end confdefs.h.  */
8348	>	#ifndef __cplusplus
8349	>	typedef int foo_t;
8350	>	static $ac_kw foo_t static_foo () {return 0; }
8351	>	$ac_kw foo_t foo () {return 0; }
8352	>	#endif
8353	>
8354	>	_ACEOF
8355	>	rm -f conftest.$ac_objext
8356	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357	>	(eval $ac_compile) 2>conftest.er1
8358	>	ac_status=$?
8359	>	grep -v '^ *+' conftest.er1 >conftest.err
8360	>	rm -f conftest.er1
8361	>	cat conftest.err >&5
8362	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363	>	(exit $ac_status); } &&
8364	>	{ ac_try='test -z "$ac_c_werror_flag"
8365	>	|| test ! -s conftest.err'
8366	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367	>	(eval $ac_try) 2>&5
8368	>	ac_status=$?
8369	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370	>	(exit $ac_status); }; } &&
8371	>	{ ac_try='test -s conftest.$ac_objext'
8372	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373	>	(eval $ac_try) 2>&5
8374	>	ac_status=$?
8375	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376	>	(exit $ac_status); }; }; then
8377	>	ac_cv_c_inline=$ac_kw; break
8378	>	else
8379	>	echo "$as_me: failed program was:" >&5
8380	>	sed 's/^/| /' conftest.$ac_ext >&5
8381	>
8382	>	fi
8383	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384	>	done
8385	>
8386	>	fi
8387	>	echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388	>	echo "${ECHO_T}$ac_cv_c_inline" >&6
8389	>
8390	>
8391	>	case $ac_cv_c_inline in
8392	>	inline | yes) ;;
8393	>	*)
8394	>	case $ac_cv_c_inline in
8395	>	no) ac_val=;;
8396	>	*) ac_val=$ac_cv_c_inline;;
8397	>	esac
8398	>	cat >>confdefs.h <<_ACEOF
8399	>	#ifndef __cplusplus
8400	>	#define inline $ac_val
8401	>	#endif
8402	>	_ACEOF
8403	>	;;
8404	>	esac
8405	>
8406	>
8407	>	# Checks for library functions.
8408	>
8409	>	for ac_header in stdlib.h
8410	>	do
8411	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8414	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8417	>	fi
8418	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420	>	else
8421	>	# Is the header compilable?
8422	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424	>	cat >conftest.$ac_ext <<_ACEOF
8425	>	/* confdefs.h.  */
8426	>	_ACEOF
8427	>	cat confdefs.h >>conftest.$ac_ext
8428	>	cat >>conftest.$ac_ext <<_ACEOF
8429	>	/* end confdefs.h.  */
8430	>	$ac_includes_default
8431	>	#include <$ac_header>
8432	>	_ACEOF
8433	>	rm -f conftest.$ac_objext
8434	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435	>	(eval $ac_compile) 2>conftest.er1
8436	>	ac_status=$?
8437	>	grep -v '^ *+' conftest.er1 >conftest.err
8438	>	rm -f conftest.er1
8439	>	cat conftest.err >&5
8440	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441	>	(exit $ac_status); } &&
8442	>	{ ac_try='test -z "$ac_c_werror_flag"
8443	>	|| test ! -s conftest.err'
8444	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445	>	(eval $ac_try) 2>&5
8446	>	ac_status=$?
8447	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448	>	(exit $ac_status); }; } &&
8449	>	{ ac_try='test -s conftest.$ac_objext'
8450	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451	>	(eval $ac_try) 2>&5
8452	>	ac_status=$?
8453	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454	>	(exit $ac_status); }; }; then
8455	>	ac_header_compiler=yes
8456	>	else
8457	>	echo "$as_me: failed program was:" >&5
8458	>	sed 's/^/| /' conftest.$ac_ext >&5
8459	>
8460	>	ac_header_compiler=no
8461	>	fi
8462	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464	>	echo "${ECHO_T}$ac_header_compiler" >&6
8465	>
8466	>	# Is the header present?
8467	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469	>	cat >conftest.$ac_ext <<_ACEOF
8470	>	/* confdefs.h.  */
8471	>	_ACEOF
8472	>	cat confdefs.h >>conftest.$ac_ext
8473	>	cat >>conftest.$ac_ext <<_ACEOF
8474	>	/* end confdefs.h.  */
8475	>	#include <$ac_header>
8476	>	_ACEOF
8477	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479	>	ac_status=$?
8480	>	grep -v '^ *+' conftest.er1 >conftest.err
8481	>	rm -f conftest.er1
8482	>	cat conftest.err >&5
8483	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484	>	(exit $ac_status); } >/dev/null; then
8485	>	if test -s conftest.err; then
8486	>	ac_cpp_err=$ac_c_preproc_warn_flag
8487	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488	>	else
8489	>	ac_cpp_err=
8490	>	fi
8491	>	else
8492	>	ac_cpp_err=yes
8493	>	fi
8494	>	if test -z "$ac_cpp_err"; then
8495	>	ac_header_preproc=yes
8496	>	else
8497	>	echo "$as_me: failed program was:" >&5
8498	>	sed 's/^/| /' conftest.$ac_ext >&5
8499	>
8500	>	ac_header_preproc=no
8501	>	fi
8502	>	rm -f conftest.err conftest.$ac_ext
8503	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504	>	echo "${ECHO_T}$ac_header_preproc" >&6
8505	>
8506	>	# So?  What about this header?
8507	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508	>	yes:no: )
8509	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513	>	ac_header_preproc=yes
8514	>	;;
8515	>	no:yes:* )
8516	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528	>	(
8529	>	cat <<\_ASBOX
8530	>	## ------------------------------ ##
8531	>	## Report this to gezelter@nd.edu ##
8532	>	## ------------------------------ ##
8533	>	_ASBOX
8534	>	) |
8535	>	sed "s/^/$as_me: WARNING:     /" >&2
8536	>	;;
8537	>	esac
8538	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8539	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8542	>	else
8543	>	eval "$as_ac_Header=\$ac_header_preproc"
8544	>	fi
8545	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547	>
8548	>	fi
8549	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550	>	cat >>confdefs.h <<_ACEOF
8551	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552	>	_ACEOF
8553	>
8554	>	fi
8555	>
8556	>	done
8557	>
8558	>	echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559	>	echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8562	>	else
8563	>	if test "$cross_compiling" = yes; then
8564	>	ac_cv_func_malloc_0_nonnull=no
8565	>	else
8566	>	cat >conftest.$ac_ext <<_ACEOF
8567	>	/* confdefs.h.  */
8568	>	_ACEOF
8569	>	cat confdefs.h >>conftest.$ac_ext
8570	>	cat >>conftest.$ac_ext <<_ACEOF
8571	>	/* end confdefs.h.  */
8572	>	#if STDC_HEADERS || HAVE_STDLIB_H
8573	>	# include <stdlib.h>
8574	>	#else
8575	>	char *malloc ();
8576	>	#endif
8577	>
8578	>	#ifdef FC_DUMMY_MAIN
8579	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8580	>	#  ifdef __cplusplus
8581	>	extern "C"
8582	>	#  endif
8583	>	int FC_DUMMY_MAIN() { return 1; }
8584	>	#endif
8585	>	#endif
8586	>	int
8587	>	main ()
8588	>	{
8589	>	exit (malloc (0) ? 0 : 1);
8590	>	;
8591	>	return 0;
8592	>	}
8593	>	_ACEOF
8594	>	rm -f conftest$ac_exeext
8595	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596	>	(eval $ac_link) 2>&5
8597	>	ac_status=$?
8598	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601	>	(eval $ac_try) 2>&5
8602	>	ac_status=$?
8603	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604	>	(exit $ac_status); }; }; then
8605	>	ac_cv_func_malloc_0_nonnull=yes
8606	>	else
8607	>	echo "$as_me: program exited with status $ac_status" >&5
8608	>	echo "$as_me: failed program was:" >&5
8609	>	sed 's/^/| /' conftest.$ac_ext >&5
8610	>
8611	>	( exit $ac_status )
8612	>	ac_cv_func_malloc_0_nonnull=no
8613	>	fi
8614	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615	>	fi
8616	>	fi
8617	>	echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618	>	echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619	>	if test $ac_cv_func_malloc_0_nonnull = yes; then
8620	>
8621	>	cat >>confdefs.h <<\_ACEOF
8622	>	#define HAVE_MALLOC 1
8623	>	_ACEOF
8624	>
8625	>	else
8626	>	cat >>confdefs.h <<\_ACEOF
8627	>	#define HAVE_MALLOC 0
8628	>	_ACEOF
8629	>
8630	>	case $LIBOBJS in
8631	>	"malloc.$ac_objext"   | \
8632	>	*" malloc.$ac_objext"   | \
8633	>	"malloc.$ac_objext "* | \
8634	>	*" malloc.$ac_objext "* ) ;;
8635	>	*) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636	>	esac
8637	>
8638	>
8639	>	cat >>confdefs.h <<\_ACEOF
8640	>	#define malloc rpl_malloc
8641	>	_ACEOF
8642	>
8643	>	fi
8644	>
8645	>
8646	>
8647	>	echo "$as_me:$LINENO: checking for working memcmp" >&5
8648	>	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649	>	if test "${ac_cv_func_memcmp_working+set}" = set; then
8650	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8651	>	else
8652	>	if test "$cross_compiling" = yes; then
8653	>	ac_cv_func_memcmp_working=no
8654	>	else
8655	>	cat >conftest.$ac_ext <<_ACEOF
8656	>	/* confdefs.h.  */
8657	>	_ACEOF
8658	>	cat confdefs.h >>conftest.$ac_ext
8659	>	cat >>conftest.$ac_ext <<_ACEOF
8660	>	/* end confdefs.h.  */
8661	>	$ac_includes_default
8662	>	#ifdef FC_DUMMY_MAIN
8663	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8664	>	#  ifdef __cplusplus
8665	>	extern "C"
8666	>	#  endif
8667	>	int FC_DUMMY_MAIN() { return 1; }
8668	>	#endif
8669	>	#endif
8670	>	int
8671	>	main ()
8672	>	{
8673	>
8674	>	/* Some versions of memcmp are not 8-bit clean.  */
8675	>	char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676	>	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677	>	exit (1);
8678	>
8679	>	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680	>	or more and with at least one buffer not starting on a 4-byte boundary.
8681	>	William Lewis provided this test program.   */
8682	>	{
8683	>	char foo[21];
8684	>	char bar[21];
8685	>	int i;
8686	>	for (i = 0; i < 4; i++)
8687	>	{
8688	>	char *a = foo + i;
8689	>	char *b = bar + i;
8690	>	strcpy (a, "--------01111111");
8691	>	strcpy (b, "--------10000000");
8692	>	if (memcmp (a, b, 16) >= 0)
8693	>	exit (1);
8694	>	}
8695	>	exit (0);
8696	>	}
8697	>
8698	>	;
8699	>	return 0;
8700	>	}
8701	>	_ACEOF
8702	>	rm -f conftest$ac_exeext
8703	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704	>	(eval $ac_link) 2>&5
8705	>	ac_status=$?
8706	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709	>	(eval $ac_try) 2>&5
8710	>	ac_status=$?
8711	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712	>	(exit $ac_status); }; }; then
8713	>	ac_cv_func_memcmp_working=yes
8714	>	else
8715	>	echo "$as_me: program exited with status $ac_status" >&5
8716	>	echo "$as_me: failed program was:" >&5
8717	>	sed 's/^/| /' conftest.$ac_ext >&5
8718	>
8719	>	( exit $ac_status )
8720	>	ac_cv_func_memcmp_working=no
8721	>	fi
8722	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723	>	fi
8724	>	fi
8725	>	echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726	>	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727	>	test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728	>	"memcmp.$ac_objext"   | \
8729	>	*" memcmp.$ac_objext"   | \
8730	>	"memcmp.$ac_objext "* | \
8731	>	*" memcmp.$ac_objext "* ) ;;
8732	>	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733	>	esac
8734	>
8735	>
8736	>
8737	>	for ac_header in stdlib.h
8738	>	do
8739	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8742	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8745	>	fi
8746	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748	>	else
8749	>	# Is the header compilable?
8750	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752	>	cat >conftest.$ac_ext <<_ACEOF
8753	>	/* confdefs.h.  */
8754	>	_ACEOF
8755	>	cat confdefs.h >>conftest.$ac_ext
8756	>	cat >>conftest.$ac_ext <<_ACEOF
8757	>	/* end confdefs.h.  */
8758	>	$ac_includes_default
8759	>	#include <$ac_header>
8760	>	_ACEOF
8761	>	rm -f conftest.$ac_objext
8762	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763	>	(eval $ac_compile) 2>conftest.er1
8764	>	ac_status=$?
8765	>	grep -v '^ *+' conftest.er1 >conftest.err
8766	>	rm -f conftest.er1
8767	>	cat conftest.err >&5
8768	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769	>	(exit $ac_status); } &&
8770	>	{ ac_try='test -z "$ac_c_werror_flag"
8771	>	|| test ! -s conftest.err'
8772	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773	>	(eval $ac_try) 2>&5
8774	>	ac_status=$?
8775	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776	>	(exit $ac_status); }; } &&
8777	>	{ ac_try='test -s conftest.$ac_objext'
8778	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779	>	(eval $ac_try) 2>&5
8780	>	ac_status=$?
8781	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782	>	(exit $ac_status); }; }; then
8783	>	ac_header_compiler=yes
8784	>	else
8785	>	echo "$as_me: failed program was:" >&5
8786	>	sed 's/^/| /' conftest.$ac_ext >&5
8787	>
8788	>	ac_header_compiler=no
8789	>	fi
8790	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792	>	echo "${ECHO_T}$ac_header_compiler" >&6
8793	>
8794	>	# Is the header present?
8795	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797	>	cat >conftest.$ac_ext <<_ACEOF
8798	>	/* confdefs.h.  */
8799	>	_ACEOF
8800	>	cat confdefs.h >>conftest.$ac_ext
8801	>	cat >>conftest.$ac_ext <<_ACEOF
8802	>	/* end confdefs.h.  */
8803	>	#include <$ac_header>
8804	>	_ACEOF
8805	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807	>	ac_status=$?
8808	>	grep -v '^ *+' conftest.er1 >conftest.err
8809	>	rm -f conftest.er1
8810	>	cat conftest.err >&5
8811	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812	>	(exit $ac_status); } >/dev/null; then
8813	>	if test -s conftest.err; then
8814	>	ac_cpp_err=$ac_c_preproc_warn_flag
8815	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816	>	else
8817	>	ac_cpp_err=
8818	>	fi
8819	>	else
8820	>	ac_cpp_err=yes
8821	>	fi
8822	>	if test -z "$ac_cpp_err"; then
8823	>	ac_header_preproc=yes
8824	>	else
8825	>	echo "$as_me: failed program was:" >&5
8826	>	sed 's/^/| /' conftest.$ac_ext >&5
8827	>
8828	>	ac_header_preproc=no
8829	>	fi
8830	>	rm -f conftest.err conftest.$ac_ext
8831	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832	>	echo "${ECHO_T}$ac_header_preproc" >&6
8833	>
8834	>	# So?  What about this header?
8835	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836	>	yes:no: )
8837	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841	>	ac_header_preproc=yes
8842	>	;;
8843	>	no:yes:* )
8844	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856	>	(
8857	>	cat <<\_ASBOX
8858	>	## ------------------------------ ##
8859	>	## Report this to gezelter@nd.edu ##
8860	>	## ------------------------------ ##
8861	>	_ASBOX
8862	>	) |
8863	>	sed "s/^/$as_me: WARNING:     /" >&2
8864	>	;;
8865	>	esac
8866	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8867	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8870	>	else
8871	>	eval "$as_ac_Header=\$ac_header_preproc"
8872	>	fi
8873	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875	>
8876	>	fi
8877	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878	>	cat >>confdefs.h <<_ACEOF
8879	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880	>	_ACEOF
8881	>
8882	>	fi
8883	>
8884	>	done
8885	>
8886	>	echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887	>	echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8890	>	else
8891	>	if test "$cross_compiling" = yes; then
8892	>	ac_cv_func_realloc_0_nonnull=no
8893	>	else
8894	>	cat >conftest.$ac_ext <<_ACEOF
8895	>	/* confdefs.h.  */
8896	>	_ACEOF
8897	>	cat confdefs.h >>conftest.$ac_ext
8898	>	cat >>conftest.$ac_ext <<_ACEOF
8899	>	/* end confdefs.h.  */
8900	>	#if STDC_HEADERS || HAVE_STDLIB_H
8901	>	# include <stdlib.h>
8902	>	#else
8903	>	char *realloc ();
8904	>	#endif
8905	>
8906	>	#ifdef FC_DUMMY_MAIN
8907	>	#ifndef FC_DUMMY_MAIN_EQ_F77
8908	>	#  ifdef __cplusplus
8909	>	extern "C"
8910	>	#  endif
8911	>	int FC_DUMMY_MAIN() { return 1; }
8912	>	#endif
8913	>	#endif
8914	>	int
8915	>	main ()
8916	>	{
8917	>	exit (realloc (0, 0) ? 0 : 1);
8918	>	;
8919	>	return 0;
8920	>	}
8921	>	_ACEOF
8922	>	rm -f conftest$ac_exeext
8923	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924	>	(eval $ac_link) 2>&5
8925	>	ac_status=$?
8926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929	>	(eval $ac_try) 2>&5
8930	>	ac_status=$?
8931	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932	>	(exit $ac_status); }; }; then
8933	>	ac_cv_func_realloc_0_nonnull=yes
8934	>	else
8935	>	echo "$as_me: program exited with status $ac_status" >&5
8936	>	echo "$as_me: failed program was:" >&5
8937	>	sed 's/^/| /' conftest.$ac_ext >&5
8938	>
8939	>	( exit $ac_status )
8940	>	ac_cv_func_realloc_0_nonnull=no
8941	>	fi
8942	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943	>	fi
8944	>	fi
8945	>	echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946	>	echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947	>	if test $ac_cv_func_realloc_0_nonnull = yes; then
8948	>
8949	>	cat >>confdefs.h <<\_ACEOF
8950	>	#define HAVE_REALLOC 1
8951	>	_ACEOF
8952	>
8953	>	else
8954	>	cat >>confdefs.h <<\_ACEOF
8955	>	#define HAVE_REALLOC 0
8956	>	_ACEOF
8957	>
8958	>	case $LIBOBJS in
8959	>	"realloc.$ac_objext"   | \
8960	>	*" realloc.$ac_objext"   | \
8961	>	"realloc.$ac_objext "* | \
8962	>	*" realloc.$ac_objext "* ) ;;
8963	>	*) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964	>	esac
8965	>
8966	>
8967	>	cat >>confdefs.h <<\_ACEOF
8968	>	#define realloc rpl_realloc
8969	>	_ACEOF
8970	>
8971	>	fi
8972	>
8973	>
8974	>
8975	>
8976	>
8977	>	for ac_header in sys/select.h sys/socket.h
8978	>	do
8979	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
8982	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984	>	echo $ECHO_N "(cached) $ECHO_C" >&6
8985	>	fi
8986	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988	>	else
8989	>	# Is the header compilable?
8990	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992	>	cat >conftest.$ac_ext <<_ACEOF
8993	>	/* confdefs.h.  */
8994	>	_ACEOF
8995	>	cat confdefs.h >>conftest.$ac_ext
8996	>	cat >>conftest.$ac_ext <<_ACEOF
8997	>	/* end confdefs.h.  */
8998	>	$ac_includes_default
8999	>	#include <$ac_header>
9000	>	_ACEOF
9001	>	rm -f conftest.$ac_objext
9002	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003	>	(eval $ac_compile) 2>conftest.er1
9004	>	ac_status=$?
9005	>	grep -v '^ *+' conftest.er1 >conftest.err
9006	>	rm -f conftest.er1
9007	>	cat conftest.err >&5
9008	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009	>	(exit $ac_status); } &&
9010	>	{ ac_try='test -z "$ac_c_werror_flag"
9011	>	|| test ! -s conftest.err'
9012	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013	>	(eval $ac_try) 2>&5
9014	>	ac_status=$?
9015	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016	>	(exit $ac_status); }; } &&
9017	>	{ ac_try='test -s conftest.$ac_objext'
9018	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019	>	(eval $ac_try) 2>&5
9020	>	ac_status=$?
9021	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022	>	(exit $ac_status); }; }; then
9023	>	ac_header_compiler=yes
9024	>	else
9025	>	echo "$as_me: failed program was:" >&5
9026	>	sed 's/^/| /' conftest.$ac_ext >&5
9027	>
9028	>	ac_header_compiler=no
9029	>	fi
9030	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032	>	echo "${ECHO_T}$ac_header_compiler" >&6
9033	>
9034	>	# Is the header present?
9035	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037	>	cat >conftest.$ac_ext <<_ACEOF
9038	>	/* confdefs.h.  */
9039	>	_ACEOF
9040	>	cat confdefs.h >>conftest.$ac_ext
9041	>	cat >>conftest.$ac_ext <<_ACEOF
9042	>	/* end confdefs.h.  */
9043	>	#include <$ac_header>
9044	>	_ACEOF
9045	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047	>	ac_status=$?
9048	>	grep -v '^ *+' conftest.er1 >conftest.err
9049	>	rm -f conftest.er1
9050	>	cat conftest.err >&5
9051	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052	>	(exit $ac_status); } >/dev/null; then
9053	>	if test -s conftest.err; then
9054	>	ac_cpp_err=$ac_c_preproc_warn_flag
9055	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056	>	else
9057	>	ac_cpp_err=
9058	>	fi
9059	>	else
9060	>	ac_cpp_err=yes
9061	>	fi
9062	>	if test -z "$ac_cpp_err"; then
9063	>	ac_header_preproc=yes
9064	>	else
9065	>	echo "$as_me: failed program was:" >&5
9066	>	sed 's/^/| /' conftest.$ac_ext >&5
9067	>
9068	>	ac_header_preproc=no
9069	>	fi
9070	>	rm -f conftest.err conftest.$ac_ext
9071	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072	>	echo "${ECHO_T}$ac_header_preproc" >&6
9073	>
9074	>	# So?  What about this header?
9075	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076	>	yes:no: )
9077	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081	>	ac_header_preproc=yes
9082	>	;;
9083	>	no:yes:* )
9084	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096	>	(
9097	>	cat <<\_ASBOX
9098	>	## ------------------------------ ##
9099	>	## Report this to gezelter@nd.edu ##
9100	>	## ------------------------------ ##
9101	>	_ASBOX
9102	>	) |
9103	>	sed "s/^/$as_me: WARNING:     /" >&2
9104	>	;;
9105	>	esac
9106	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9107	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9110	>	else
9111	>	eval "$as_ac_Header=\$ac_header_preproc"
9112	>	fi
9113	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115	>
9116	>	fi
9117	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118	>	cat >>confdefs.h <<_ACEOF
9119	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120	>	_ACEOF
9121	>
9122	>	fi
9123	>
9124	>	done
9125	>
9126	>	echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127	>	echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128	>	if test "${ac_cv_func_select_args+set}" = set; then
9129	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9130	>	else
9131	>	for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132	>	for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133	>	for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134	>	cat >conftest.$ac_ext <<_ACEOF
9135	>	/* confdefs.h.  */
9136	>	_ACEOF
9137	>	cat confdefs.h >>conftest.$ac_ext
9138	>	cat >>conftest.$ac_ext <<_ACEOF
9139	>	/* end confdefs.h.  */
9140	>	$ac_includes_default
9141	>	#if HAVE_SYS_SELECT_H
9142	>	# include <sys/select.h>
9143	>	#endif
9144	>	#if HAVE_SYS_SOCKET_H
9145	>	# include <sys/socket.h>
9146	>	#endif
9147	>
9148	>	#ifdef FC_DUMMY_MAIN
9149	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9150	>	#  ifdef __cplusplus
9151	>	extern "C"
9152	>	#  endif
9153	>	int FC_DUMMY_MAIN() { return 1; }
9154	>	#endif
9155	>	#endif
9156	>	int
9157	>	main ()
9158	>	{
9159	>	extern int select ($ac_arg1,
9160	>	$ac_arg234, $ac_arg234, $ac_arg234,
9161	>	$ac_arg5);
9162	>	;
9163	>	return 0;
9164	>	}
9165	>	_ACEOF
9166	>	rm -f conftest.$ac_objext
9167	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168	>	(eval $ac_compile) 2>conftest.er1
9169	>	ac_status=$?
9170	>	grep -v '^ *+' conftest.er1 >conftest.err
9171	>	rm -f conftest.er1
9172	>	cat conftest.err >&5
9173	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174	>	(exit $ac_status); } &&
9175	>	{ ac_try='test -z "$ac_c_werror_flag"
9176	>	|| test ! -s conftest.err'
9177	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178	>	(eval $ac_try) 2>&5
9179	>	ac_status=$?
9180	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181	>	(exit $ac_status); }; } &&
9182	>	{ ac_try='test -s conftest.$ac_objext'
9183	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184	>	(eval $ac_try) 2>&5
9185	>	ac_status=$?
9186	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187	>	(exit $ac_status); }; }; then
9188	>	ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189	>	else
9190	>	echo "$as_me: failed program was:" >&5
9191	>	sed 's/^/| /' conftest.$ac_ext >&5
9192	>
9193	>	fi
9194	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195	>	done
9196	>	done
9197	>	done
9198	>	# Provide a safe default value.
9199	>	: ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200	>
9201	>	fi
9202	>	echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203	>	echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204	>	ac_save_IFS=$IFS; IFS=','
9205	>	set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206	>	IFS=$ac_save_IFS
9207	>	shift
9208	>
9209	>	cat >>confdefs.h <<_ACEOF
9210	>	#define SELECT_TYPE_ARG1 $1
9211	>	_ACEOF
9212	>
9213	>
9214	>	cat >>confdefs.h <<_ACEOF
9215	>	#define SELECT_TYPE_ARG234 ($2)
9216	>	_ACEOF
9217	>
9218	>
9219	>	cat >>confdefs.h <<_ACEOF
9220	>	#define SELECT_TYPE_ARG5 ($3)
9221	>	_ACEOF
9222	>
9223	>	rm -f conftest*
9224	>
9225	>
9226	>	for ac_func in strftime
9227	>	do
9228	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9230	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9232	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9233	>	else
9234	>	cat >conftest.$ac_ext <<_ACEOF
9235	>	/* confdefs.h.  */
9236	>	_ACEOF
9237	>	cat confdefs.h >>conftest.$ac_ext
9238	>	cat >>conftest.$ac_ext <<_ACEOF
9239	>	/* end confdefs.h.  */
9240	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242	>	#define $ac_func innocuous_$ac_func
9243	>
9244	>	/* System header to define __stub macros and hopefully few prototypes,
9245	>	which can conflict with char $ac_func (); below.
9246	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247	>	<limits.h> exists even on freestanding compilers.  */
9248	>
9249	>	#ifdef __STDC__
9250	>	# include <limits.h>
9251	>	#else
9252	>	# include <assert.h>
9253	>	#endif
9254	>
9255	>	#undef $ac_func
9256	>
9257	>	/* Override any gcc2 internal prototype to avoid an error.  */
9258	>	#ifdef __cplusplus
9259	>	extern "C"
9260	>	{
9261	>	#endif
9262	>	/* We use char because int might match the return type of a gcc2
9263	>	builtin and then its argument prototype would still apply.  */
9264	>	char $ac_func ();
9265	>	/* The GNU C library defines this for functions which it implements
9266	>	to always fail with ENOSYS.  Some functions are actually named
9267	>	something starting with __ and the normal name is an alias.  */
9268	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269	>	choke me
9270	>	#else
9271	>	char (*f) () = $ac_func;
9272	>	#endif
9273	>	#ifdef __cplusplus
9274	>	}
9275	>	#endif
9276	>
9277	>	#ifdef FC_DUMMY_MAIN
9278	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9279	>	#  ifdef __cplusplus
9280	>	extern "C"
9281	>	#  endif
9282	>	int FC_DUMMY_MAIN() { return 1; }
9283	>	#endif
9284	>	#endif
9285	>	int
9286	>	main ()
9287	>	{
9288	>	return f != $ac_func;
9289	>	;
9290	>	return 0;
9291	>	}
9292	>	_ACEOF
9293	>	rm -f conftest.$ac_objext conftest$ac_exeext
9294	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295	>	(eval $ac_link) 2>conftest.er1
9296	>	ac_status=$?
9297	>	grep -v '^ *+' conftest.er1 >conftest.err
9298	>	rm -f conftest.er1
9299	>	cat conftest.err >&5
9300	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301	>	(exit $ac_status); } &&
9302	>	{ ac_try='test -z "$ac_c_werror_flag"
9303	>	|| test ! -s conftest.err'
9304	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305	>	(eval $ac_try) 2>&5
9306	>	ac_status=$?
9307	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308	>	(exit $ac_status); }; } &&
9309	>	{ ac_try='test -s conftest$ac_exeext'
9310	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311	>	(eval $ac_try) 2>&5
9312	>	ac_status=$?
9313	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314	>	(exit $ac_status); }; }; then
9315	>	eval "$as_ac_var=yes"
9316	>	else
9317	>	echo "$as_me: failed program was:" >&5
9318	>	sed 's/^/| /' conftest.$ac_ext >&5
9319	>
9320	>	eval "$as_ac_var=no"
9321	>	fi
9322	>	rm -f conftest.err conftest.$ac_objext \
9323	>	conftest$ac_exeext conftest.$ac_ext
9324	>	fi
9325	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9328	>	cat >>confdefs.h <<_ACEOF
9329	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330	>	_ACEOF
9331	>
9332	>	else
9333	>	# strftime is in -lintl on SCO UNIX.
9334	>	echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335	>	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336	>	if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9338	>	else
9339	>	ac_check_lib_save_LIBS=$LIBS
9340	>	LIBS="-lintl  $LIBS"
9341	>	cat >conftest.$ac_ext <<_ACEOF
9342	>	/* confdefs.h.  */
9343	>	_ACEOF
9344	>	cat confdefs.h >>conftest.$ac_ext
9345	>	cat >>conftest.$ac_ext <<_ACEOF
9346	>	/* end confdefs.h.  */
9347	>
9348	>	/* Override any gcc2 internal prototype to avoid an error.  */
9349	>	#ifdef __cplusplus
9350	>	extern "C"
9351	>	#endif
9352	>	/* We use char because int might match the return type of a gcc2
9353	>	builtin and then its argument prototype would still apply.  */
9354	>	char strftime ();
9355	>	#ifdef FC_DUMMY_MAIN
9356	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9357	>	#  ifdef __cplusplus
9358	>	extern "C"
9359	>	#  endif
9360	>	int FC_DUMMY_MAIN() { return 1; }
9361	>	#endif
9362	>	#endif
9363	>	int
9364	>	main ()
9365	>	{
9366	>	strftime ();
9367	>	;
9368	>	return 0;
9369	>	}
9370	>	_ACEOF
9371	>	rm -f conftest.$ac_objext conftest$ac_exeext
9372	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373	>	(eval $ac_link) 2>conftest.er1
9374	>	ac_status=$?
9375	>	grep -v '^ *+' conftest.er1 >conftest.err
9376	>	rm -f conftest.er1
9377	>	cat conftest.err >&5
9378	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379	>	(exit $ac_status); } &&
9380	>	{ ac_try='test -z "$ac_c_werror_flag"
9381	>	|| test ! -s conftest.err'
9382	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383	>	(eval $ac_try) 2>&5
9384	>	ac_status=$?
9385	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386	>	(exit $ac_status); }; } &&
9387	>	{ ac_try='test -s conftest$ac_exeext'
9388	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389	>	(eval $ac_try) 2>&5
9390	>	ac_status=$?
9391	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392	>	(exit $ac_status); }; }; then
9393	>	ac_cv_lib_intl_strftime=yes
9394	>	else
9395	>	echo "$as_me: failed program was:" >&5
9396	>	sed 's/^/| /' conftest.$ac_ext >&5
9397	>
9398	>	ac_cv_lib_intl_strftime=no
9399	>	fi
9400	>	rm -f conftest.err conftest.$ac_objext \
9401	>	conftest$ac_exeext conftest.$ac_ext
9402	>	LIBS=$ac_check_lib_save_LIBS
9403	>	fi
9404	>	echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405	>	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406	>	if test $ac_cv_lib_intl_strftime = yes; then
9407	>	cat >>confdefs.h <<\_ACEOF
9408	>	#define HAVE_STRFTIME 1
9409	>	_ACEOF
9410	>
9411	>	LIBS="-lintl $LIBS"
9412	>	fi
9413	>
9414	>	fi
9415	>	done
9416	>
9417	>	echo "$as_me:$LINENO: checking for working strtod" >&5
9418	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419	>	if test "${ac_cv_func_strtod+set}" = set; then
9420	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9421	>	else
9422	>	if test "$cross_compiling" = yes; then
9423	>	ac_cv_func_strtod=no
9424	>	else
9425	>	cat >conftest.$ac_ext <<_ACEOF
9426	>	/* confdefs.h.  */
9427	>	_ACEOF
9428	>	cat confdefs.h >>conftest.$ac_ext
9429	>	cat >>conftest.$ac_ext <<_ACEOF
9430	>	/* end confdefs.h.  */
9431	>
9432	>	double strtod ();
9433	>	int
9434	>	main()
9435	>	{
9436	>	{
9437	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438	>	char *string = " +69";
9439	>	char *term;
9440	>	double value;
9441	>	value = strtod (string, &term);
9442	>	if (value != 69 || term != (string + 4))
9443	>	exit (1);
9444	>	}
9445	>
9446	>	{
9447	>	/* Under Solaris 2.4, strtod returns the wrong value for the
9448	>	terminating character under some conditions.  */
9449	>	char *string = "NaN";
9450	>	char *term;
9451	>	strtod (string, &term);
9452	>	if (term != string && *(term - 1) == 0)
9453	>	exit (1);
9454	>	}
9455	>	exit (0);
9456	>	}
9457	>
9458	>	_ACEOF
9459	>	rm -f conftest$ac_exeext
9460	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461	>	(eval $ac_link) 2>&5
9462	>	ac_status=$?
9463	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466	>	(eval $ac_try) 2>&5
9467	>	ac_status=$?
9468	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469	>	(exit $ac_status); }; }; then
9470	>	ac_cv_func_strtod=yes
9471	>	else
9472	>	echo "$as_me: program exited with status $ac_status" >&5
9473	>	echo "$as_me: failed program was:" >&5
9474	>	sed 's/^/| /' conftest.$ac_ext >&5
9475	>
9476	>	( exit $ac_status )
9477	>	ac_cv_func_strtod=no
9478	>	fi
9479	>	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480	>	fi
9481	>	fi
9482	>	echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484	>	if test $ac_cv_func_strtod = no; then
9485	>	case $LIBOBJS in
9486	>	"strtod.$ac_objext"   | \
9487	>	*" strtod.$ac_objext"   | \
9488	>	"strtod.$ac_objext "* | \
9489	>	*" strtod.$ac_objext "* ) ;;
9490	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491	>	esac
9492	>
9493	>	echo "$as_me:$LINENO: checking for pow" >&5
9494	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495	>	if test "${ac_cv_func_pow+set}" = set; then
9496	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9497	>	else
9498	>	cat >conftest.$ac_ext <<_ACEOF
9499	>	/* confdefs.h.  */
9500	>	_ACEOF
9501	>	cat confdefs.h >>conftest.$ac_ext
9502	>	cat >>conftest.$ac_ext <<_ACEOF
9503	>	/* end confdefs.h.  */
9504	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506	>	#define pow innocuous_pow
9507	>
9508	>	/* System header to define __stub macros and hopefully few prototypes,
9509	>	which can conflict with char pow (); below.
9510	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511	>	<limits.h> exists even on freestanding compilers.  */
9512	>
9513	>	#ifdef __STDC__
9514	>	# include <limits.h>
9515	>	#else
9516	>	# include <assert.h>
9517	>	#endif
9518	>
9519	>	#undef pow
9520	>
9521	>	/* Override any gcc2 internal prototype to avoid an error.  */
9522	>	#ifdef __cplusplus
9523	>	extern "C"
9524	>	{
9525	>	#endif
9526	>	/* We use char because int might match the return type of a gcc2
9527	>	builtin and then its argument prototype would still apply.  */
9528	>	char pow ();
9529	>	/* The GNU C library defines this for functions which it implements
9530	>	to always fail with ENOSYS.  Some functions are actually named
9531	>	something starting with __ and the normal name is an alias.  */
9532	>	#if defined (__stub_pow) || defined (__stub___pow)
9533	>	choke me
9534	>	#else
9535	>	char (*f) () = pow;
9536	>	#endif
9537	>	#ifdef __cplusplus
9538	>	}
9539	>	#endif
9540	>
9541	>	#ifdef FC_DUMMY_MAIN
9542	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9543	>	#  ifdef __cplusplus
9544	>	extern "C"
9545	>	#  endif
9546	>	int FC_DUMMY_MAIN() { return 1; }
9547	>	#endif
9548	>	#endif
9549	>	int
9550	>	main ()
9551	>	{
9552	>	return f != pow;
9553	>	;
9554	>	return 0;
9555	>	}
9556	>	_ACEOF
9557	>	rm -f conftest.$ac_objext conftest$ac_exeext
9558	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559	>	(eval $ac_link) 2>conftest.er1
9560	>	ac_status=$?
9561	>	grep -v '^ *+' conftest.er1 >conftest.err
9562	>	rm -f conftest.er1
9563	>	cat conftest.err >&5
9564	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565	>	(exit $ac_status); } &&
9566	>	{ ac_try='test -z "$ac_c_werror_flag"
9567	>	|| test ! -s conftest.err'
9568	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569	>	(eval $ac_try) 2>&5
9570	>	ac_status=$?
9571	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572	>	(exit $ac_status); }; } &&
9573	>	{ ac_try='test -s conftest$ac_exeext'
9574	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575	>	(eval $ac_try) 2>&5
9576	>	ac_status=$?
9577	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578	>	(exit $ac_status); }; }; then
9579	>	ac_cv_func_pow=yes
9580	>	else
9581	>	echo "$as_me: failed program was:" >&5
9582	>	sed 's/^/| /' conftest.$ac_ext >&5
9583	>
9584	>	ac_cv_func_pow=no
9585	>	fi
9586	>	rm -f conftest.err conftest.$ac_objext \
9587	>	conftest$ac_exeext conftest.$ac_ext
9588	>	fi
9589	>	echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590	>	echo "${ECHO_T}$ac_cv_func_pow" >&6
9591	>
9592	>	if test $ac_cv_func_pow = no; then
9593	>	echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595	>	if test "${ac_cv_lib_m_pow+set}" = set; then
9596	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9597	>	else
9598	>	ac_check_lib_save_LIBS=$LIBS
9599	>	LIBS="-lm  $LIBS"
9600	>	cat >conftest.$ac_ext <<_ACEOF
9601	>	/* confdefs.h.  */
9602	>	_ACEOF
9603	>	cat confdefs.h >>conftest.$ac_ext
9604	>	cat >>conftest.$ac_ext <<_ACEOF
9605	>	/* end confdefs.h.  */
9606	>
9607	>	/* Override any gcc2 internal prototype to avoid an error.  */
9608	>	#ifdef __cplusplus
9609	>	extern "C"
9610	>	#endif
9611	>	/* We use char because int might match the return type of a gcc2
9612	>	builtin and then its argument prototype would still apply.  */
9613	>	char pow ();
9614	>	#ifdef FC_DUMMY_MAIN
9615	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9616	>	#  ifdef __cplusplus
9617	>	extern "C"
9618	>	#  endif
9619	>	int FC_DUMMY_MAIN() { return 1; }
9620	>	#endif
9621	>	#endif
9622	>	int
9623	>	main ()
9624	>	{
9625	>	pow ();
9626	>	;
9627	>	return 0;
9628	>	}
9629	>	_ACEOF
9630	>	rm -f conftest.$ac_objext conftest$ac_exeext
9631	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632	>	(eval $ac_link) 2>conftest.er1
9633	>	ac_status=$?
9634	>	grep -v '^ *+' conftest.er1 >conftest.err
9635	>	rm -f conftest.er1
9636	>	cat conftest.err >&5
9637	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638	>	(exit $ac_status); } &&
9639	>	{ ac_try='test -z "$ac_c_werror_flag"
9640	>	|| test ! -s conftest.err'
9641	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642	>	(eval $ac_try) 2>&5
9643	>	ac_status=$?
9644	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645	>	(exit $ac_status); }; } &&
9646	>	{ ac_try='test -s conftest$ac_exeext'
9647	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648	>	(eval $ac_try) 2>&5
9649	>	ac_status=$?
9650	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651	>	(exit $ac_status); }; }; then
9652	>	ac_cv_lib_m_pow=yes
9653	>	else
9654	>	echo "$as_me: failed program was:" >&5
9655	>	sed 's/^/| /' conftest.$ac_ext >&5
9656	>
9657	>	ac_cv_lib_m_pow=no
9658	>	fi
9659	>	rm -f conftest.err conftest.$ac_objext \
9660	>	conftest$ac_exeext conftest.$ac_ext
9661	>	LIBS=$ac_check_lib_save_LIBS
9662	>	fi
9663	>	echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665	>	if test $ac_cv_lib_m_pow = yes; then
9666	>	POW_LIB=-lm
9667	>	else
9668	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670	>	fi
9671	>
9672	>	fi
9673	>
9674	>	fi
9675	>
9676	>
9677	>
9678	>
9679	>
9680	>
9681	>
9682	>
9683	>
9684	>
9685	>
9686	>
9687	>
9688	>
9689	>
9690	>
9691	>
9692	>
9693	>
9694	>
9695	>
9696	>
9697	>
9698	>
9699	>
9700	>
9701	>
9702	>
9703	>	for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9704	>	do
9705	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
9707	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
9709	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9710	>	else
9711	>	cat >conftest.$ac_ext <<_ACEOF
9712	>	/* confdefs.h.  */
9713	>	_ACEOF
9714	>	cat confdefs.h >>conftest.$ac_ext
9715	>	cat >>conftest.$ac_ext <<_ACEOF
9716	>	/* end confdefs.h.  */
9717	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719	>	#define $ac_func innocuous_$ac_func
9720	>
9721	>	/* System header to define __stub macros and hopefully few prototypes,
9722	>	which can conflict with char $ac_func (); below.
9723	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724	>	<limits.h> exists even on freestanding compilers.  */
9725	>
9726	>	#ifdef __STDC__
9727	>	# include <limits.h>
9728	>	#else
9729	>	# include <assert.h>
9730	>	#endif
9731	>
9732	>	#undef $ac_func
9733	>
9734	>	/* Override any gcc2 internal prototype to avoid an error.  */
9735	>	#ifdef __cplusplus
9736	>	extern "C"
9737	>	{
9738	>	#endif
9739	>	/* We use char because int might match the return type of a gcc2
9740	>	builtin and then its argument prototype would still apply.  */
9741	>	char $ac_func ();
9742	>	/* The GNU C library defines this for functions which it implements
9743	>	to always fail with ENOSYS.  Some functions are actually named
9744	>	something starting with __ and the normal name is an alias.  */
9745	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746	>	choke me
9747	>	#else
9748	>	char (*f) () = $ac_func;
9749	>	#endif
9750	>	#ifdef __cplusplus
9751	>	}
9752	>	#endif
9753	>
9754	>	#ifdef FC_DUMMY_MAIN
9755	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9756	>	#  ifdef __cplusplus
9757	>	extern "C"
9758	>	#  endif
9759	>	int FC_DUMMY_MAIN() { return 1; }
9760	>	#endif
9761	>	#endif
9762	>	int
9763	>	main ()
9764	>	{
9765	>	return f != $ac_func;
9766	>	;
9767	>	return 0;
9768	>	}
9769	>	_ACEOF
9770	>	rm -f conftest.$ac_objext conftest$ac_exeext
9771	>	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772	>	(eval $ac_link) 2>conftest.er1
9773	>	ac_status=$?
9774	>	grep -v '^ *+' conftest.er1 >conftest.err
9775	>	rm -f conftest.er1
9776	>	cat conftest.err >&5
9777	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778	>	(exit $ac_status); } &&
9779	>	{ ac_try='test -z "$ac_c_werror_flag"
9780	>	|| test ! -s conftest.err'
9781	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782	>	(eval $ac_try) 2>&5
9783	>	ac_status=$?
9784	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785	>	(exit $ac_status); }; } &&
9786	>	{ ac_try='test -s conftest$ac_exeext'
9787	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788	>	(eval $ac_try) 2>&5
9789	>	ac_status=$?
9790	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791	>	(exit $ac_status); }; }; then
9792	>	eval "$as_ac_var=yes"
9793	>	else
9794	>	echo "$as_me: failed program was:" >&5
9795	>	sed 's/^/| /' conftest.$ac_ext >&5
9796	>
9797	>	eval "$as_ac_var=no"
9798	>	fi
9799	>	rm -f conftest.err conftest.$ac_objext \
9800	>	conftest$ac_exeext conftest.$ac_ext
9801	>	fi
9802	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803	>	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
9805	>	cat >>confdefs.h <<_ACEOF
9806	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807	>	_ACEOF
9808	>
9809	>	fi
9810	>	done
9811	>
9812	>
9813	>	# special check for _system_configuration because AIX <4.3.2 do not
9814	>	# contain the `physmem' member.
9815	>	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817	>	cat >conftest.$ac_ext <<_ACEOF
9818	>	/* confdefs.h.  */
9819	>	_ACEOF
9820	>	cat confdefs.h >>conftest.$ac_ext
9821	>	cat >>conftest.$ac_ext <<_ACEOF
9822	>	/* end confdefs.h.  */
9823	>	#include <sys/systemcfg.h>
9824	>	#ifdef FC_DUMMY_MAIN
9825	>	#ifndef FC_DUMMY_MAIN_EQ_F77
9826	>	#  ifdef __cplusplus
9827	>	extern "C"
9828	>	#  endif
9829	>	int FC_DUMMY_MAIN() { return 1; }
9830	>	#endif
9831	>	#endif
9832	>	int
9833	>	main ()
9834	>	{
9835	>	double x = _system_configuration.physmem;
9836	>	;
9837	>	return 0;
9838	>	}
9839	>	_ACEOF
9840	>	rm -f conftest.$ac_objext
9841	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842	>	(eval $ac_compile) 2>conftest.er1
9843	>	ac_status=$?
9844	>	grep -v '^ *+' conftest.er1 >conftest.err
9845	>	rm -f conftest.er1
9846	>	cat conftest.err >&5
9847	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848	>	(exit $ac_status); } &&
9849	>	{ ac_try='test -z "$ac_c_werror_flag"
9850	>	|| test ! -s conftest.err'
9851	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852	>	(eval $ac_try) 2>&5
9853	>	ac_status=$?
9854	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855	>	(exit $ac_status); }; } &&
9856	>	{ ac_try='test -s conftest.$ac_objext'
9857	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858	>	(eval $ac_try) 2>&5
9859	>	ac_status=$?
9860	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861	>	(exit $ac_status); }; }; then
9862	>	echo "$as_me:$LINENO: result: yes" >&5
9863	>	echo "${ECHO_T}yes" >&6
9864	>
9865	>	cat >>confdefs.h <<\_ACEOF
9866	>	#define HAVE__SYSTEM_CONFIGURATION 1
9867	>	_ACEOF
9868	>
9869	>	else
9870	>	echo "$as_me: failed program was:" >&5
9871	>	sed 's/^/| /' conftest.$ac_ext >&5
9872	>
9873	>	echo "$as_me:$LINENO: result: no" >&5
9874	>	echo "${ECHO_T}no" >&6
9875	>	fi
9876	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877	>
9878	>	# clean out junk possibly left behind by a previous configuration
9879	>	rm -f src/getopt.h
9880	>	# Check for getopt_long support
9881	>
9882	>	for ac_header in getopt.h
9883	>	do
9884	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
9887	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889	>	echo $ECHO_N "(cached) $ECHO_C" >&6
9890	>	fi
9891	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893	>	else
9894	>	# Is the header compilable?
9895	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897	>	cat >conftest.$ac_ext <<_ACEOF
9898	>	/* confdefs.h.  */
9899	>	_ACEOF
9900	>	cat confdefs.h >>conftest.$ac_ext
9901	>	cat >>conftest.$ac_ext <<_ACEOF
9902	>	/* end confdefs.h.  */
9903	>	$ac_includes_default
9904	>	#include <$ac_header>
9905	>	_ACEOF
9906	>	rm -f conftest.$ac_objext
9907	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908	>	(eval $ac_compile) 2>conftest.er1
9909	>	ac_status=$?
9910	>	grep -v '^ *+' conftest.er1 >conftest.err
9911	>	rm -f conftest.er1
9912	>	cat conftest.err >&5
9913	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914	>	(exit $ac_status); } &&
9915	>	{ ac_try='test -z "$ac_c_werror_flag"
9916	>	|| test ! -s conftest.err'
9917	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918	>	(eval $ac_try) 2>&5
9919	>	ac_status=$?
9920	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921	>	(exit $ac_status); }; } &&
9922	>	{ ac_try='test -s conftest.$ac_objext'
9923	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924	>	(eval $ac_try) 2>&5
9925	>	ac_status=$?
9926	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927	>	(exit $ac_status); }; }; then
9928	>	ac_header_compiler=yes
9929	>	else
9930	>	echo "$as_me: failed program was:" >&5
9931	>	sed 's/^/| /' conftest.$ac_ext >&5
9932	>
9933	>	ac_header_compiler=no
9934	>	fi
9935	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937	>	echo "${ECHO_T}$ac_header_compiler" >&6
9938	>
9939	>	# Is the header present?
9940	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942	>	cat >conftest.$ac_ext <<_ACEOF
9943	>	/* confdefs.h.  */
9944	>	_ACEOF
9945	>	cat confdefs.h >>conftest.$ac_ext
9946	>	cat >>conftest.$ac_ext <<_ACEOF
9947	>	/* end confdefs.h.  */
9948	>	#include <$ac_header>
9949	>	_ACEOF
9950	>	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951	>	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952	>	ac_status=$?
9953	>	grep -v '^ *+' conftest.er1 >conftest.err
9954	>	rm -f conftest.er1
9955	>	cat conftest.err >&5
9956	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957	>	(exit $ac_status); } >/dev/null; then
9958	>	if test -s conftest.err; then
9959	>	ac_cpp_err=$ac_c_preproc_warn_flag
9960	>	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961	>	else
9962	>	ac_cpp_err=
9963	>	fi
9964	>	else
9965	>	ac_cpp_err=yes
9966	>	fi
9967	>	if test -z "$ac_cpp_err"; then
9968	>	ac_header_preproc=yes
9969	>	else
9970	>	echo "$as_me: failed program was:" >&5
9971	>	sed 's/^/| /' conftest.$ac_ext >&5
9972	>
9973	>	ac_header_preproc=no
9974	>	fi
9975	>	rm -f conftest.err conftest.$ac_ext
9976	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977	>	echo "${ECHO_T}$ac_header_preproc" >&6
9978	>
9979	>	# So?  What about this header?
9980	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981	>	yes:no: )
9982	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986	>	ac_header_preproc=yes
9987	>	;;
9988	>	no:yes:* )
9989	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001	>	(
10002	>	cat <<\_ASBOX
10003	>	## ------------------------------ ##
10004	>	## Report this to gezelter@nd.edu ##
10005	>	## ------------------------------ ##
10006	>	_ASBOX
10007	>	) |
10008	>	sed "s/^/$as_me: WARNING:     /" >&2
10009	>	;;
10010	>	esac
10011	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10012	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10015	>	else
10016	>	eval "$as_ac_Header=\$ac_header_preproc"
10017	>	fi
10018	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020	>
10021	>	fi
10022	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023	>	cat >>confdefs.h <<_ACEOF
10024	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025	>	_ACEOF
10026	>
10027	>	fi
10028	>
10029	>	done
10030	>
10031	>
10032	>	for ac_func in getopt_long
10033	>	do
10034	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035	>	echo "$as_me:$LINENO: checking for $ac_func" >&5
10036	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037	>	if eval "test \"\${$as_ac_var+set}\" = set"; then
10038	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10039	>	else
10040	>	cat >conftest.$ac_ext <<_ACEOF
10041	>	/* confdefs.h.  */
10042	>	_ACEOF
10043	>	cat confdefs.h >>conftest.$ac_ext
10044	>	cat >>conftest.$ac_ext <<_ACEOF
10045	>	/* end confdefs.h.  */
10046	>	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047	>	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048	>	#define $ac_func innocuous_$ac_func
10049	>
10050	>	/* System header to define __stub macros and hopefully few prototypes,
10051	>	which can conflict with char $ac_func (); below.
10052	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053	>	<limits.h> exists even on freestanding compilers.  */
10054	>
10055	>	#ifdef __STDC__
10056	>	# include <limits.h>
10057	>	#else
10058	>	# include <assert.h>
10059	>	#endif
10060	>
10061	>	#undef $ac_func
10062	>
10063	>	/* Override any gcc2 internal prototype to avoid an error.  */
10064	>	#ifdef __cplusplus
10065	>	extern "C"
10066	>	{
10067	>	#endif
10068	>	/* We use char because int might match the return type of a gcc2
10069	>	builtin and then its argument prototype would still apply.  */
10070	>	char $ac_func ();
10071	>	/* The GNU C library defines this for functions which it implements
10072	>	to always fail with ENOSYS.  Some functions are actually named
10073	>	something starting with __ and the normal name is an alias.  */
10074	>	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075	>	choke me
10076	>	#else
10077	>	char (*f) () = $ac_func;
10078	>	#endif
10079	>	#ifdef __cplusplus
10080	>	}
10081	>	#endif
10082	>
10083	>	#ifdef FC_DUMMY_MAIN
10084	>	#ifndef FC_DUMMY_MAIN_EQ_F77
10085	>	#  ifdef __cplusplus
10086	>	extern "C"
10087	>	#  endif
10088	>	int FC_DUMMY_MAIN() { return 1; }
10089	>	#endif
10090		#endif
3847	–	/* We use char because int might match the return type of a gcc2
3848	–	builtin and then its argument prototype would still apply.  */
3849	–	char $ac_func ();
10091		int
10092		main ()
10093		{
10094	<	$ac_func ();
10094	>	return f != $ac_func;
10095		;
10096		return 0;
10097		}
#	Line 3877 | Line 10118 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10118		ac_status=$?
10119		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120		(exit $ac_status); }; }; then
10121	<	ac_success=yes; break 2
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	<	done
10131	<	done
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	<	if test "$ac_success" = "yes"; then
10139	<	case $ac_foobar in
10140	<	foobar)
10141	<	ac_case=lower
10142	<	ac_foo_bar=foo_bar
10143	<	;;
10144	<	FOOBAR)
10145	<	ac_case=upper
10146	<	ac_foo_bar=FOO_BAR
10147	<	;;
3901	<	esac
3902	<
3903	<	ac_success_extra=no
3904	<	for ac_extra in "" "_"; do
3905	<	ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3906	<
3907	<	cat >conftest.$ac_ext <<_ACEOF
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
#	Line 3917 | Line 10157 | 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 $ac_func ();
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	<	$ac_func ();
10172	>	getopt_long ();
10173		;
10174		return 0;
10175		}
#	Line 3948 | Line 10196 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10196		ac_status=$?
10197		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198		(exit $ac_status); }; }; then
10199	<	ac_success_extra=yes; break
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	<	done
3960	<
3961	<	if test "$ac_success_extra" = "yes"; then
3962	<	ac_cv_f90_mangling="$ac_case case"
3963	<	if test -z "$ac_underscore"; then
3964	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
3965	<	else
3966	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3967	<
3968	<	fi
3969	<	if test -z "$ac_extra"; then
3970	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3971	<	else
3972	<	ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3973	<	fi
3974	<	else
3975	<	ac_cv_f90_mangling="unknown"
3976	<	fi
3977	<	else
3978	<	ac_cv_f90_mangling="unknown"
3979	<
3980	<	fi
3981	<
3982	<	LIBS=$ac_save_LIBS
3983	<	ac_ext=f90
3984	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3985	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3986	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3987	<	rm -f cf90_test* conftest*
3988	<	else
3989	<	echo "$as_me: failed program was:" >&5
3990	<	sed 's/^/| /' conftest.$ac_ext >&5
3991	<
10208	>	LIBS=$ac_check_lib_save_LIBS
10209		fi
10210	<	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10211	<	ac_ext=f90
10212	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
10213	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10214	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3998	<
3999	<	fi
4000	<	echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4001	<	echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4002	<
4003	<
4004	<
4005	<	case $ac_cv_f90_mangling in
4006	<	"lower case, no underscore, no extra underscore")
4007	<	cat >>confdefs.h <<\_ACEOF
4008	<	#define F90_FUNC(name,NAME) name
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	<	cat >>confdefs.h <<\_ACEOF
10218	<	#define F90_FUNC_(name,NAME) name
10219	<	_ACEOF
10220	<	;;
10221	<	"lower case, no underscore, extra underscore")
10222	<	cat >>confdefs.h <<\_ACEOF
10223	<	#define F90_FUNC(name,NAME) name
10224	<	_ACEOF
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	<	cat >>confdefs.h <<\_ACEOF
10228	<	#define F90_FUNC_(name,NAME) name ## _
10229	<	_ACEOF
10230	<	;;
10231	<	"lower case, underscore, no extra underscore")
10232	<	cat >>confdefs.h <<\_ACEOF
4026	<	#define F90_FUNC(name,NAME) name ## _
4027	<	_ACEOF
4028	<
4029	<	cat >>confdefs.h <<\_ACEOF
4030	<	#define F90_FUNC_(name,NAME) name ## _
4031	<	_ACEOF
4032	<	;;
4033	<	"lower case, underscore, extra underscore")
4034	<	cat >>confdefs.h <<\_ACEOF
4035	<	#define F90_FUNC(name,NAME) name ## _
4036	<	_ACEOF
4037	<
4038	<	cat >>confdefs.h <<\_ACEOF
4039	<	#define F90_FUNC_(name,NAME) name ## __
4040	<	_ACEOF
4041	<	;;
4042	<	"upper case, no underscore, no extra underscore")
4043	<	cat >>confdefs.h <<\_ACEOF
4044	<	#define F90_FUNC(name,NAME) NAME
4045	<	_ACEOF
4046	<
4047	<	cat >>confdefs.h <<\_ACEOF
4048	<	#define F90_FUNC_(name,NAME) NAME
4049	<	_ACEOF
4050	<	;;
4051	<	"upper case, no underscore, extra underscore")
4052	<	cat >>confdefs.h <<\_ACEOF
4053	<	#define F90_FUNC(name,NAME) NAME
4054	<	_ACEOF
4055	<
4056	<	cat >>confdefs.h <<\_ACEOF
4057	<	#define F90_FUNC_(name,NAME) NAME ## _
4058	<	_ACEOF
4059	<	;;
4060	<	"upper case, underscore, no extra underscore")
4061	<	cat >>confdefs.h <<\_ACEOF
4062	<	#define F90_FUNC(name,NAME) NAME ## _
4063	<	_ACEOF
4064	<
4065	<	cat >>confdefs.h <<\_ACEOF
4066	<	#define F90_FUNC_(name,NAME) NAME ## _
4067	<	_ACEOF
4068	<	;;
4069	<	"upper case, underscore, extra underscore")
4070	<	cat >>confdefs.h <<\_ACEOF
4071	<	#define F90_FUNC(name,NAME) NAME ## _
4072	<	_ACEOF
4073	<
4074	<	cat >>confdefs.h <<\_ACEOF
4075	<	#define F90_FUNC_(name,NAME) NAME ## __
4076	<	_ACEOF
4077	<	;;
4078	<	*)
4079	<	{ echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4080	<	echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4081	<	;;
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
4085	–
4086	–
4087	–
4088	–	echo "$as_me:$LINENO: checking for module suffix" >&5
4089	–	echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4090	–	rm -f conftest*
4091	–	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4092	–	rm -f work*
4093	–	cat >conftest.f90 <<EOF
4094	–	module conftest
4095	–	integer n
4096	–	parameter (n=1)
4097	–	end module conftest
4098	–	EOF
4099	–	# SGI and absoft compilers generates module name in upper case!
4100	–	testname="conftest"
4101	–	modcase="lower"
4102	–	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4103	–	MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4104	–	MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4105	–	if test -z "$MOD" ; then
4106	–	MOD=`ls CONFTEST* 2>/dev/null \
4107	–	| grep -v CONFTEST.f | grep -v CONFTEST.o`
4108	–	MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4109	–	if test -n "$MOD" ; then
4110	–	testname="CONFTEST"
4111	–	modcase="upper"
4112	–	fi
4113	–	fi
4114	–	if test -z "$MOD" ; then
4115	–	echo "$as_me:$LINENO: result: unknown" >&5
4116	–	echo "${ECHO_T}unknown" >&6
4117	–	# Use mod if we can't figure it out
4118	–	MOD="mod"
4119	–	else
4120	–	echo "$as_me:$LINENO: result: $MOD" >&5
4121	–	echo "${ECHO_T}$MOD" >&6
4122	–	fi
4123	–	if test -s work.pcl ; then
4124	–	{ echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4125	–	echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4126	–	fi
4127	–	else
4128	–	echo "$as_me:$LINENO: result: unknown" >&5
4129	–	echo "${ECHO_T}unknown" >&6
10237		fi
10238
10239	<
10240	<
4134	<
4135	<
4136	<	# Check for module include path (some use -I, some (Solaris) use -M, some
4137	<	# (absoft) use -p).
4138	<	# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4139	<	# specified, work.pcl and work.pc are created.  However, if you specify
4140	<	# a file, it must contain a the name of a file ending in .pc .  Ugh!
4141	<	# Use the module made above
4142	<	echo "$as_me:$LINENO: checking for module directory path flag" >&5
4143	<	echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4144	<	rm -f conftest*
4145	<	# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4146	<	rm -f work*
4147	<	cat >conftest.f90 <<EOF
4148	<	module conftest
4149	<	integer n
4150	<	parameter (n=1)
4151	<	end module conftest
4152	<	EOF
4153	<	# SGI and absoft compilers generates module name in upper case!
4154	<	testname="conftest"
4155	<	if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4156	<	mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4157	<	mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4158	<	if test -n "$mod" ; then
4159	<	testname="CONFTEST"
4160	<	fi
4161	<	madedir=0
4162	<	if test ! -d conf ; then mkdir conf ; madedir=1; fi
4163	<	cp $testname.$MOD conf
4164	<	rm -f conftest* CONFTEST*
4165	<	cat >conftest1.f90 <<EOF
4166	<	program main
4167	<	use conftest
4168	<	print *, n
4169	<	end
4170	<	EOF
4171	<	F90_WORK_FILES_ARG=""
4172	<	F90MODINCSPEC=""
4173	<	if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4174	<	MODDIRFLAG="-I"
4175	<	F90MODINCSPEC="-I<dir>"
4176	<	echo "$as_me:$LINENO: result: -I" >&5
4177	<	echo "${ECHO_T}-I" >&6
4178	<	elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4179	<	MODDIRFLAG="-M"
4180	<	F90MODINCSPEC="-M<dir>"
4181	<	echo "$as_me:$LINENO: result: -M" >&5
4182	<	echo "${ECHO_T}-M" >&6
4183	<	elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4184	<	MODDIRFLAG="-p"
4185	<	F90MODINCSPEC="-p<dir>"
4186	<	echo "$as_me:$LINENO: result: -p" >&5
4187	<	echo "${ECHO_T}-p" >&6
4188	<	elif test -s work.pc ; then
4189	<	cp work.pc conf/mpimod.pc
4190	<	echo "mpimod.pc" > conf/mpimod.pcl
4191	<	echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4192	<	if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4193	<	MODDIRFLAG='-cl,mpimod.pcl'
4194	<	echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4195	<	echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4196	<	F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4197	<	F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
10239	>	fi
10240	>	done
10241
4199	–	else
4200	–	# The version of the Intel compiler that I have refuses to let
4201	–	# you put the "work catalog" list anywhere but the current
4202	–	# directory. For example, you cannot in
4203	–	:
4204	–	fi
4205	–	fi
4206	–	if test -z "MODDIRFLAG" ; then
4207	–	echo "$as_me:$LINENO: result: unknown" >&5
4208	–	echo "${ECHO_T}unknown" >&6
4209	–	fi
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
4212	–	rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4213	–	if test $madedir = 1 ; then rmdir conf ; fi
4214	–	fi
10249
10250	<
10251	<	echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
10252	<	echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4219	<	if test "${ac_cv_f90_module_names+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
10254		else
4222	–	ac_ext=f90
4223	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4224	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4225	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10255
10256	<	# carry out the test in a new directory, so that we don't miss anything
10257	<	mkdir conftest
10258	<	cd conftest
10259	<	cat >conftest.$ac_ext <<_ACEOF
10260	<	MODULE Bar
10261	<	END MODULE Bar
10256	>
10257	>	ac_ext=cc
10258	>	ac_cpp='$CXXCPP $CPPFLAGS'
10259	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262	>
10263	>	cat >conftest.$ac_ext <<_ACEOF
10264	>	/* confdefs.h.  */
10265		_ACEOF
10266	+	cat confdefs.h >>conftest.$ac_ext
10267	+	cat >>conftest.$ac_ext <<_ACEOF
10268	+	/* end confdefs.h.  */
10269	+	namespace Outer { namespace Inner { int i = 0; }}
10270	+	#ifdef FC_DUMMY_MAIN
10271	+	#ifndef FC_DUMMY_MAIN_EQ_F77
10272	+	#  ifdef __cplusplus
10273	+	extern "C"
10274	+	#  endif
10275	+	int FC_DUMMY_MAIN() { return 1; }
10276	+	#endif
10277	+	#endif
10278	+	int
10279	+	main ()
10280	+	{
10281	+	using namespace Outer::Inner; return i;
10282	+	;
10283	+	return 0;
10284	+	}
10285	+	_ACEOF
10286		rm -f conftest.$ac_objext
10287		if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10288		(eval $ac_compile) 2>conftest.er1
#	Line 4240 | 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_f90_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 4253 | 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_cv_f90_module_names=
4257	<	ac_file_list=*
4258	<	for ac_file in $ac_file_list; do
4259	<	case $ac_file in
4260	<	# don't care for original source and object files
4261	<	conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4262	<	:
4263	<	;;
4264	<	# look for new files derived from the file name
4265	<	*conftest*)
4266	<	ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4267	<	ac_exists=false
4268	<	for ac_i in $ac_cv_f90_module_names; do
4269	<	if test x"$ac_pat" = x"$ac_i"; then
4270	<	ac_exists=true
4271	<	break
4272	<	fi
4273	<	done
4274	<
4275	<	if test x"$ac_exists" = xtrue; then
4276	<	:
10308	>	ac_cv_cxx_namespaces=yes
10309		else
4278	–	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4279	–	fi
4280	–
4281	–	;;
4282	–	# look for new files derived from the module name,
4283	–	# with different case translation schemes
4284	–	*Bar*)
4285	–	ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4286	–	ac_exists=false
4287	–	for ac_i in $ac_cv_f90_module_names; do
4288	–	if test x"$ac_pat" = x"$ac_i"; then
4289	–	ac_exists=true
4290	–	break
4291	–	fi
4292	–	done
4293	–
4294	–	if test x"$ac_exists" = xtrue; then
4295	–	:
4296	–	else
4297	–	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4298	–	fi
4299	–
4300	–	;;
4301	–	*bar*)
4302	–	ac_pat=`echo $ac_file | sed s/bar/%module%/`
4303	–	ac_exists=false
4304	–	for ac_i in $ac_cv_f90_module_names; do
4305	–	if test x"$ac_pat" = x"$ac_i"; then
4306	–	ac_exists=true
4307	–	break
4308	–	fi
4309	–	done
4310	–
4311	–	if test x"$ac_exists" = xtrue; then
4312	–	:
4313	–	else
4314	–	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4315	–	fi
4316	–
4317	–	;;
4318	–	*BAR*)
4319	–	ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4320	–	ac_exists=false
4321	–	for ac_i in $ac_cv_f90_module_names; do
4322	–	if test x"$ac_pat" = x"$ac_i"; then
4323	–	ac_exists=true
4324	–	break
4325	–	fi
4326	–	done
4327	–
4328	–	if test x"$ac_exists" = xtrue; then
4329	–	:
4330	–	else
4331	–	ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4332	–	fi
4333	–
4334	–	;;
4335	–	# Other files - we have no idea how they are generated
4336	–	*)
4337	–	{ echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4338	–	echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4339	–	;;
4340	–	esac
4341	–	done
4342	–	if test "x$ac_cv_f90_module_names" = "x"; then
4343	–	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4344	–	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4345	–	fi
4346	–
4347	–	else
10310		echo "$as_me: failed program was:" >&5
10311		sed 's/^/| /' conftest.$ac_ext >&5
10312
10313	<	ac_cv_f90_module_names=
4352	<	{ echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4353	<	echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
10313	>	ac_cv_cxx_namespaces=no
10314		fi
10315		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316	<	cd ..
10317	<	# cleanup
10318	<	rm -rf conftest
10319	<	ac_ext=f90
10320	<	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4361	<	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4362	<	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
4364	–	fi
4365	–	echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4366	–	echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
10322
4368	–	# We now generate a shell script that will help us to figure out the correct
4369	–	# module file names, using the value of ac_cv_f90_module_names
4370	–
4371	–	echo "Generating shell script modnam"
4372	–
4373	–	cat > scripts/modnam << EOF
4374	–	#! /bin/sh
4375	–	# This script is auto-generated by configure
4376	–	#
4377	–	usage="\\
4378	–	Usage: \$0 [FILES]
4379	–
4380	–	[FILES] are Fortran 90 source files.
4381	–	The output is a list of module file names that the Fortran 90 compiler
4382	–	generates when compiling [FILES]."
4383	–
4384	–	list=
4385	–	empty=
4386	–
4387	–	if test \$# -eq 0; then
4388	–	echo "\$usage"; exit 0
10323		fi
10324	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325	+	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326	+	if test "$ac_cv_cxx_namespaces" = yes; then
10327
10328	<	while test \$# != 0; do
10328	>	cat >>confdefs.h <<\_ACEOF
10329	>	#define HAVE_NAMESPACES
10330	>	_ACEOF
10331
4393	–	file=\$1
4394	–	shift
4395	–
4396	–	# strip suffix
4397	–	base=\`echo \$file | sed 's/[.][^.]*$//'\`
4398	–
4399	–	test ! -f \$file && continue
4400	–
4401	–	# Look for module definitions and transform them to upper / lower case
4402	–	mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4403	–	upper=\`echo \$mods | tr a-z A-Z\`
4404	–	lower=\`echo \$mods | tr A-Z a-z\`
4405	–
4406	–	# Here, the patterns for generating module file names were inserted by configure
4407	–	for trans in $ac_cv_f90_module_names; do
4408	–
4409	–	pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4410	–	var=empty
4411	–	case \$pat in
4412	–	%MODULE%)
4413	–	var=upper ;;
4414	–	%Module%)
4415	–	var=mods ;;
4416	–	%module%)
4417	–	var=lower ;;
4418	–	%FILE%)
4419	–	test -n "\$mods" && var=base ;;
4420	–	esac
4421	–	new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4422	–	list="\$list \$new"
4423	–	done
4424	–	done
4425	–
4426	–	echo \$list
4427	–	# end of configure-generated script
4428	–	EOF
4429	–	chmod 755 scripts/modnam
4430	–
4431	–	pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4432	–	F90_MODULE_NAMES=empty
4433	–	case $pat in
4434	–	%MODULE%)
4435	–	F90_MODULE_NAMES=UPPER ;;
4436	–	%Module%)
4437	–	F90_MODULE_NAMES=Mixed ;;
4438	–	%module%)
4439	–	F90_MODULE_NAMES=lower ;;
4440	–	*)
4441	–	F90_MODULE_NAMES=unknown ;;
4442	–	esac
4443	–
4444	–	ac_ext=c
4445	–	ac_cpp='$CPP $CPPFLAGS'
4446	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4447	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4448	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4449	–
4450	–
4451	–	ac_ext=c
4452	–	ac_cpp='$CPP $CPPFLAGS'
4453	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4454	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4455	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4456	–
4457	–	ac_ext=c
4458	–	ac_cpp='$CPP $CPPFLAGS'
4459	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4460	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4461	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4462	–	echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4463	–	echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4464	–	# On Suns, sometimes $CPP names a directory.
4465	–	if test -n "$CPP" && test -d "$CPP"; then
4466	–	CPP=
10332		fi
10333	<	if test -z "$CPP"; then
10334	<	if test "${ac_cv_prog_CPP+set}" = set; then
10333	>
10334	>	ac_ext=cc
10335	>	ac_cpp='$CXXCPP $CPPFLAGS'
10336	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339	>	echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340	>	echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341	>	if test -z "$CXXCPP"; then
10342	>	if test "${ac_cv_prog_CXXCPP+set}" = set; then
10343		echo $ECHO_N "(cached) $ECHO_C" >&6
10344		else
10345	<	# Double quotes because CPP needs to be expanded
10346	<	for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10345	>	# Double quotes because CXXCPP needs to be expanded
10346	>	for CXXCPP in "$CXX -E" "/lib/cpp"
10347		do
10348		ac_preproc_ok=false
10349	<	for ac_c_preproc_warn_flag in '' yes
10349	>	for ac_cxx_preproc_warn_flag in '' yes
10350		do
10351		# Use a header file that comes with gcc, so configuring glibc
10352		# with a fresh cross-compiler works.
#	Line 4503 | Line 10376 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10376		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377		(exit $ac_status); } >/dev/null; then
10378		if test -s conftest.err; then
10379	<	ac_cpp_err=$ac_c_preproc_warn_flag
10380	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10379	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10380	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381		else
10382		ac_cpp_err=
10383		fi
#	Line 4541 | Line 10414 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10414		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415		(exit $ac_status); } >/dev/null; then
10416		if test -s conftest.err; then
10417	<	ac_cpp_err=$ac_c_preproc_warn_flag
10418	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10417	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10418	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10419		else
10420		ac_cpp_err=
10421		fi
#	Line 4570 | Line 10443 | fi
10443		fi
10444
10445		done
10446	<	ac_cv_prog_CPP=$CPP
10446	>	ac_cv_prog_CXXCPP=$CXXCPP
10447
10448		fi
10449	<	CPP=$ac_cv_prog_CPP
10449	>	CXXCPP=$ac_cv_prog_CXXCPP
10450		else
10451	<	ac_cv_prog_CPP=$CPP
10451	>	ac_cv_prog_CXXCPP=$CXXCPP
10452		fi
10453	<	echo "$as_me:$LINENO: result: $CPP" >&5
10454	<	echo "${ECHO_T}$CPP" >&6
10453	>	echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454	>	echo "${ECHO_T}$CXXCPP" >&6
10455		ac_preproc_ok=false
10456	<	for ac_c_preproc_warn_flag in '' yes
10456	>	for ac_cxx_preproc_warn_flag in '' yes
10457		do
10458		# Use a header file that comes with gcc, so configuring glibc
10459		# with a fresh cross-compiler works.
#	Line 4600 | Line 10473 | cat >>conftest.$ac_ext <<_ACEOF
10473		# include <assert.h>
10474		#endif
10475		Syntax error
10476	+	_ACEOF
10477	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10478	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10479	+	ac_status=$?
10480	+	grep -v '^ *+' conftest.er1 >conftest.err
10481	+	rm -f conftest.er1
10482	+	cat conftest.err >&5
10483	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484	+	(exit $ac_status); } >/dev/null; then
10485	+	if test -s conftest.err; then
10486	+	ac_cpp_err=$ac_cxx_preproc_warn_flag
10487	+	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10488	+	else
10489	+	ac_cpp_err=
10490	+	fi
10491	+	else
10492	+	ac_cpp_err=yes
10493	+	fi
10494	+	if test -z "$ac_cpp_err"; then
10495	+	:
10496	+	else
10497	+	echo "$as_me: failed program was:" >&5
10498	+	sed 's/^/| /' conftest.$ac_ext >&5
10499	+
10500	+	# Broken: fails on valid input.
10501	+	continue
10502	+	fi
10503	+	rm -f conftest.err conftest.$ac_ext
10504	+
10505	+	# OK, works on sane cases.  Now check whether non-existent headers
10506	+	# can be detected and how.
10507	+	cat >conftest.$ac_ext <<_ACEOF
10508	+	/* confdefs.h.  */
10509	+	_ACEOF
10510	+	cat confdefs.h >>conftest.$ac_ext
10511	+	cat >>conftest.$ac_ext <<_ACEOF
10512	+	/* end confdefs.h.  */
10513	+	#include <ac_nonexistent.h>
10514	+	_ACEOF
10515	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10516	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10517	+	ac_status=$?
10518	+	grep -v '^ *+' conftest.er1 >conftest.err
10519	+	rm -f conftest.er1
10520	+	cat conftest.err >&5
10521	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522	+	(exit $ac_status); } >/dev/null; then
10523	+	if test -s conftest.err; then
10524	+	ac_cpp_err=$ac_cxx_preproc_warn_flag
10525	+	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10526	+	else
10527	+	ac_cpp_err=
10528	+	fi
10529	+	else
10530	+	ac_cpp_err=yes
10531	+	fi
10532	+	if test -z "$ac_cpp_err"; then
10533	+	# Broken: success on invalid input.
10534	+	continue
10535	+	else
10536	+	echo "$as_me: failed program was:" >&5
10537	+	sed 's/^/| /' conftest.$ac_ext >&5
10538	+
10539	+	# Passes both tests.
10540	+	ac_preproc_ok=:
10541	+	break
10542	+	fi
10543	+	rm -f conftest.err conftest.$ac_ext
10544	+
10545	+	done
10546	+	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10547	+	rm -f conftest.err conftest.$ac_ext
10548	+	if $ac_preproc_ok; then
10549	+	:
10550	+	else
10551	+	{ { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10552	+	See \`config.log' for more details." >&5
10553	+	echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10554	+	See \`config.log' for more details." >&2;}
10555	+	{ (exit 1); exit 1; }; }
10556	+	fi
10557	+
10558	+	ac_ext=cc
10559	+	ac_cpp='$CXXCPP $CPPFLAGS'
10560	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563	+
10564	+
10565	+	echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566	+	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567	+	if test "${ac_cv_cxx_have_stl+set}" = set; then
10568	+	echo $ECHO_N "(cached) $ECHO_C" >&6
10569	+	else
10570	+
10571	+
10572	+
10573	+	ac_ext=cc
10574	+	ac_cpp='$CXXCPP $CPPFLAGS'
10575	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578	+
10579	+	cat >conftest.$ac_ext <<_ACEOF
10580	+	/* confdefs.h.  */
10581	+	_ACEOF
10582	+	cat confdefs.h >>conftest.$ac_ext
10583	+	cat >>conftest.$ac_ext <<_ACEOF
10584	+	/* end confdefs.h.  */
10585	+	#include <list>
10586	+	#include <deque>
10587	+	#ifdef HAVE_NAMESPACES
10588	+	using namespace std;
10589	+	#endif
10590	+	#ifdef FC_DUMMY_MAIN
10591	+	#ifndef FC_DUMMY_MAIN_EQ_F77
10592	+	#  ifdef __cplusplus
10593	+	extern "C"
10594	+	#  endif
10595	+	int FC_DUMMY_MAIN() { return 1; }
10596	+	#endif
10597	+	#endif
10598	+	int
10599	+	main ()
10600	+	{
10601	+	list<int> x; x.push_back(5);
10602	+	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603	+	;
10604	+	return 0;
10605	+	}
10606		_ACEOF
10607	+	rm -f conftest.$ac_objext
10608	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10609	+	(eval $ac_compile) 2>conftest.er1
10610	+	ac_status=$?
10611	+	grep -v '^ *+' conftest.er1 >conftest.err
10612	+	rm -f conftest.er1
10613	+	cat conftest.err >&5
10614	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615	+	(exit $ac_status); } &&
10616	+	{ ac_try='test -z "$ac_cxx_werror_flag"
10617	+	|| test ! -s conftest.err'
10618	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10619	+	(eval $ac_try) 2>&5
10620	+	ac_status=$?
10621	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10622	+	(exit $ac_status); }; } &&
10623	+	{ ac_try='test -s conftest.$ac_objext'
10624	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10625	+	(eval $ac_try) 2>&5
10626	+	ac_status=$?
10627	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628	+	(exit $ac_status); }; }; then
10629	+	ac_cv_cxx_have_stl=yes
10630	+	else
10631	+	echo "$as_me: failed program was:" >&5
10632	+	sed 's/^/| /' conftest.$ac_ext >&5
10633	+
10634	+	ac_cv_cxx_have_stl=no
10635	+	fi
10636	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637	+	ac_ext=cc
10638	+	ac_cpp='$CXXCPP $CPPFLAGS'
10639	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10641	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10642	+
10643	+
10644	+	fi
10645	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646	+	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647	+	if test "$ac_cv_cxx_have_stl" = yes; then
10648	+
10649	+	cat >>confdefs.h <<\_ACEOF
10650	+	#define HAVE_STL
10651	+	_ACEOF
10652	+
10653	+	fi
10654	+
10655	+
10656	+
10657	+	if test "${ac_cv_header_iostream+set}" = set; then
10658	+	echo "$as_me:$LINENO: checking for iostream" >&5
10659	+	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660	+	if test "${ac_cv_header_iostream+set}" = set; then
10661	+	echo $ECHO_N "(cached) $ECHO_C" >&6
10662	+	fi
10663	+	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664	+	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665	+	else
10666	+	# Is the header compilable?
10667	+	echo "$as_me:$LINENO: checking iostream usability" >&5
10668	+	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669	+	cat >conftest.$ac_ext <<_ACEOF
10670	+	/* confdefs.h.  */
10671	+	_ACEOF
10672	+	cat confdefs.h >>conftest.$ac_ext
10673	+	cat >>conftest.$ac_ext <<_ACEOF
10674	+	/* end confdefs.h.  */
10675	+	$ac_includes_default
10676	+	#include <iostream>
10677	+	_ACEOF
10678	+	rm -f conftest.$ac_objext
10679	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10680	+	(eval $ac_compile) 2>conftest.er1
10681	+	ac_status=$?
10682	+	grep -v '^ *+' conftest.er1 >conftest.err
10683	+	rm -f conftest.er1
10684	+	cat conftest.err >&5
10685	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10686	+	(exit $ac_status); } &&
10687	+	{ ac_try='test -z "$ac_cxx_werror_flag"
10688	+	|| test ! -s conftest.err'
10689	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10690	+	(eval $ac_try) 2>&5
10691	+	ac_status=$?
10692	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693	+	(exit $ac_status); }; } &&
10694	+	{ ac_try='test -s conftest.$ac_objext'
10695	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10696	+	(eval $ac_try) 2>&5
10697	+	ac_status=$?
10698	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699	+	(exit $ac_status); }; }; then
10700	+	ac_header_compiler=yes
10701	+	else
10702	+	echo "$as_me: failed program was:" >&5
10703	+	sed 's/^/| /' conftest.$ac_ext >&5
10704	+
10705	+	ac_header_compiler=no
10706	+	fi
10707	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10708	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10709	+	echo "${ECHO_T}$ac_header_compiler" >&6
10710	+
10711	+	# Is the header present?
10712	+	echo "$as_me:$LINENO: checking iostream presence" >&5
10713	+	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714	+	cat >conftest.$ac_ext <<_ACEOF
10715	+	/* confdefs.h.  */
10716	+	_ACEOF
10717	+	cat confdefs.h >>conftest.$ac_ext
10718	+	cat >>conftest.$ac_ext <<_ACEOF
10719	+	/* end confdefs.h.  */
10720	+	#include <iostream>
10721	+	_ACEOF
10722		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10724		ac_status=$?
#	Line 4609 | Line 10727 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10727		cat conftest.err >&5
10728		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10729		(exit $ac_status); } >/dev/null; then
10730	<	if test -s conftest.err; then
10731	<	ac_cpp_err=$ac_c_preproc_warn_flag
10732	<	ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10733	<	else
10734	<	ac_cpp_err=
10735	<	fi
10730	>	if test -s conftest.err; then
10731	>	ac_cpp_err=$ac_cxx_preproc_warn_flag
10732	>	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10733	>	else
10734	>	ac_cpp_err=
10735	>	fi
10736	>	else
10737	>	ac_cpp_err=yes
10738	>	fi
10739	>	if test -z "$ac_cpp_err"; then
10740	>	ac_header_preproc=yes
10741	>	else
10742	>	echo "$as_me: failed program was:" >&5
10743	>	sed 's/^/| /' conftest.$ac_ext >&5
10744	>
10745	>	ac_header_preproc=no
10746	>	fi
10747	>	rm -f conftest.err conftest.$ac_ext
10748	>	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10749	>	echo "${ECHO_T}$ac_header_preproc" >&6
10750	>
10751	>	# So?  What about this header?
10752	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753	>	yes:no: )
10754	>	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755	>	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757	>	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758	>	ac_header_preproc=yes
10759	>	;;
10760	>	no:yes:* )
10761	>	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762	>	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763	>	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764	>	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765	>	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766	>	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767	>	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768	>	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769	>	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770	>	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771	>	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772	>	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773	>	(
10774	>	cat <<\_ASBOX
10775	>	## ------------------------------ ##
10776	>	## Report this to gezelter@nd.edu ##
10777	>	## ------------------------------ ##
10778	>	_ASBOX
10779	>	) |
10780	>	sed "s/^/$as_me: WARNING:     /" >&2
10781	>	;;
10782	>	esac
10783	>	echo "$as_me:$LINENO: checking for iostream" >&5
10784	>	echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785	>	if test "${ac_cv_header_iostream+set}" = set; then
10786	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10787	>	else
10788	>	ac_cv_header_iostream=$ac_header_preproc
10789	>	fi
10790	>	echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791	>	echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792	>
10793	>	fi
10794	>	if test $ac_cv_header_iostream = yes; then
10795	>
10796	>
10797	>	cat >>confdefs.h <<\_ACEOF
10798	>	#define HAVE_IOSTREAM 1
10799	>	_ACEOF
10800	>
10801	>
10802	>	else
10803	>
10804	>
10805	>	for ac_header in iostream.h
10806	>	do
10807	>	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10809	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10810	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10811	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10812	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10813	>	fi
10814	>	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10815	>	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10816	>	else
10817	>	# Is the header compilable?
10818	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
10819	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10820	>	cat >conftest.$ac_ext <<_ACEOF
10821	>	/* confdefs.h.  */
10822	>	_ACEOF
10823	>	cat confdefs.h >>conftest.$ac_ext
10824	>	cat >>conftest.$ac_ext <<_ACEOF
10825	>	/* end confdefs.h.  */
10826	>	$ac_includes_default
10827	>	#include <$ac_header>
10828	>	_ACEOF
10829	>	rm -f conftest.$ac_objext
10830	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831	>	(eval $ac_compile) 2>conftest.er1
10832	>	ac_status=$?
10833	>	grep -v '^ *+' conftest.er1 >conftest.err
10834	>	rm -f conftest.er1
10835	>	cat conftest.err >&5
10836	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837	>	(exit $ac_status); } &&
10838	>	{ ac_try='test -z "$ac_cxx_werror_flag"
10839	>	|| test ! -s conftest.err'
10840	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841	>	(eval $ac_try) 2>&5
10842	>	ac_status=$?
10843	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844	>	(exit $ac_status); }; } &&
10845	>	{ ac_try='test -s conftest.$ac_objext'
10846	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10847	>	(eval $ac_try) 2>&5
10848	>	ac_status=$?
10849	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10850	>	(exit $ac_status); }; }; then
10851	>	ac_header_compiler=yes
10852		else
4619	–	ac_cpp_err=yes
4620	–	fi
4621	–	if test -z "$ac_cpp_err"; then
4622	–	:
4623	–	else
10853		echo "$as_me: failed program was:" >&5
10854		sed 's/^/| /' conftest.$ac_ext >&5
10855
10856	<	# Broken: fails on valid input.
4628	<	continue
10856	>	ac_header_compiler=no
10857		fi
10858	<	rm -f conftest.err conftest.$ac_ext
10858	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10859	>	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10860	>	echo "${ECHO_T}$ac_header_compiler" >&6
10861
10862	<	# OK, works on sane cases.  Now check whether non-existent headers
10863	<	# can be detected and how.
10864	<	cat >conftest.$ac_ext <<_ACEOF
10862	>	# Is the header present?
10863	>	echo "$as_me:$LINENO: checking $ac_header presence" >&5
10864	>	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10865	>	cat >conftest.$ac_ext <<_ACEOF
10866		/* confdefs.h.  */
10867		_ACEOF
10868		cat confdefs.h >>conftest.$ac_ext
10869		cat >>conftest.$ac_ext <<_ACEOF
10870		/* end confdefs.h.  */
10871	<	#include <ac_nonexistent.h>
10871	>	#include <$ac_header>
10872		_ACEOF
10873		if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10874		(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
#	Line 4648 | 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 4657 | Line 10888 | if test -z "$ac_cpp_err"; then
10888		ac_cpp_err=yes
10889		fi
10890		if test -z "$ac_cpp_err"; then
10891	<	# Broken: success on invalid input.
4661	<	continue
10891	>	ac_header_preproc=yes
10892		else
10893		echo "$as_me: failed program was:" >&5
10894		sed 's/^/| /' conftest.$ac_ext >&5
10895
10896	<	# Passes both tests.
4667	<	ac_preproc_ok=:
4668	<	break
10896	>	ac_header_preproc=no
10897		fi
10898		rm -f conftest.err conftest.$ac_ext
10899	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10900	+	echo "${ECHO_T}$ac_header_preproc" >&6
10901
10902	<	done
10903	<	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10904	<	rm -f conftest.err conftest.$ac_ext
10905	<	if $ac_preproc_ok; then
10906	<	:
10902	>	# So?  What about this header?
10903	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904	>	yes:no: )
10905	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906	>	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10908	>	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10909	>	ac_header_preproc=yes
10910	>	;;
10911	>	no:yes:* )
10912	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10913	>	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10914	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10915	>	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10916	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10917	>	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10918	>	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10919	>	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10920	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10921	>	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10922	>	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10923	>	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10924	>	(
10925	>	cat <<\_ASBOX
10926	>	## ------------------------------ ##
10927	>	## Report this to gezelter@nd.edu ##
10928	>	## ------------------------------ ##
10929	>	_ASBOX
10930	>	) |
10931	>	sed "s/^/$as_me: WARNING:     /" >&2
10932	>	;;
10933	>	esac
10934	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
10935	>	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10936	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
10937	>	echo $ECHO_N "(cached) $ECHO_C" >&6
10938		else
10939	<	{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4679	<	See \`config.log' for more details." >&5
4680	<	echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4681	<	See \`config.log' for more details." >&2;}
4682	<	{ (exit 1); exit 1; }; }
10939	>	eval "$as_ac_Header=\$ac_header_preproc"
10940		fi
10941	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943
10944	<	ac_ext=c
10945	<	ac_cpp='$CPP $CPPFLAGS'
10946	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10947	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10948	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
10944	>	fi
10945	>	if test `eval echo '${'$as_ac_Header'}'` = yes; then
10946	>	cat >>confdefs.h <<_ACEOF
10947	>	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10948	>	_ACEOF
10949
10950	+	fi
10951
10952	<	echo "$as_me:$LINENO: checking for egrep" >&5
10953	<	echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10954	<	if test "${ac_cv_prog_egrep+set}" = set; then
4695	<	echo $ECHO_N "(cached) $ECHO_C" >&6
4696	<	else
4697	<	if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4698	<	then ac_cv_prog_egrep='grep -E'
4699	<	else ac_cv_prog_egrep='egrep'
4700	<	fi
10952	>	done
10953	>
10954	>
10955		fi
4702	–	echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4703	–	echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4704	–	EGREP=$ac_cv_prog_egrep
10956
10957
10958	<	echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10959	<	echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10960	<	if test "${ac_cv_header_stdc+set}" = set; then
10958	>
10959	>
10960	>	if test "${ac_cv_header_iomanip+set}" = set; then
10961	>	echo "$as_me:$LINENO: checking for iomanip" >&5
10962	>	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963	>	if test "${ac_cv_header_iomanip+set}" = set; then
10964		echo $ECHO_N "(cached) $ECHO_C" >&6
10965	+	fi
10966	+	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967	+	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968		else
10969	<	cat >conftest.$ac_ext <<_ACEOF
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	<	#include <stdlib.h>
10979	<	#include <stdarg.h>
4720	<	#include <string.h>
4721	<	#include <float.h>
4722	<
4723	<	int
4724	<	main ()
4725	<	{
4726	<
4727	<	;
4728	<	return 0;
4729	<	}
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
#	Line 4737 | Line 10987 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10987		cat conftest.err >&5
10988		echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989		(exit $ac_status); } &&
10990	<	{ ac_try='test -z "$ac_c_werror_flag"
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
#	Line 4750 | Line 11000 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11000		ac_status=$?
11001		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002		(exit $ac_status); }; }; then
11003	<	ac_cv_header_stdc=yes
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_cv_header_stdc=no
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	<	if test $ac_cv_header_stdc = yes; then
11015	<	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
11016	<	cat >conftest.$ac_ext <<_ACEOF
11014	>	# Is the header present?
11015	>	echo "$as_me:$LINENO: checking iomanip presence" >&5
11016	>	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017	>	cat >conftest.$ac_ext <<_ACEOF
11018		/* confdefs.h.  */
11019		_ACEOF
11020		cat confdefs.h >>conftest.$ac_ext
11021		cat >>conftest.$ac_ext <<_ACEOF
11022		/* end confdefs.h.  */
11023	<	#include <string.h>
4771	<
11023	>	#include <iomanip>
11024		_ACEOF
11025	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11026	<	$EGREP "memchr" >/dev/null 2>&1; then
11027	<	:
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_cv_header_stdc=no
11040	>	ac_cpp_err=yes
11041		fi
11042	<	rm -f conftest*
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	<	if test $ac_cv_header_stdc = yes; then
11055	<	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
11056	<	cat >conftest.$ac_ext <<_ACEOF
11057	<	/* confdefs.h.  */
11058	<	_ACEOF
11059	<	cat confdefs.h >>conftest.$ac_ext
11060	<	cat >>conftest.$ac_ext <<_ACEOF
11061	<	/* end confdefs.h.  */
11062	<	#include <stdlib.h>
11063	<
11064	<	_ACEOF
11065	<	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11066	<	$EGREP "free" >/dev/null 2>&1; then
11067	<	:
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_stdc=no
11091	>	ac_cv_header_iomanip=$ac_header_preproc
11092		fi
11093	<	rm -f conftest*
11093	>	echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094	>	echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095
11096		fi
11097	<
4804	<	if test $ac_cv_header_stdc = yes; then
4805	<	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4806	<	if test "$cross_compiling" = yes; then
4807	<	:
4808	<	else
4809	<	cat >conftest.$ac_ext <<_ACEOF
4810	<	/* confdefs.h.  */
4811	<	_ACEOF
4812	<	cat confdefs.h >>conftest.$ac_ext
4813	<	cat >>conftest.$ac_ext <<_ACEOF
4814	<	/* end confdefs.h.  */
4815	<	#include <ctype.h>
4816	<	#if ((' ' & 0x0FF) == 0x020)
4817	<	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4818	<	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4819	<	#else
4820	<	# define ISLOWER(c) \
4821	<	(('a' <= (c) && (c) <= 'i') \
4822	<	|| ('j' <= (c) && (c) <= 'r') \
4823	<	|| ('s' <= (c) && (c) <= 'z'))
4824	<	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4825	<	#endif
11097	>	if test $ac_cv_header_iomanip = yes; then
11098
4827	–	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4828	–	int
4829	–	main ()
4830	–	{
4831	–	int i;
4832	–	for (i = 0; i < 256; i++)
4833	–	if (XOR (islower (i), ISLOWER (i))
4834	–	|| toupper (i) != TOUPPER (i))
4835	–	exit(2);
4836	–	exit (0);
4837	–	}
4838	–	_ACEOF
4839	–	rm -f conftest$ac_exeext
4840	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4841	–	(eval $ac_link) 2>&5
4842	–	ac_status=$?
4843	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4844	–	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4845	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4846	–	(eval $ac_try) 2>&5
4847	–	ac_status=$?
4848	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
4849	–	(exit $ac_status); }; }; then
4850	–	:
4851	–	else
4852	–	echo "$as_me: program exited with status $ac_status" >&5
4853	–	echo "$as_me: failed program was:" >&5
4854	–	sed 's/^/| /' conftest.$ac_ext >&5
11099
4856	–	( exit $ac_status )
4857	–	ac_cv_header_stdc=no
4858	–	fi
4859	–	rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4860	–	fi
4861	–	fi
4862	–	fi
4863	–	echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4864	–	echo "${ECHO_T}$ac_cv_header_stdc" >&6
4865	–	if test $ac_cv_header_stdc = yes; then
4866	–
11100		cat >>confdefs.h <<\_ACEOF
11101	<	#define STDC_HEADERS 1
11101	>	#define HAVE_IOMANIP 1
11102		_ACEOF
11103
4871	–	fi
11104
11105	<	# On IRIX 5.3, sys/types and inttypes.h are conflicting.
11105	>	else
11106
11107
11108	<
4877	<
4878	<
4879	<
4880	<
4881	<
4882	<
4883	<	for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4884	<	inttypes.h stdint.h unistd.h
11108	>	for ac_header in iomanip.h
11109		do
11110		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111	<	echo "$as_me:$LINENO: checking for $ac_header" >&5
11111	>	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11112	>	echo "$as_me:$LINENO: checking for $ac_header" >&5
11113		echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11114		if eval "test \"\${$as_ac_Header+set}\" = set"; then
11115		echo $ECHO_N "(cached) $ECHO_C" >&6
11116	+	fi
11117	+	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11118	+	echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11119		else
11120	<	cat >conftest.$ac_ext <<_ACEOF
11120	>	# Is the header compilable?
11121	>	echo "$as_me:$LINENO: checking $ac_header usability" >&5
11122	>	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11123	>	cat >conftest.$ac_ext <<_ACEOF
11124		/* confdefs.h.  */
11125		_ACEOF
11126		cat confdefs.h >>conftest.$ac_ext
11127		cat >>conftest.$ac_ext <<_ACEOF
11128		/* end confdefs.h.  */
11129		$ac_includes_default
4899	–
11130		#include <$ac_header>
11131		_ACEOF
11132		rm -f conftest.$ac_objext
#	Line 4908 | 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 4921 | Line 11151 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11151		ac_status=$?
11152		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11153		(exit $ac_status); }; }; then
11154	<	eval "$as_ac_Header=yes"
11154	>	ac_header_compiler=yes
11155		else
11156		echo "$as_me: failed program was:" >&5
11157		sed 's/^/| /' conftest.$ac_ext >&5
11158
11159	<	eval "$as_ac_Header=no"
11159	>	ac_header_compiler=no
11160		fi
11161		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11162	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11163	+	echo "${ECHO_T}$ac_header_compiler" >&6
11164	+
11165	+	# Is the header present?
11166	+	echo "$as_me:$LINENO: checking $ac_header presence" >&5
11167	+	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11168	+	cat >conftest.$ac_ext <<_ACEOF
11169	+	/* confdefs.h.  */
11170	+	_ACEOF
11171	+	cat confdefs.h >>conftest.$ac_ext
11172	+	cat >>conftest.$ac_ext <<_ACEOF
11173	+	/* end confdefs.h.  */
11174	+	#include <$ac_header>
11175	+	_ACEOF
11176	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11177	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11178	+	ac_status=$?
11179	+	grep -v '^ *+' conftest.er1 >conftest.err
11180	+	rm -f conftest.er1
11181	+	cat conftest.err >&5
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_cxx_preproc_warn_flag
11186	+	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187	+	else
11188	+	ac_cpp_err=
11189	+	fi
11190	+	else
11191	+	ac_cpp_err=yes
11192		fi
11193	+	if test -z "$ac_cpp_err"; then
11194	+	ac_header_preproc=yes
11195	+	else
11196	+	echo "$as_me: failed program was:" >&5
11197	+	sed 's/^/| /' conftest.$ac_ext >&5
11198	+
11199	+	ac_header_preproc=no
11200	+	fi
11201	+	rm -f conftest.err conftest.$ac_ext
11202	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11203	+	echo "${ECHO_T}$ac_header_preproc" >&6
11204	+
11205	+	# So?  What about this header?
11206	+	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207	+	yes:no: )
11208	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209	+	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11210	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11211	+	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11212	+	ac_header_preproc=yes
11213	+	;;
11214	+	no:yes:* )
11215	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11216	+	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11217	+	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11218	+	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11219	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11220	+	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11221	+	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11222	+	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11223	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11224	+	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11225	+	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11226	+	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11227	+	(
11228	+	cat <<\_ASBOX
11229	+	## ------------------------------ ##
11230	+	## Report this to gezelter@nd.edu ##
11231	+	## ------------------------------ ##
11232	+	_ASBOX
11233	+	) |
11234	+	sed "s/^/$as_me: WARNING:     /" >&2
11235	+	;;
11236	+	esac
11237	+	echo "$as_me:$LINENO: checking for $ac_header" >&5
11238	+	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11239	+	if eval "test \"\${$as_ac_Header+set}\" = set"; then
11240	+	echo $ECHO_N "(cached) $ECHO_C" >&6
11241	+	else
11242	+	eval "$as_ac_Header=\$ac_header_preproc"
11243	+	fi
11244		echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11245		echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11246	+
11247	+	fi
11248		if test `eval echo '${'$as_ac_Header'}'` = yes; then
11249		cat >>confdefs.h <<_ACEOF
11250		#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
#	Line 4942 | Line 11255 | done
11255		done
11256
11257
11258	+	fi
11259
11260
11261
11262
11263	<
4950	<
4951	<
4952	<
4953	<
4954	<	for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
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 4984 | 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 5028 | 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 5049 | 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 5103 | Line 11412 | done
11412
11413
11414
11415	<
11416	<
11417	<	for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
5109	<	do
5110	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5111	<	echo "$as_me:$LINENO: checking for $ac_func" >&5
5112	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5113	<	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
11420	<	cat >conftest.$ac_ext <<_ACEOF
11420	>
11421	>	ac_cv_cxx_have_std_iostream=no
11422	>	ac_cv_cxx_need_use_std_iostream=no
11423	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11424	>
11425	>
11426	>	ac_ext=cc
11427	>	ac_cpp='$CXXCPP $CPPFLAGS'
11428	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431	>
11432	>	cat >conftest.$ac_ext <<_ACEOF
11433		/* confdefs.h.  */
11434		_ACEOF
11435		cat confdefs.h >>conftest.$ac_ext
11436		cat >>conftest.$ac_ext <<_ACEOF
11437		/* end confdefs.h.  */
5122	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5123	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5124	–	#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.
5128	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5129	<	<limits.h> exists even on freestanding compilers.  */
5130	<
5131	<	#ifdef __STDC__
5132	<	# 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
11445	>	#ifdef FC_DUMMY_MAIN
11446	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11447	>	#  ifdef __cplusplus
11448	>	extern "C"
11449	>	#  endif
11450	>	int FC_DUMMY_MAIN() { return 1; }
11451	>	#endif
11452	>	#endif
11453	>	int
11454	>	main ()
11455	>	{
11456	>	std::cout<<"Hello World"<<std::endl;return 0;
11457	>	;
11458	>	return 0;
11459	>	}
11460	>	_ACEOF
11461	>	rm -f conftest.$ac_objext
11462	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11463	>	(eval $ac_compile) 2>conftest.er1
11464	>	ac_status=$?
11465	>	grep -v '^ *+' conftest.er1 >conftest.err
11466	>	rm -f conftest.er1
11467	>	cat conftest.err >&5
11468	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469	>	(exit $ac_status); } &&
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
11474	>	ac_status=$?
11475	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476	>	(exit $ac_status); }; } &&
11477	>	{ ac_try='test -s conftest.$ac_objext'
11478	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479	>	(eval $ac_try) 2>&5
11480	>	ac_status=$?
11481	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482	>	(exit $ac_status); }; }; then
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
11488	<	/* Override any gcc2 internal prototype to avoid an error.  */
11489	<	#ifdef __cplusplus
11490	<	extern "C"
11491	<	{
11492	<	#endif
11493	<	/* We use char because int might match the return type of a gcc2
11494	<	builtin and then its argument prototype would still apply.  */
11495	<	char $ac_func ();
11496	<	/* The GNU C library defines this for functions which it implements
11497	<	to always fail with ENOSYS.  Some functions are actually named
11498	<	something starting with __ and the normal name is an alias.  */
11499	<	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5151	<	choke me
11488	>	fi
11489	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
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.  */
11496	>
11497	>	#define __USE_STD_IOSTREAM 1
11498	>	#ifdef HAVE_IOSTREAM
11499	>	#include <iostream>
11500		#else
11501	<	char (*f) () = $ac_func;
11501	>	#include <iostream.h>
11502		#endif
5155	–	#ifdef __cplusplus
5156	–	}
5157	–	#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	<	return f != $ac_func;
11515	>	std::cout<<"Hello World"<<std::endl;return 0;
11516		;
11517		return 0;
11518		}
11519		_ACEOF
11520	<	rm -f conftest.$ac_objext conftest$ac_exeext
11521	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11522	<	(eval $ac_link) 2>conftest.er1
11520	>	rm -f conftest.$ac_objext
11521	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11522	>	(eval $ac_compile) 2>conftest.er1
11523		ac_status=$?
11524		grep -v '^ *+' conftest.er1 >conftest.err
11525		rm -f conftest.er1
11526		cat conftest.err >&5
11527		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528		(exit $ac_status); } &&
11529	<	{ ac_try='test -z "$ac_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
11533		ac_status=$?
11534		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535		(exit $ac_status); }; } &&
11536	<	{ ac_try='test -s conftest$ac_exeext'
11536	>	{ ac_try='test -s conftest.$ac_objext'
11537		{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11538		(eval $ac_try) 2>&5
11539		ac_status=$?
11540		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541		(exit $ac_status); }; }; then
11542	<	eval "$as_ac_var=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
5194	–	eval "$as_ac_var=no"
11547		fi
11548	<	rm -f conftest.err conftest.$ac_objext \
11549	<	conftest$ac_exeext conftest.$ac_ext
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: `eval echo '${'$as_ac_var'}'`" >&5
11559	<	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11560	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
11561	<	cat >>confdefs.h <<_ACEOF
11562	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
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 HAVE_STD_IOSTREAM 1
11564		_ACEOF
11565
11566	<	fi
11567	<	done
11566	>	fi
11567	>	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568
11569	<	# special check for _system_configuration because AIX <4.3.2 do not
11570	<	# contain the `physmem' member.
11571	<	echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11572	<	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11573	<	cat >conftest.$ac_ext <<_ACEOF
11569	>	cat >>confdefs.h <<\_ACEOF
11570	>	#define __USE_STD_IOSTREAM 1
11571	>	_ACEOF
11572	>
11573	>	fi
11574	>
11575	>
11576	>
11577	>
11578	>	echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579	>	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580	>	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11582	>	else
11583	>
11584	>	ac_cv_cxx_have_std_stl=no
11585	>	if test "x$ac_cv_cxx_namespaces" = xyes; then
11586	>
11587	>
11588	>	ac_ext=cc
11589	>	ac_cpp='$CXXCPP $CPPFLAGS'
11590	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593	>
11594	>	cat >conftest.$ac_ext <<_ACEOF
11595		/* confdefs.h.  */
11596		_ACEOF
11597		cat confdefs.h >>conftest.$ac_ext
11598		cat >>conftest.$ac_ext <<_ACEOF
11599		/* end confdefs.h.  */
11600	<	#include <sys/systemcfg.h>
11600	>	#include <list>
11601	>
11602	>	#ifdef FC_DUMMY_MAIN
11603	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11604	>	#  ifdef __cplusplus
11605	>	extern "C"
11606	>	#  endif
11607	>	int FC_DUMMY_MAIN() { return 1; }
11608	>	#endif
11609	>	#endif
11610		int
11611		main ()
11612		{
11613	<	double x = _system_configuration.physmem;
11613	>	std::list<int> foo;return 0;
11614		;
11615		return 0;
11616		}
#	Line 5234 | 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 5247 | 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	<	echo "$as_me:$LINENO: result: yes" >&5
11641	<	echo "${ECHO_T}yes" >&6
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
11645	+	fi
11646	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647	+	ac_ext=cc
11648	+	ac_cpp='$CXXCPP $CPPFLAGS'
11649	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652	+
11653	+	fi
11654	+
11655	+	fi
11656	+	echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657	+	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658	+	if test "$ac_cv_cxx_have_std_stl" = yes; then
11659	+
11660		cat >>confdefs.h <<\_ACEOF
11661	<	#define HAVE__SYSTEM_CONFIGURATION 1
11661	>	#define HAVE_STD_STL 1
11662		_ACEOF
11663
11664	+	fi
11665	+
11666	+
11667	+
11668	+	echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669	+	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670	+	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671	+	echo $ECHO_N "(cached) $ECHO_C" >&6
11672		else
11673	+
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	+	int fd=0;ofstream s;s.attach(fd);
11711	+	;
11712	+	return 0;
11713	+	}
11714	+	_ACEOF
11715	+	rm -f conftest.$ac_objext
11716	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717	+	(eval $ac_compile) 2>conftest.er1
11718	+	ac_status=$?
11719	+	grep -v '^ *+' conftest.er1 >conftest.err
11720	+	rm -f conftest.er1
11721	+	cat conftest.err >&5
11722	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723	+	(exit $ac_status); } &&
11724	+	{ ac_try='test -z "$ac_cxx_werror_flag"
11725	+	|| test ! -s conftest.err'
11726	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727	+	(eval $ac_try) 2>&5
11728	+	ac_status=$?
11729	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11730	+	(exit $ac_status); }; } &&
11731	+	{ ac_try='test -s conftest.$ac_objext'
11732	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11733	+	(eval $ac_try) 2>&5
11734	+	ac_status=$?
11735	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736	+	(exit $ac_status); }; }; then
11737	+	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
5261	–	echo "$as_me:$LINENO: result: no" >&5
5262	–	echo "${ECHO_T}no" >&6
11742		fi
11743		rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744	+	ac_ext=cc
11745	+	ac_cpp='$CXXCPP $CPPFLAGS'
11746	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749
5266	–	# clean out junk possibly left behind by a previous configuration
5267	–	rm -f src/getopt.h
5268	–	# Check for getopt_long support
11750
11751	<	for ac_header in getopt.h
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 HAVE_FSTREAM_ATTACH 1
11758	>	_ACEOF
11759	>
11760	>	fi
11761	>
11762	>
11763	>
11764	>	echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765	>	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766	>	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11768	>	else
11769	>
11770	>	ac_cv_cxx_have_fstream_open=no
11771	>	ac_cv_cxx_fstream_open_prot=no
11772	>
11773	>
11774	>	ac_ext=cc
11775	>	ac_cpp='$CXXCPP $CPPFLAGS'
11776	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779	>
11780	>	# Try with 2 parameters
11781	>	cat >conftest.$ac_ext <<_ACEOF
11782	>	/* confdefs.h.  */
11783	>	_ACEOF
11784	>	cat confdefs.h >>conftest.$ac_ext
11785	>	cat >>conftest.$ac_ext <<_ACEOF
11786	>	/* end confdefs.h.  */
11787	>
11788	>	#ifdef HAVE_IOSTREAM
11789	>	#include <fstream>
11790	>	#else
11791	>	#include <fstream.h>
11792	>	#endif
11793	>	#ifdef HAVE_STD_IOSTREAM
11794	>	using namespace std;
11795	>	#endif
11796	>
11797	>	#ifdef FC_DUMMY_MAIN
11798	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11799	>	#  ifdef __cplusplus
11800	>	extern "C"
11801	>	#  endif
11802	>	int FC_DUMMY_MAIN() { return 1; }
11803	>	#endif
11804	>	#endif
11805	>	int
11806	>	main ()
11807	>	{
11808	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809	>	;
11810	>	return 0;
11811	>	}
11812	>	_ACEOF
11813	>	rm -f conftest.$ac_objext
11814	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11815	>	(eval $ac_compile) 2>conftest.er1
11816	>	ac_status=$?
11817	>	grep -v '^ *+' conftest.er1 >conftest.err
11818	>	rm -f conftest.er1
11819	>	cat conftest.err >&5
11820	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821	>	(exit $ac_status); } &&
11822	>	{ ac_try='test -z "$ac_cxx_werror_flag"
11823	>	|| test ! -s conftest.err'
11824	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825	>	(eval $ac_try) 2>&5
11826	>	ac_status=$?
11827	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828	>	(exit $ac_status); }; } &&
11829	>	{ ac_try='test -s conftest.$ac_objext'
11830	>	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11831	>	(eval $ac_try) 2>&5
11832	>	ac_status=$?
11833	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834	>	(exit $ac_status); }; }; then
11835	>	ac_cv_cxx_have_fstream_open=yes
11836	>	else
11837	>	echo "$as_me: failed program was:" >&5
11838	>	sed 's/^/| /' conftest.$ac_ext >&5
11839	>
11840	>	fi
11841	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842	>	# Try with mode parameter
11843	>	cat >conftest.$ac_ext <<_ACEOF
11844	>	/* confdefs.h.  */
11845	>	_ACEOF
11846	>	cat confdefs.h >>conftest.$ac_ext
11847	>	cat >>conftest.$ac_ext <<_ACEOF
11848	>	/* end confdefs.h.  */
11849	>
11850	>	#ifdef HAVE_IOSTREAM
11851	>	#include <fstream>
11852	>	#else
11853	>	#include <fstream.h>
11854	>	#endif
11855	>	#ifdef HAVE_STD_IOSTREAM
11856	>	using namespace std;
11857	>	#endif
11858	>
11859	>	#ifdef FC_DUMMY_MAIN
11860	>	#ifndef FC_DUMMY_MAIN_EQ_F77
11861	>	#  ifdef __cplusplus
11862	>	extern "C"
11863	>	#  endif
11864	>	int FC_DUMMY_MAIN() { return 1; }
11865	>	#endif
11866	>	#endif
11867	>	int
11868	>	main ()
11869	>	{
11870	>	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871	>	;
11872	>	return 0;
11873	>	}
11874	>	_ACEOF
11875	>	rm -f conftest.$ac_objext
11876	>	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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_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_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	>	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	>
11902	>	fi
11903	>	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904	>	ac_ext=cc
11905	>	ac_cpp='$CXXCPP $CPPFLAGS'
11906	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909	>
11910	>
11911	>	fi
11912	>	echo "$as_me:$LINENO: result: $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	>	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	>	fi
11928	>
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 5300 | 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 5344 | 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 5365 | 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 5416 | 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
5424	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5425	<	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 5431 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100		cat confdefs.h >>conftest.$ac_ext
12101		cat >>conftest.$ac_ext <<_ACEOF
12102		/* end confdefs.h.  */
5434	–	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5435	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5436	–	#define $ac_func innocuous_$ac_func
5437	–
5438	–	/* System header to define __stub macros and hopefully few prototypes,
5439	–	which can conflict with char $ac_func (); below.
5440	–	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5441	–	<limits.h> exists even on freestanding compilers.  */
12103
12104	<	#ifdef __STDC__
12105	<	# include <limits.h>
12106	<	#else
12107	<	# include <assert.h>
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
5448	–
5449	–	#undef $ac_func
5450	–
5451	–	/* Override any gcc2 internal prototype to avoid an error.  */
5452	–	#ifdef __cplusplus
5453	–	extern "C"
5454	–	{
12111		#endif
5456	–	/* We use char because int might match the return type of a gcc2
5457	–	builtin and then its argument prototype would still apply.  */
5458	–	char $ac_func ();
5459	–	/* The GNU C library defines this for functions which it implements
5460	–	to always fail with ENOSYS.  Some functions are actually named
5461	–	something starting with __ and the normal name is an alias.  */
5462	–	#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5463	–	choke me
5464	–	#else
5465	–	char (*f) () = $ac_func;
5466	–	#endif
5467	–	#ifdef __cplusplus
5468	–	}
5469	–	#endif
5470	–
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
5506	–	eval "$as_ac_var=no"
5507	–	fi
5508	–	rm -f conftest.err conftest.$ac_objext \
5509	–	conftest$ac_exeext conftest.$ac_ext
5510	–	fi
5511	–	echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5512	–	echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5513	–	if test `eval echo '${'$as_ac_var'}'` = yes; then
5514	–	cat >>confdefs.h <<_ACEOF
5515	–	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5516	–	_ACEOF
5517	–
5518	–	else
5519	–	# FreeBSD has a gnugetopt library for this
5520	–	echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5521	–	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5522	–	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5523	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5524	–	else
5525	–	ac_check_lib_save_LIBS=$LIBS
5526	–	LIBS="-lgnugetopt  $LIBS"
12147		cat >conftest.$ac_ext <<_ACEOF
12148		/* confdefs.h.  */
12149		_ACEOF
#	Line 5531 | 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
5539	<	builtin and then its argument prototype would still apply.  */
5540	<	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 \
5579	<	conftest$ac_exeext conftest.$ac_ext
5580	<	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
5590	<	# use the GNU replacement
5591	<	case $LIBOBJS in
5592	<	"getopt.$ac_objext"   | \
5593	<	*" getopt.$ac_objext"   | \
5594	<	"getopt.$ac_objext "* | \
5595	<	*" getopt.$ac_objext "* ) ;;
5596	<	*) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5597	<	esac
12211	>	elif test $ac_cv_cpp_func = no; then
12212
12213	<	case $LIBOBJS in
12214	<	"getopt1.$ac_objext"   | \
12215	<	*" getopt1.$ac_objext"   | \
5602	<	"getopt1.$ac_objext "* | \
5603	<	*" getopt1.$ac_objext "* ) ;;
5604	<	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5605	<	esac
12213	>	cat >>confdefs.h <<\_ACEOF
12214	>	#define __func__ ""
12215	>	_ACEOF
12216
5607	–	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5608	–
12217		fi
12218
5611	–	fi
5612	–	done
12219
12220
12221
12222	+
12223		case $debug in
12224		1)
12225		;;
#	Line 5621 | 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 5631 | 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 5669 | 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 5699 | 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 5712 | 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 5739 | 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 5770 | 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 5793 | 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 5822 | 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 5845 | 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 5878 | 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 5936 | 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 5969 | 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 5997 | 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 6042 | 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 6092 | 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 6130 | 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 6151 | 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 6164 | 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 6191 | 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 6222 | 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 6245 | 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 6274 | 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 6297 | 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 6330 | Line 13058 | fi
13058		if test -n "$is60x"; then
13059
13060
13061	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063		if test "${ac_m_cpu_60x+set}" = set; then
13064		echo $ECHO_N "(cached) $ECHO_C" >&6
13065		else
13066		echo 'void f(){}' > conftest.cpp
13067	<	if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13067	>	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068		ac_m_cpu_60x=yes
13069		else
13070		ac_m_cpu_60x=no
#	Line 6388 | Line 13116 | if test "$ac_cv_prog_gxx_2_95" = yes; then
13116		:
13117
13118
13119	<	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
13120	<	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
13119	>	echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120	>	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121		if test "${ac_m_cpu_750+set}" = set; then
13122		echo $ECHO_N "(cached) $ECHO_C" >&6
13123		else
13124		echo 'void f(){}' > conftest.cpp
13125	<	if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13125	>	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126		ac_m_cpu_750=yes
13127		else
13128		ac_m_cpu_750=no
#	Line 6409 | Line 13137 | else
13137		CPU_FLAGS=-mcpu=750
13138		else
13139		:
6412	–
6413	–	fi
6414	–
6415	–	else
6416	–	:
6417	–
6418	–	fi
6419	–
6420	–	fi
6421	–	if test -z "$CPU_FLAGS"; then
6422	–
6423	–
6424	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
6425	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
6426	–	if test "${ac_m_cpu_powerpc+set}" = set; then
6427	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6428	–	else
6429	–	echo 'void f(){}' > conftest.cpp
6430	–	if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
6431	–	ac_m_cpu_powerpc=yes
6432	–	else
6433	–	ac_m_cpu_powerpc=no
6434	–	fi
6435	–	rm -f conftest*
6436	–
6437	–	fi
6438	–	echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
6439	–	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
6440	–	if test "$ac_m_cpu_powerpc" = yes; then
6441	–	:
6442	–	CPU_FLAGS=-mcpu=powerpc
6443	–	else
6444	–	:
6445	–
6446	–	fi
6447	–
6448	–	fi
6449	–	if test -z "$CPU_FLAGS"; then
6450	–
6451	–
6452	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6453	–	echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6454	–	if test "${ac_m_powerpc+set}" = set; then
6455	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6456	–	else
6457	–	echo 'void f(){}' > conftest.cpp
6458	–	if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6459	–	ac_m_powerpc=yes
6460	–	else
6461	–	ac_m_powerpc=no
6462	–	fi
6463	–	rm -f conftest*
6464	–
6465	–	fi
6466	–	echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6467	–	echo "${ECHO_T}$ac_m_powerpc" >&6
6468	–	if test "$ac_m_powerpc" = yes; then
6469	–	:
6470	–	CPU_FLAGS=-mpowerpc
6471	–	else
6472	–	:
6473	–
6474	–	fi
6475	–
6476	–	fi
6477	–	esac
6478	–	fi
6479	–
6480	–	if test -n "$CPU_FLAGS"; then
6481	–	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6482	–	fi
6483	–
6484	–	if test -z "$CXXFLAGS"; then
6485	–	echo ""
6486	–	echo "**********************************************************"
6487	–	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6488	–	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6489	–	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6490	–	echo "**********************************************************"
6491	–	echo ""
6492	–	CXXFLAGS="-O3"
6493	–	fi
6494	–
6495	–
6496	–
6497	–	echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6498	–	echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6499	–	if test "${ac_guessed_cxxflags+set}" = set; then
6500	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6501	–	else
6502	–	echo 'void f(){}' > conftest.cpp
6503	–	if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6504	–	ac_guessed_cxxflags=yes
6505	–	else
6506	–	ac_guessed_cxxflags=no
6507	–	fi
6508	–	rm -f conftest*
6509	–
6510	–	fi
6511	–	echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6512	–	echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6513	–	if test "$ac_guessed_cxxflags" = yes; then
6514	–	:
6515	–
6516	–	else
6517	–	:
6518	–
6519	–	echo ""
6520	–	echo "**********************************************************"
6521	–	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6522	–	echo "* your compiler.                                         *"
6523	–	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6524	–	echo "**********************************************************"
6525	–	echo ""
6526	–	CXXFLAGS=""
6527	–
6528	–	fi
6529	–
6530	–
6531	–	fi
6532	–
6533	–
6534	–
6535	–
6536	–
6537	–	# Try to determine "good" native compiler flags if none specified on command
6538	–	# line
6539	–
6540	–	if test x"$F90FLAGS" = x ; then
6541	–	F90FLAGS=""
6542	–	case "${host_cpu}-${host_os}" in
6543	–
6544	–	*linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6545	–	F90FLAGS="-O"
6546	–	fi;;
6547	–	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6548	–	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6549	–	fi;;
6550	–	powerpc*-aix*)
6551	–	if test "$F90" = f90 -o "$F90" = xlf90; then
6552	–	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6553	–	echo "*******************************************************"
6554	–	echo "*  You have AIX on an unknown powerpc system.  It is  *"
6555	–	echo "*  recommended that you use                           *"
6556	–	echo "*                                                     *"
6557	–	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6558	–	echo "*                                 ^^^                 *"
6559	–	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6560	–	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6561	–	echo "*******************************************************"
6562	–	fi;;
6563	–	*darwin*)
6564	–	if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6565	–	F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6566	–	fi;;
6567	–	esac
6568	–
6569	–	if test -n "$CPU_FLAGS"; then
6570	–	F90FLAGS="$F90FLAGS $CPU_FLAGS"
6571	–	fi
6572	–
6573	–	if test -z "$F90FLAGS"; then
6574	–	echo ""
6575	–	echo "**********************************************************"
6576	–	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6577	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6578	–	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6579	–	echo "**********************************************************"
6580	–	echo ""
6581	–	F90FLAGS="-O3"
6582	–	fi
6583	–
6584	–
6585	–	echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6586	–	echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6587	–	if test "${ac_guessed_f90flags+set}" = set; then
6588	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6589	–	else
6590	–
6591	–
6592	–
6593	–	ac_ext=f90
6594	–	ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6595	–	ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6596	–	ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6597	–
6598	–	echo 'program main' > conftest.$ac_ext
6599	–	echo 'end program main' >> conftest.$ac_ext
6600	–	ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6601	–	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6602	–	(eval $ac_compile) 2>&5
6603	–	ac_status=$?
6604	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6605	–	(exit $ac_status); }; then
6606	–	ac_guessed_f90flags=yes
6607	–	else
6608	–	ac_guessed_f90flags=no
6609	–	fi
6610	–	rm -f conftest*
6611	–	ac_ext=c
6612	–	ac_cpp='$CPP $CPPFLAGS'
6613	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6614	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6615	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6616	–
6617	–
6618	–	fi
6619	–	echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6620	–	echo "${ECHO_T}$ac_guessed_f90flags" >&6
6621	–	if test "$ac_guessed_f90flags" = yes; then
6622	–	:
6623	–
6624	–	else
6625	–	:
6626	–
6627	–	echo ""
6628	–	echo "**********************************************************"
6629	–	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6630	–	echo "* your compiler.                                         *"
6631	–	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6632	–	echo "**********************************************************"
6633	–	echo ""
6634	–	F90FLAGS=""
6635	–
6636	–	fi
6637	–
6638	–
6639	–	fi
6640	–
6641	–	;;
6642	–	esac
6643	–
6644	–	# Find a good install program.  We prefer a C program (faster),
6645	–	# so one script is as good as another.  But avoid the broken or
6646	–	# incompatible versions:
6647	–	# SysV /etc/install, /usr/sbin/install
6648	–	# SunOS /usr/etc/install
6649	–	# IRIX /sbin/install
6650	–	# AIX /bin/install
6651	–	# AmigaOS /C/install, which installs bootblocks on floppy discs
6652	–	# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6653	–	# AFS /usr/afsws/bin/install, which mishandles nonexistent args
6654	–	# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6655	–	# OS/2's system install, which has a completely different semantic
6656	–	# ./install, which can be erroneously created by make from ./install.sh.
6657	–	echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6658	–	echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6659	–	if test -z "$INSTALL"; then
6660	–	if test "${ac_cv_path_install+set}" = set; then
6661	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6662	–	else
6663	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6664	–	for as_dir in $PATH
6665	–	do
6666	–	IFS=$as_save_IFS
6667	–	test -z "$as_dir" && as_dir=.
6668	–	# Account for people who put trailing slashes in PATH elements.
6669	–	case $as_dir/ in
6670	–	./ | .// | /cC/* | \
6671	–	/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6672	–	?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6673	–	/usr/ucb/* ) ;;
6674	–	*)
6675	–	# OSF1 and SCO ODT 3.0 have their own names for install.
6676	–	# Don't use installbsd from OSF since it installs stuff as root
6677	–	# by default.
6678	–	for ac_prog in ginstall scoinst install; do
6679	–	for ac_exec_ext in '' $ac_executable_extensions; do
6680	–	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6681	–	if test $ac_prog = install &&
6682	–	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6683	–	# AIX install.  It has an incompatible calling convention.
6684	–	:
6685	–	elif test $ac_prog = install &&
6686	–	grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6687	–	# program-specific install script used by HP pwplus--don't use.
6688	–	:
6689	–	else
6690	–	ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6691	–	break 3
6692	–	fi
6693	–	fi
6694	–	done
6695	–	done
6696	–	;;
6697	–	esac
6698	–	done
6699	–
6700	–
6701	–	fi
6702	–	if test "${ac_cv_path_install+set}" = set; then
6703	–	INSTALL=$ac_cv_path_install
6704	–	else
6705	–	# As a last resort, use the slow shell script.  We don't cache a
6706	–	# path for INSTALL within a source directory, because that will
6707	–	# break other packages using the cache if that directory is
6708	–	# removed, or if the path is relative.
6709	–	INSTALL=$ac_install_sh
6710	–	fi
6711	–	fi
6712	–	echo "$as_me:$LINENO: result: $INSTALL" >&5
6713	–	echo "${ECHO_T}$INSTALL" >&6
6714	–
6715	–	# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6716	–	# It thinks the first close brace ends the variable substitution.
6717	–	test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6718	–
6719	–	test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6720	–
6721	–	test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6722	–
6723	–	echo "$as_me:$LINENO: checking whether ln -s works" >&5
6724	–	echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6725	–	LN_S=$as_ln_s
6726	–	if test "$LN_S" = "ln -s"; then
6727	–	echo "$as_me:$LINENO: result: yes" >&5
6728	–	echo "${ECHO_T}yes" >&6
6729	–	else
6730	–	echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6731	–	echo "${ECHO_T}no, using $LN_S" >&6
6732	–	fi
6733	–
6734	–	echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6735	–	echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6736	–	set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6737	–	if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6738	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6739	–	else
6740	–	cat >conftest.make <<\_ACEOF
6741	–	all:
6742	–	@echo 'ac_maketemp="$(MAKE)"'
6743	–	_ACEOF
6744	–	# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6745	–	eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6746	–	if test -n "$ac_maketemp"; then
6747	–	eval ac_cv_prog_make_${ac_make}_set=yes
6748	–	else
6749	–	eval ac_cv_prog_make_${ac_make}_set=no
6750	–	fi
6751	–	rm -f conftest.make
6752	–	fi
6753	–	if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6754	–	echo "$as_me:$LINENO: result: yes" >&5
6755	–	echo "${ECHO_T}yes" >&6
6756	–	SET_MAKE=
6757	–	else
6758	–	echo "$as_me:$LINENO: result: no" >&5
6759	–	echo "${ECHO_T}no" >&6
6760	–	SET_MAKE="MAKE=${MAKE-make}"
6761	–	fi
6762	–
6763	–	if test -n "$ac_tool_prefix"; then
6764	–	# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6765	–	set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6766	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6767	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6768	–	if test "${ac_cv_prog_RANLIB+set}" = set; then
6769	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6770	–	else
6771	–	if test -n "$RANLIB"; then
6772	–	ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6773	–	else
6774	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6775	–	for as_dir in $PATH
6776	–	do
6777	–	IFS=$as_save_IFS
6778	–	test -z "$as_dir" && as_dir=.
6779	–	for ac_exec_ext in '' $ac_executable_extensions; do
6780	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6781	–	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6782	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6783	–	break 2
6784	–	fi
6785	–	done
6786	–	done
6787	–
6788	–	fi
6789	–	fi
6790	–	RANLIB=$ac_cv_prog_RANLIB
6791	–	if test -n "$RANLIB"; then
6792	–	echo "$as_me:$LINENO: result: $RANLIB" >&5
6793	–	echo "${ECHO_T}$RANLIB" >&6
6794	–	else
6795	–	echo "$as_me:$LINENO: result: no" >&5
6796	–	echo "${ECHO_T}no" >&6
6797	–	fi
6798	–
6799	–	fi
6800	–	if test -z "$ac_cv_prog_RANLIB"; then
6801	–	ac_ct_RANLIB=$RANLIB
6802	–	# Extract the first word of "ranlib", so it can be a program name with args.
6803	–	set dummy ranlib; ac_word=$2
6804	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6805	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6806	–	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6807	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6808	–	else
6809	–	if test -n "$ac_ct_RANLIB"; then
6810	–	ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6811	–	else
6812	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6813	–	for as_dir in $PATH
6814	–	do
6815	–	IFS=$as_save_IFS
6816	–	test -z "$as_dir" && as_dir=.
6817	–	for ac_exec_ext in '' $ac_executable_extensions; do
6818	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6819	–	ac_cv_prog_ac_ct_RANLIB="ranlib"
6820	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6821	–	break 2
6822	–	fi
6823	–	done
6824	–	done
6825	–
6826	–	test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6827	–	fi
6828	–	fi
6829	–	ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6830	–	if test -n "$ac_ct_RANLIB"; then
6831	–	echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6832	–	echo "${ECHO_T}$ac_ct_RANLIB" >&6
6833	–	else
6834	–	echo "$as_me:$LINENO: result: no" >&5
6835	–	echo "${ECHO_T}no" >&6
6836	–	fi
6837	–
6838	–	RANLIB=$ac_ct_RANLIB
6839	–	else
6840	–	RANLIB="$ac_cv_prog_RANLIB"
6841	–	fi
6842	–
6843	–	for ac_prog in 'bison -y' byacc
6844	–	do
6845	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6846	–	set dummy $ac_prog; ac_word=$2
6847	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6848	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6849	–	if test "${ac_cv_prog_YACC+set}" = set; then
6850	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6851	–	else
6852	–	if test -n "$YACC"; then
6853	–	ac_cv_prog_YACC="$YACC" # Let the user override the test.
6854	–	else
6855	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6856	–	for as_dir in $PATH
6857	–	do
6858	–	IFS=$as_save_IFS
6859	–	test -z "$as_dir" && as_dir=.
6860	–	for ac_exec_ext in '' $ac_executable_extensions; do
6861	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6862	–	ac_cv_prog_YACC="$ac_prog"
6863	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6864	–	break 2
6865	–	fi
6866	–	done
6867	–	done
6868	–
6869	–	fi
6870	–	fi
6871	–	YACC=$ac_cv_prog_YACC
6872	–	if test -n "$YACC"; then
6873	–	echo "$as_me:$LINENO: result: $YACC" >&5
6874	–	echo "${ECHO_T}$YACC" >&6
6875	–	else
6876	–	echo "$as_me:$LINENO: result: no" >&5
6877	–	echo "${ECHO_T}no" >&6
6878	–	fi
6879	–
6880	–	test -n "$YACC" && break
6881	–	done
6882	–	test -n "$YACC" || YACC="yacc"
6883	–
6884	–	for ac_prog in flex lex
6885	–	do
6886	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
6887	–	set dummy $ac_prog; ac_word=$2
6888	–	echo "$as_me:$LINENO: checking for $ac_word" >&5
6889	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6890	–	if test "${ac_cv_prog_LEX+set}" = set; then
6891	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6892	–	else
6893	–	if test -n "$LEX"; then
6894	–	ac_cv_prog_LEX="$LEX" # Let the user override the test.
6895	–	else
6896	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6897	–	for as_dir in $PATH
6898	–	do
6899	–	IFS=$as_save_IFS
6900	–	test -z "$as_dir" && as_dir=.
6901	–	for ac_exec_ext in '' $ac_executable_extensions; do
6902	–	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6903	–	ac_cv_prog_LEX="$ac_prog"
6904	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6905	–	break 2
6906	–	fi
6907	–	done
6908	–	done
6909	–
6910	–	fi
6911	–	fi
6912	–	LEX=$ac_cv_prog_LEX
6913	–	if test -n "$LEX"; then
6914	–	echo "$as_me:$LINENO: result: $LEX" >&5
6915	–	echo "${ECHO_T}$LEX" >&6
6916	–	else
6917	–	echo "$as_me:$LINENO: result: no" >&5
6918	–	echo "${ECHO_T}no" >&6
6919	–	fi
6920	–
6921	–	test -n "$LEX" && break
6922	–	done
6923	–	test -n "$LEX" || LEX=":"
6924	–
6925	–	if test -z "$LEXLIB"
6926	–	then
6927	–	echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6928	–	echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6929	–	if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6930	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6931	–	else
6932	–	ac_check_lib_save_LIBS=$LIBS
6933	–	LIBS="-lfl  $LIBS"
6934	–	cat >conftest.$ac_ext <<_ACEOF
6935	–	/* confdefs.h.  */
6936	–	_ACEOF
6937	–	cat confdefs.h >>conftest.$ac_ext
6938	–	cat >>conftest.$ac_ext <<_ACEOF
6939	–	/* end confdefs.h.  */
6940	–
6941	–	/* Override any gcc2 internal prototype to avoid an error.  */
6942	–	#ifdef __cplusplus
6943	–	extern "C"
6944	–	#endif
6945	–	/* We use char because int might match the return type of a gcc2
6946	–	builtin and then its argument prototype would still apply.  */
6947	–	char yywrap ();
6948	–	int
6949	–	main ()
6950	–	{
6951	–	yywrap ();
6952	–	;
6953	–	return 0;
6954	–	}
6955	–	_ACEOF
6956	–	rm -f conftest.$ac_objext conftest$ac_exeext
6957	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6958	–	(eval $ac_link) 2>conftest.er1
6959	–	ac_status=$?
6960	–	grep -v '^ *+' conftest.er1 >conftest.err
6961	–	rm -f conftest.er1
6962	–	cat conftest.err >&5
6963	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6964	–	(exit $ac_status); } &&
6965	–	{ ac_try='test -z "$ac_c_werror_flag"
6966	–	|| test ! -s conftest.err'
6967	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6968	–	(eval $ac_try) 2>&5
6969	–	ac_status=$?
6970	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6971	–	(exit $ac_status); }; } &&
6972	–	{ ac_try='test -s conftest$ac_exeext'
6973	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6974	–	(eval $ac_try) 2>&5
6975	–	ac_status=$?
6976	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
6977	–	(exit $ac_status); }; }; then
6978	–	ac_cv_lib_fl_yywrap=yes
6979	–	else
6980	–	echo "$as_me: failed program was:" >&5
6981	–	sed 's/^/| /' conftest.$ac_ext >&5
6982	–
6983	–	ac_cv_lib_fl_yywrap=no
6984	–	fi
6985	–	rm -f conftest.err conftest.$ac_objext \
6986	–	conftest$ac_exeext conftest.$ac_ext
6987	–	LIBS=$ac_check_lib_save_LIBS
6988	–	fi
6989	–	echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6990	–	echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6991	–	if test $ac_cv_lib_fl_yywrap = yes; then
6992	–	LEXLIB="-lfl"
6993	–	else
6994	–	echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6995	–	echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6996	–	if test "${ac_cv_lib_l_yywrap+set}" = set; then
6997	–	echo $ECHO_N "(cached) $ECHO_C" >&6
6998	–	else
6999	–	ac_check_lib_save_LIBS=$LIBS
7000	–	LIBS="-ll  $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	–	/* Override any gcc2 internal prototype to avoid an error.  */
7009	–	#ifdef __cplusplus
7010	–	extern "C"
7011	–	#endif
7012	–	/* We use char because int might match the return type of a gcc2
7013	–	builtin and then its argument prototype would still apply.  */
7014	–	char yywrap ();
7015	–	int
7016	–	main ()
7017	–	{
7018	–	yywrap ();
7019	–	;
7020	–	return 0;
7021	–	}
7022	–	_ACEOF
7023	–	rm -f conftest.$ac_objext conftest$ac_exeext
7024	–	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7025	–	(eval $ac_link) 2>conftest.er1
7026	–	ac_status=$?
7027	–	grep -v '^ *+' conftest.er1 >conftest.err
7028	–	rm -f conftest.er1
7029	–	cat conftest.err >&5
7030	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031	–	(exit $ac_status); } &&
7032	–	{ ac_try='test -z "$ac_c_werror_flag"
7033	–	|| test ! -s conftest.err'
7034	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7035	–	(eval $ac_try) 2>&5
7036	–	ac_status=$?
7037	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7038	–	(exit $ac_status); }; } &&
7039	–	{ ac_try='test -s conftest$ac_exeext'
7040	–	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7041	–	(eval $ac_try) 2>&5
7042	–	ac_status=$?
7043	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7044	–	(exit $ac_status); }; }; then
7045	–	ac_cv_lib_l_yywrap=yes
7046	–	else
7047	–	echo "$as_me: failed program was:" >&5
7048	–	sed 's/^/| /' conftest.$ac_ext >&5
13140
7050	–	ac_cv_lib_l_yywrap=no
13141		fi
7052	–	rm -f conftest.err conftest.$ac_objext \
7053	–	conftest$ac_exeext conftest.$ac_ext
7054	–	LIBS=$ac_check_lib_save_LIBS
7055	–	fi
7056	–	echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7057	–	echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7058	–	if test $ac_cv_lib_l_yywrap = yes; then
7059	–	LEXLIB="-ll"
7060	–	fi
13142
13143	<	fi
13143	>	else
13144	>	:
13145
13146		fi
13147
13148	<	if test "x$LEX" != "x:"; then
13149	<	echo "$as_me:$LINENO: checking lex output file root" >&5
13150	<	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
13151	<	if test "${ac_cv_prog_lex_root+set}" = set; then
13148	>	fi
13149	>	if test -z "$CPU_FLAGS"; then
13150	>
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	<	# The minimal lex program is just a single line: %%.  But some broken lexes
13158	<	# (Solaris, I think it was) want two %% lines, so accommodate them.
13159	<	cat >conftest.l <<_ACEOF
7075	<	%%
7076	<	%%
7077	<	_ACEOF
7078	<	{ (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7079	<	(eval $LEX conftest.l) 2>&5
7080	<	ac_status=$?
7081	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7082	<	(exit $ac_status); }
7083	<	if test -f lex.yy.c; then
7084	<	ac_cv_prog_lex_root=lex.yy
7085	<	elif test -f lexyy.c; then
7086	<	ac_cv_prog_lex_root=lexyy
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	<	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7089	<	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7090	<	{ (exit 1); exit 1; }; }
13161	>	ac_m_cpu_powerpc=no
13162		fi
13163	<	fi
7093	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7094	<	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7095	<	rm -f conftest.l
7096	<	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13163	>	rm -f conftest*
13164
13165	<	echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13166	<	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13167	<	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13168	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13165	>	fi
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	<	# POSIX says lex can declare yytext either as a pointer or an array; the
7104	<	# default is implementation-dependent. Figure out which it is, since
7105	<	# not all implementations provide the %pointer and %array declarations.
7106	<	ac_cv_prog_lex_yytext_pointer=no
7107	<	echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7108	<	ac_save_LIBS=$LIBS
7109	<	LIBS="$LIBS $LEXLIB"
7110	<	cat >conftest.$ac_ext <<_ACEOF
7111	<	`cat $LEX_OUTPUT_ROOT.c`
7112	<	_ACEOF
7113	<	rm -f conftest.$ac_objext conftest$ac_exeext
7114	<	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7115	<	(eval $ac_link) 2>conftest.er1
7116	<	ac_status=$?
7117	<	grep -v '^ *+' conftest.er1 >conftest.err
7118	<	rm -f conftest.er1
7119	<	cat conftest.err >&5
7120	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7121	<	(exit $ac_status); } &&
7122	<	{ ac_try='test -z "$ac_c_werror_flag"
7123	<	|| test ! -s conftest.err'
7124	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7125	<	(eval $ac_try) 2>&5
7126	<	ac_status=$?
7127	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7128	<	(exit $ac_status); }; } &&
7129	<	{ ac_try='test -s conftest$ac_exeext'
7130	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7131	<	(eval $ac_try) 2>&5
7132	<	ac_status=$?
7133	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
7134	<	(exit $ac_status); }; }; then
7135	<	ac_cv_prog_lex_yytext_pointer=yes
7136	<	else
7137	<	echo "$as_me: failed program was:" >&5
7138	<	sed 's/^/| /' conftest.$ac_ext >&5
13172	>	:
13173
13174		fi
7141	–	rm -f conftest.err conftest.$ac_objext \
7142	–	conftest$ac_exeext conftest.$ac_ext
7143	–	LIBS=$ac_save_LIBS
7144	–	rm -f "${LEX_OUTPUT_ROOT}.c"
13175
13176	<	fi
13177	<	echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
7148	<	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7149	<	if test $ac_cv_prog_lex_yytext_pointer = yes; then
13176	>	fi
13177	>	if test -z "$CPU_FLAGS"; then
13178
7151	–	cat >>confdefs.h <<\_ACEOF
7152	–	#define YYTEXT_POINTER 1
7153	–	_ACEOF
13179
13180	<	fi
13181	<
13182	<	fi
7158	<	# Extract the first word of "ar", so it can be a program name with args.
7159	<	set dummy ar; ac_word=$2
7160	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
7161	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7162	<	if test "${ac_cv_prog_AR+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	<	if test -n "$AR"; then
13186	<	ac_cv_prog_AR="$AR" # Let the user override the test.
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	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13190	<	for as_dir in $PATH
13191	<	do
7171	<	IFS=$as_save_IFS
7172	<	test -z "$as_dir" && as_dir=.
7173	<	for ac_exec_ext in '' $ac_executable_extensions; do
7174	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7175	<	ac_cv_prog_AR="ar"
7176	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7177	<	break 2
7178	<	fi
7179	<	done
7180	<	done
13189	>	ac_m_powerpc=no
13190	>	fi
13191	>	rm -f conftest*
13192
7182	–	test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13193		fi
13194	<	fi
13195	<	AR=$ac_cv_prog_AR
13196	<	if test -n "$AR"; then
13197	<	echo "$as_me:$LINENO: result: $AR" >&5
13198	<	echo "${ECHO_T}$AR" >&6
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	<	echo "$as_me:$LINENO: result: no" >&5
13201	<	echo "${ECHO_T}no" >&6
13200	>	:
13201	>
13202		fi
13203
13204	<	if test "$AR" = "NONE"; then
13205	<	{ { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
13206	<	echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7197	<	{ (exit 1); exit 1; }; }
7198	<	cat >confcache <<\_ACEOF
7199	<	# This file is a shell script that caches the results of configure
7200	<	# tests run on this system so they can be shared between configure
7201	<	# scripts and configure runs, see configure's option --config-cache.
7202	<	# It is not useful on other systems.  If it contains results you don't
7203	<	# want to keep, you may remove or edit it.
7204	<	#
7205	<	# config.status only pays attention to the cache file if you give it
7206	<	# the --recheck option to rerun configure.
7207	<	#
7208	<	# `ac_cv_env_foo' variables (set or unset) will be overridden when
7209	<	# loading this file, other *unset* `ac_cv_foo' will be assigned the
7210	<	# following values.
13204	>	fi
13205	>	esac
13206	>	fi
13207
13208	<	_ACEOF
13208	>	if test -n "$CPU_FLAGS"; then
13209	>	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210	>	fi
13211
13212	<	# The following way of writing the cache mishandles newlines in values,
13213	<	# but we know of no workaround that is simple, portable, and efficient.
13214	<	# So, don't put newlines in cache variables' values.
13215	<	# Ultrix sh set writes to stderr and can't be redirected directly,
13216	<	# and sets the high bit in the cache file unless we assign to the vars.
13217	<	{
13218	<	(set) 2>&1 |
13219	<	case `(ac_space=' '; set | grep ac_space) 2>&1` in
13220	<	*ac_space=\ *)
7223	<	# `set' does not quote correctly, so add quotes (double-quote
7224	<	# substitution turns \\\\ into \\, and sed turns \\ into \).
7225	<	sed -n \
7226	<	"s/'/'\\\\''/g;
7227	<	s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7228	<	;;
7229	<	*)
7230	<	# `set' quotes correctly as required by POSIX, so do not add quotes.
7231	<	sed -n \
7232	<	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7233	<	;;
7234	<	esac;
7235	<	} |
7236	<	sed '
7237	<	t clear
7238	<	: clear
7239	<	s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7240	<	t end
7241	<	/^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7242	<	: end' >>confcache
7243	<	if diff $cache_file confcache >/dev/null 2>&1; then :; else
7244	<	if test -w $cache_file; then
7245	<	test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7246	<	cat confcache >$cache_file
7247	<	else
7248	<	echo "not updating unwritable cache $cache_file"
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
7250	–	fi
7251	–	rm -f confcache
7252	–	exit 1
7253	–	fi
13222
13223	<	# Extract the first word of "ps", so it can be a program name with args.
13224	<	set dummy ps; ac_word=$2
13225	<	echo "$as_me:$LINENO: checking for $ac_word" >&5
13226	<	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13227	<	if test "${ac_cv_path_PS+set}" = set; then
13223	>
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 $PS in
13231	<	[\\/]* | ?:[\\/]*)
13232	<	ac_cv_path_PS="$PS" # Let the user override the test with a path.
13233	<	;;
13234	<	*)
7267	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7268	<	for as_dir in $PATH
7269	<	do
7270	<	IFS=$as_save_IFS
7271	<	test -z "$as_dir" && as_dir=.
7272	<	for ac_exec_ext in '' $ac_executable_extensions; do
7273	<	if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7274	<	ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7275	<	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7276	<	break 2
7277	<	fi
7278	<	done
7279	<	done
7280	<
7281	<	;;
7282	<	esac
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	>	ac_guessed_cxxflags=no
13235		fi
13236	<	PS=$ac_cv_path_PS
13236	>	rm -f conftest*
13237
7286	–	if test -n "$PS"; then
7287	–	echo "$as_me:$LINENO: result: $PS" >&5
7288	–	echo "${ECHO_T}$PS" >&6
7289	–	else
7290	–	echo "$as_me:$LINENO: result: no" >&5
7291	–	echo "${ECHO_T}no" >&6
13238		fi
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
7294	–	echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7295	–	echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7296	–	if test "${ac_cv_prog_ps_syntax+set}" = set; then
7297	–	echo $ECHO_N "(cached) $ECHO_C" >&6
13244		else
13245	+	:
13246
13247	<	if $PS ax -o rss > /dev/null 2>&1; then
13248	<	ac_cv_prog_ps_ax=yes
13249	<	else
13250	<	ac_cv_prog_ps_ax=no
13251	<	fi
13252	<	if $PS -ef -o rss > /dev/null 2>&1; then
13253	<	ac_cv_prog_ps_ef=yes
13254	<	else
7308	<	ac_cv_prog_ps_ef=no
7309	<	fi
7310	<	if test "$ac_cv_prog_ps_ax" = yes; then
7311	<	ac_cv_prog_ps_syntax=BSD
7312	<	else
7313	<	if test "$ac_cv_prog_ps_ef" = yes; then
7314	<	ac_cv_prog_ps_syntax=POSIX
7315	<	else
7316	<	{ { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7317	<	echo "$as_me: error: Could not determine ps syntax" >&2;}
7318	<	{ (exit 1); exit 1; }; }
7319	<	fi
7320	<	fi
7321	<
7322	<	fi
7323	<	echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7324	<	echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
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
13256	+	fi
13257
7327	–	cat >>confdefs.h <<_ACEOF
7328	–	#define PSCOMMAND $PS
7329	–	_ACEOF
13258
13259	+	fi
13260
13261	<	if test "$ac_cv_prog_ps_syntax" = BSD; then
13262	<	cat >>confdefs.h <<\_ACEOF
7334	<	#define PSTYPE_IS_BSD 1
7335	<	_ACEOF
13261	>	;;
13262	>	esac
13263
13264	<	else
13265	<	if test "$ac_cv_prog_ps_syntax" = POSIX; then
13266	<	cat >>confdefs.h <<\_ACEOF
7340	<	#define PSTYPE_IS_POSIX 1
13264	>
13265	>	cat >>confdefs.h <<\_ACEOF
13266	>	#define OBAPI
13267		_ACEOF
13268
7343	–	else
7344	–	{ { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
7345	–	echo "$as_me: error: Unknown ps syntax type!" >&2;}
7346	–	{ (exit 1); exit 1; }; }
7347	–	fi
7348	–	fi
13269
13270
13271	+
13272		# Check whether --with-mpi or --without-mpi was given.
13273		if test "${with_mpi+set}" = set; then
13274		withval="$with_mpi"
#	Line 7376 | Line 13297 | have_mpi_h=0
13297		echo "$as_me:$LINENO: checking for mpi.h" >&5
13298		echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13299		have_mpi_h=0
13300	+	rm -f conftest*
13301		echo '#include <mpi.h>' > conftest.cc
13302	<	if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13302	>	if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13303		echo "$as_me:$LINENO: result: yes" >&5
13304		echo "${ECHO_T}yes" >&6
13305		have_mpi_h=1
13306		else
13307	+	if test -s conftest.out ; then
13308	+	cat conftest.out >> config.log
13309	+	fi
13310		echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13311		echo "${ECHO_T}no! Check MPI include paths" >&6
13312		USE_MPI="no"
#	Line 7399 | 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 7458 | 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 7528 | 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 7599 | 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 7670 | 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 7714 | 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 7742 | 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 7819 | Line 13784 | fi
13784
13785
13786
13787	+	USE_CGAL=no
13788	+	cgal_makefile=auto
13789
13790	+	# Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13791	+	if test "${with_cgal_makefile+set}" = set; then
13792	+	withval="$with_cgal_makefile"
13793	+	cgal_makefile="$withval"
13794	+	fi;
13795	+
13796	+	if test "x$cgal_makefile" != xno; then
13797	+
13798	+	if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13799	+	cgal_makefile="$CGAL_MAKEFILE"
13800	+	fi
13801	+
13802	+	echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13803	+	echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13804	+
13805	+	if test -f "$cgal_makefile"; then
13806	+
13807	+	cat >config.tmp.Makefile <<EOF
13808	+	include $cgal_makefile
13809	+	default:
13810	+	@echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13811	+	@echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13812	+	@echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13813	+	@echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13814	+	@echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13815	+	@echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13816	+	@echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13817	+	@echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13818	+	@echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13819	+	@echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13820	+	@echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13821	+	@echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13822	+	EOF
13823	+
13824	+	make -s -f config.tmp.Makefile
13825	+	. config.tmp.cgalvariables
13826	+
13827	+	rm -f config.tmp.Makefile config.tmp.cgalvariables
13828	+
13829	+	if test "x$CGAL_INCLDIR" = "x"; then
13830	+	CGAL_INCLDIR=""
13831	+	fi
13832	+
13833	+	if test "x$CGAL_LIBDIR" = "x"; then
13834	+	CGAL_LIBDIR=""
13835	+	fi
13836	+
13837	+	if test "x$CGAL_RLIBDIR" = "x"; then
13838	+	CGAL_RLIBDIR=""
13839	+	fi
13840	+
13841	+	if test "x$LEDA_INCLDIR" = "x"; then
13842	+	LEDA_INCLDIR=""
13843	+	fi
13844	+
13845	+	if test "x$LEDA_LIBDIR" = "x"; then
13846	+	LEDA_LIBDIR=""
13847	+	fi
13848	+
13849	+	if test "x$LEDA_RLIBDIR" = "x"; then
13850	+	LEDA_RLIBDIR=""
13851	+	fi
13852	+
13853	+	if test "x$GMP_INCLDIR" = "x"; then
13854	+	GMP_INCLDIR=""
13855	+	fi
13856	+
13857	+	if test "x$GMP_LIBDIR" = "x"; then
13858	+	GMP_LIBDIR=""
13859	+	fi
13860	+
13861	+	if test "x$GMP_RLIBDIR" = "x"; then
13862	+	GMP_RLIBDIR=""
13863	+	fi
13864	+
13865	+	echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13866	+	echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13867	+	echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13868	+	echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13869	+	echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13870	+	echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13871	+	echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13872	+	echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13873	+	echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13874	+	echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13875	+	echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13876	+	echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13877	+	echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13878	+	echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13879	+	echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13880	+	echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13881	+	echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13882	+	echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13883	+
13884	+	ac_ext=cc
13885	+	ac_cpp='$CXXCPP $CPPFLAGS'
13886	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13887	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13888	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13889	+
13890	+	save_CXXFLAGS="$CXXFLAGS"
13891	+	CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13892	+	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13893	+	echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13894	+	echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13895	+	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13896	+	echo $ECHO_N "(cached) $ECHO_C" >&6
13897	+	fi
13898	+	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13899	+	echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13900	+	else
13901	+	# Is the header compilable?
13902	+	echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13903	+	echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13904	+	cat >conftest.$ac_ext <<_ACEOF
13905	+	/* confdefs.h.  */
13906	+	_ACEOF
13907	+	cat confdefs.h >>conftest.$ac_ext
13908	+	cat >>conftest.$ac_ext <<_ACEOF
13909	+	/* end confdefs.h.  */
13910	+	$ac_includes_default
13911	+	#include <CGAL/Cartesian.h>
13912	+	_ACEOF
13913	+	rm -f conftest.$ac_objext
13914	+	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13915	+	(eval $ac_compile) 2>conftest.er1
13916	+	ac_status=$?
13917	+	grep -v '^ *+' conftest.er1 >conftest.err
13918	+	rm -f conftest.er1
13919	+	cat conftest.err >&5
13920	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13921	+	(exit $ac_status); } &&
13922	+	{ ac_try='test -z "$ac_cxx_werror_flag"
13923	+	|| test ! -s conftest.err'
13924	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13925	+	(eval $ac_try) 2>&5
13926	+	ac_status=$?
13927	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13928	+	(exit $ac_status); }; } &&
13929	+	{ ac_try='test -s conftest.$ac_objext'
13930	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13931	+	(eval $ac_try) 2>&5
13932	+	ac_status=$?
13933	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13934	+	(exit $ac_status); }; }; then
13935	+	ac_header_compiler=yes
13936	+	else
13937	+	echo "$as_me: failed program was:" >&5
13938	+	sed 's/^/| /' conftest.$ac_ext >&5
13939	+
13940	+	ac_header_compiler=no
13941	+	fi
13942	+	rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13943	+	echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13944	+	echo "${ECHO_T}$ac_header_compiler" >&6
13945	+
13946	+	# Is the header present?
13947	+	echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13948	+	echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13949	+	cat >conftest.$ac_ext <<_ACEOF
13950	+	/* confdefs.h.  */
13951	+	_ACEOF
13952	+	cat confdefs.h >>conftest.$ac_ext
13953	+	cat >>conftest.$ac_ext <<_ACEOF
13954	+	/* end confdefs.h.  */
13955	+	#include <CGAL/Cartesian.h>
13956	+	_ACEOF
13957	+	if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13958	+	(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
13959	+	ac_status=$?
13960	+	grep -v '^ *+' conftest.er1 >conftest.err
13961	+	rm -f conftest.er1
13962	+	cat conftest.err >&5
13963	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13964	+	(exit $ac_status); } >/dev/null; then
13965	+	if test -s conftest.err; then
13966	+	ac_cpp_err=$ac_cxx_preproc_warn_flag
13967	+	ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13968	+	else
13969	+	ac_cpp_err=
13970	+	fi
13971	+	else
13972	+	ac_cpp_err=yes
13973	+	fi
13974	+	if test -z "$ac_cpp_err"; then
13975	+	ac_header_preproc=yes
13976	+	else
13977	+	echo "$as_me: failed program was:" >&5
13978	+	sed 's/^/| /' conftest.$ac_ext >&5
13979	+
13980	+	ac_header_preproc=no
13981	+	fi
13982	+	rm -f conftest.err conftest.$ac_ext
13983	+	echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13984	+	echo "${ECHO_T}$ac_header_preproc" >&6
13985	+
13986	+	# So?  What about this header?
13987	+	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13988	+	yes:no: )
13989	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13990	+	echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13991	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13992	+	echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13993	+	ac_header_preproc=yes
13994	+	;;
13995	+	no:yes:* )
13996	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13997	+	echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13998	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13999	+	echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
14000	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
14001	+	echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
14002	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
14003	+	echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14004	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
14005	+	echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
14006	+	{ echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
14007	+	echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
14008	+	(
14009	+	cat <<\_ASBOX
14010	+	## ------------------------------ ##
14011	+	## Report this to gezelter@nd.edu ##
14012	+	## ------------------------------ ##
14013	+	_ASBOX
14014	+	) |
14015	+	sed "s/^/$as_me: WARNING:     /" >&2
14016	+	;;
14017	+	esac
14018	+	echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
14019	+	echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
14020	+	if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
14021	+	echo $ECHO_N "(cached) $ECHO_C" >&6
14022	+	else
14023	+	ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
14024	+	fi
14025	+	echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
14026	+	echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
14027	+
14028	+	fi
14029	+	if test $ac_cv_header_CGAL_Cartesian_h = yes; then
14030	+	cgal=yes
14031	+	else
14032	+	cgal=no
14033	+	fi
14034	+
14035	+
14036	+	CXXFLAGS="$save_CXXFLAGS"
14037	+
14038	+	if test "x$cgal" = xyes; then
14039	+	echo "$as_me:$LINENO: checking for CGAL version" >&5
14040	+	echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
14041	+	LOCATION=${CGAL_INCLDIR}
14042	+	LOCATION=${LOCATION:-/usr/include}
14043	+	if test -f $LOCATION/CGAL/version.h; then
14044	+	CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
14045	+	else
14046	+	CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
14047	+	fi
14048	+	if echo $CGAL_VERSION | grep -q "^[3456789]"; then
14049	+	echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
14050	+	echo "${ECHO_T}($CGAL_VERSION) yes" >&6
14051	+	else
14052	+	echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
14053	+	echo "${ECHO_T}($CGAL_VERSION) no" >&6
14054	+	cgal=no
14055	+	fi
14056	+	fi
14057	+
14058	+	if test "x$cgal" = xyes; then
14059	+	CGAL_LIBS="-lCGAL"
14060	+	echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
14061	+	echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
14062	+	if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
14063	+	CGAL_USES_LEDA=yes
14064	+	echo "$as_me:$LINENO: result: yes" >&5
14065	+	echo "${ECHO_T}yes" >&6
14066	+	CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
14067	+	else
14068	+	echo "$as_me:$LINENO: result: no" >&5
14069	+	echo "${ECHO_T}no" >&6
14070	+	CGAL_USES_LEDA=no
14071	+	fi
14072	+
14073	+	echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
14074	+	echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
14075	+	if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
14076	+	CGAL_USES_GMP=yes
14077	+	echo "$as_me:$LINENO: result: yes" >&5
14078	+	echo "${ECHO_T}yes" >&6
14079	+	CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
14080	+	else
14081	+	echo "$as_me:$LINENO: result: no" >&5
14082	+	echo "${ECHO_T}no" >&6
14083	+	CGAL_USES_GMP=no
14084	+	fi
14085	+
14086	+	CGAL_LIBS="$CGAL_LIBS -lm"
14087	+
14088	+	CGAL_CXXFLAGS="-ftemplate-depth-50"
14089	+
14090	+	echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
14091	+	echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
14092	+	echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
14093	+	echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
14094	+	echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
14095	+	echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
14096	+	echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
14097	+	echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
14098	+	echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
14099	+	echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
14100	+	echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
14101	+	echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
14102	+	echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
14103	+	echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
14104	+	fi
14105	+
14106	+	if test "x$cgal" = xyes; then
14107	+	save_LIBS="$LIBS"
14108	+	LIBS="$LIBS -L$CGAL_LIBDIR"
14109	+	if test "x$CGAL_USES_LEDA" = xyes; then
14110	+	LIBS="-lL $LIBS -L$LEDA_LIBDIR"
14111	+	fi
14112	+	# if test "x$CGAL_USES_GMP" = xyes; then
14113	+	#   LIBS="-lgmp $LIBS $GMP_LIBDIR"
14114	+	# fi
14115	+	echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
14116	+	echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
14117	+	save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
14118	+	CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
14119	+	save_LIBS_CHECK_CXX_LIB="$LIBS"
14120	+	LIBS="-lCGAL  $LIBS"
14121	+	cat >conftest.$ac_ext <<_ACEOF
14122	+	/* confdefs.h.  */
14123	+	_ACEOF
14124	+	cat confdefs.h >>conftest.$ac_ext
14125	+	cat >>conftest.$ac_ext <<_ACEOF
14126	+	/* end confdefs.h.  */
14127	+	#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	+	{
14139	+	::CGAL::Cartesian<int>::Point_2 P
14140	+	;
14141	+	return 0;
14142	+	}
14143	+	_ACEOF
14144	+	rm -f conftest.$ac_objext conftest$ac_exeext
14145	+	if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14146	+	(eval $ac_link) 2>conftest.er1
14147	+	ac_status=$?
14148	+	grep -v '^ *+' conftest.er1 >conftest.err
14149	+	rm -f conftest.er1
14150	+	cat conftest.err >&5
14151	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14152	+	(exit $ac_status); } &&
14153	+	{ ac_try='test -z "$ac_cxx_werror_flag"
14154	+	|| test ! -s conftest.err'
14155	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14156	+	(eval $ac_try) 2>&5
14157	+	ac_status=$?
14158	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14159	+	(exit $ac_status); }; } &&
14160	+	{ ac_try='test -s conftest$ac_exeext'
14161	+	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14162	+	(eval $ac_try) 2>&5
14163	+	ac_status=$?
14164	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14165	+	(exit $ac_status); }; }; then
14166	+	echo "$as_me:$LINENO: result: yes" >&5
14167	+	echo "${ECHO_T}yes" >&6
14168	+	cgal=yes
14169	+	else
14170	+	echo "$as_me: failed program was:" >&5
14171	+	sed 's/^/| /' conftest.$ac_ext >&5
14172	+
14173	+	echo "$as_me:$LINENO: result: no" >&5
14174	+	echo "${ECHO_T}no" >&6
14175	+	cgal=no
14176	+	fi
14177	+	rm -f conftest.err conftest.$ac_objext \
14178	+	conftest$ac_exeext conftest.$ac_ext
14179	+	CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
14180	+	LIBS="$save_LIBS_CHECK_CXX_LIB"
14181	+	LIBS="$save_LIBS"
14182	+	fi
14183	+
14184	+	fi
14185	+	ac_ext=c
14186	+	ac_cpp='$CPP $CPPFLAGS'
14187	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14188	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14189	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
14190	+
14191	+
14192	+	fi
14193	+
14194	+	if test "x$cgal" = xyes; then
14195	+	USE_CGAL=yes
14196	+
14197	+	cat >>confdefs.h <<\_ACEOF
14198	+	#define HAVE_CGAL 1
14199	+	_ACEOF
14200	+
14201	+
14202	+	cat >>confdefs.h <<_ACEOF
14203	+	#define CGAL_VERSION $CGAL_VERSION
14204	+	_ACEOF
14205	+
14206	+	if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14207	+	{ echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14208	+	echo "$as_me: WARNING: *****************************************************" >&2;}
14209	+	{ echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14210	+	echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14211	+	{ echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14212	+	echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14213	+	{ echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14214	+	echo "$as_me: WARNING: *****************************************************" >&2;}
14215	+	fi
14216	+	else
14217	+	if test "x$cgal_makefile" != xno; then
14218	+	echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14219	+	echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14220	+	fi
14221	+	CGAL_INCLDIR=
14222	+	CGAL_LIBDIR=
14223	+	CGAL_RLIBDIR=
14224	+	CGAL_DEFINES=
14225	+	CGAL_CXXFLAGS=
14226	+	CGAL_LIBS=
14227	+	fi
14228	+
14229	+
14230	+	CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14231	+
14232	+	CGAL_LIB_DIR=${CGAL_LIBDIR}
14233	+
14234	+	CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14235	+
14236	+
14237	+
14238	+
14239	+
14240	+
14241	+
14242		# Check whether --enable-doxygen or --disable-doxygen was given.
14243		if test "${enable_doxygen+set}" = set; then
14244		enableval="$enable_doxygen"
#	Line 7961 | Line 14380 | fi
14380
14381
14382
7964	–	OBJEXT=".$OBJEXT"
14383
7966	–	OOPSE=oopse
14384
7968	–	if test "x${prefix}" = "xNONE"
7969	–	then
7970	–	OOPSE_HOME=${ac_default_prefix}/oopse
7971	–	else
7972	–	OOPSE_HOME=${prefix}/oopse
7973	–	fi
7974	–	# Check whether --enable-oopse-home or --disable-oopse-home was given.
7975	–	if test "${enable_oopse_home+set}" = set; then
7976	–	enableval="$enable_oopse_home"
7977	–	OOPSE_HOME="${enableval}"
7978	–	fi;
14385
7980	–	case "x$INSTALL" in
7981	–	x/*) ;;
7982	–	*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
7983	–	esac
14386
7985	–	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14387
7987	–	CFLAGS=${CFLAGS-""}
7988	–	CXXFLAGS=${CXXFLAGS-""}
7989	–	CPPFLAGS=${CPPFLAGS-""}
7990	–	FFLAGS=${FFLAGS-""}
7991	–	F90FLAGS=${F90FLAGS-""}
7992	–	LDFLAGS=${LDFLAGS-""}
7993	–	DEBUG=${DEBUG-"-g"}
14388
7995	–	case $debug in
7996	–	1)
7997	–	FFLAGS="$DEBUG $FFLAGS"
7998	–	F90FLAGS="$DEBUG $F90FLAGS"
7999	–	;;
8000	–	*)
8001	–	;;
8002	–	esac
14389
14390
14391
14392
14393
14394
14395	<
8010	<
8011	<
8012	<
8013	<
8014	<
8015	<
8016	<
8017	<
8018	<
8019	<
8020	<
8021	<	ac_config_headers="$ac_config_headers src/config.h"
8022	<
8023	<	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
14395	>	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396
14397
14398		cat >confcache <<\_ACEOF
#	Line 8385 | 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 8448 | 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 8553 | Line 14925 | do
14925		# Handling of arguments.
14926		"make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14927		"src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14928	+	"src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14929	+	"scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14930		"src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14931		"src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14932		*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
#	Line 8640 | 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
8643	–	s,@PROGNAME@,$PROGNAME,;t t
8644	–	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 8650 | Line 15022 | s,@host_os@,$host_os,;t t
15022		s,@host_cpu@,$host_cpu,;t t
15023		s,@host_vendor@,$host_vendor,;t t
15024		s,@host_os@,$host_os,;t t
15025	<	s,@CC@,$CC,;t t
15026	<	s,@CFLAGS@,$CFLAGS,;t t
15025	>	s,@PROGNAME@,$PROGNAME,;t t
15026	>	s,@debug@,$debug,;t t
15027	>	s,@CXX@,$CXX,;t t
15028	>	s,@CXXFLAGS@,$CXXFLAGS,;t t
15029		s,@LDFLAGS@,$LDFLAGS,;t t
15030		s,@CPPFLAGS@,$CPPFLAGS,;t t
15031	<	s,@ac_ct_CC@,$ac_ct_CC,;t t
15031	>	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032		s,@EXEEXT@,$EXEEXT,;t t
15033		s,@OBJEXT@,$OBJEXT,;t t
15034	<	s,@CXX@,$CXX,;t t
15035	<	s,@CXXFLAGS@,$CXXFLAGS,;t t
15036	<	s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15037	<	s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15038	<	s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15039	<	s,@F90@,$F90,;t t
8666	<	s,@F90FLAGS@,$F90FLAGS,;t t
8667	<	s,@ac_ct_F90@,$ac_ct_F90,;t t
8668	<	s,@PREPFLAG@,$PREPFLAG,;t t
8669	<	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8670	<	s,@F90LIBS@,$F90LIBS,;t t
8671	<	s,@F90_FUNC@,$F90_FUNC,;t t
8672	<	s,@F90_FUNC_@,$F90_FUNC_,;t t
8673	<	s,@MOD@,$MOD,;t t
8674	<	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8675	<	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8676	<	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
8677	<	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;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
8680	–	s,@LIBOBJS@,$LIBOBJS,;t t
8681	–	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8682	–	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8683	–	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042		s,@LN_S@,$LN_S,;t t
15043		s,@SET_MAKE@,$SET_MAKE,;t t
15044		s,@RANLIB@,$RANLIB,;t t
15045		s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15046	<	s,@YACC@,$YACC,;t t
15047	<	s,@LEX@,$LEX,;t t
15048	<	s,@LEXLIB@,$LEXLIB,;t t
15049	<	s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046	>	s,@PERLINTERP@,$PERLINTERP,;t t
15047	>	s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048	>	s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049	>	s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050	>	s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051		s,@AR@,$AR,;t t
15052		s,@PS@,$PS,;t t
15053	+	s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054	+	s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055	+	s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056	+	s,@FCLIBS@,$FCLIBS,;t t
15057	+	s,@FC_FUNC@,$FC_FUNC,;t t
15058	+	s,@FC_FUNC_@,$FC_FUNC_,;t t
15059	+	s,@MOD@,$MOD,;t t
15060	+	s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061	+	s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062	+	s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063	+	s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064	+	s,@LIBOBJS@,$LIBOBJS,;t t
15065	+	s,@POW_LIB@,$POW_LIB,;t t
15066	+	s,@CXXCPP@,$CXXCPP,;t t
15067	+	s,@__func__@,$__func__,;t t
15068		s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069		s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070		s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15071		s,@MPI_LIB@,$MPI_LIB,;t t
15072		s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15073		s,@USE_MPI@,$USE_MPI,;t t
15074	+	s,@USE_CGAL@,$USE_CGAL,;t t
15075	+	s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
15076	+	s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
15077	+	s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
15078	+	s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
15079	+	s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080	+	s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15081		s,@DOXYGEN@,$DOXYGEN,;t t
15082		s,@DOT@,$DOT,;t t
15083		s,@DOC@,$DOC,;t t
#	Line 8708 | 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
8711	–	s,@FFLAGS@,$FFLAGS,;t t
15092		s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093		CEOF
15094
#	Line 8946 | Line 15326 | s,@INSTALL@,$ac_INSTALL,;t t
15326		rm -f $tmp/out
15327		fi
15328
15329	+	# Run the commands associated with the file.
15330	+	case $ac_file in
15331	+	make/Makefile ) chmod 0755 scripts/* ;;
15332	+	src/utils/Makefile ) chmod 0755 scripts/* ;;
15333	+	src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15334	+	scripts/filepp ) chmod 0755 scripts/* ;;
15335	+	esac
15336		done
15337		_ACEOF
15338		cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

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