ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing:
trunk/configure (file contents), Revision 1379 by gezelter, Thu Oct 22 14:09:13 2009 UTC vs.
branches/development/configure (file contents), Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.64 for OOPSE 4.0.
3	>	# Generated by GNU Autoconf 2.65 for OpenMD 1.0.
4		#
5		# Report bugs to <gezelter@nd.edu>.
6		#
7	+	#
8		# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
9	<	# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
10	<	# Foundation, Inc.
9	>	# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
10	>	# Inc.
11	>	#
12		#
13		# This configure script is free software; the Free Software Foundation
14		# gives unlimited permission to copy, distribute and modify it.
#	Line 527 | Line 529 | as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
529		as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
530
531
532	<	exec 7<&0 </dev/null 6>&1
532	>	test -n "$DJDIR" || exec 7<&0 </dev/null
533	>	exec 6>&1
534
535		# Name of the host.
536		# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
#	Line 547 | Line 550 | MAKEFLAGS=
550		MAKEFLAGS=
551
552		# Identity of this package.
553	<	PACKAGE_NAME='OOPSE'
554	<	PACKAGE_TARNAME='oopse'
555	<	PACKAGE_VERSION='4.0'
556	<	PACKAGE_STRING='OOPSE 4.0'
553	>	PACKAGE_NAME='OpenMD'
554	>	PACKAGE_TARNAME='openmd'
555	>	PACKAGE_VERSION='1.0'
556	>	PACKAGE_STRING='OpenMD 1.0'
557		PACKAGE_BUGREPORT='gezelter@nd.edu'
558		PACKAGE_URL=''
559
560	<	ac_unique_file="src/applications/oopse/oopse.cpp"
560	>	ac_unique_file="src/applications/openmd/openmd.cpp"
561		ac_default_prefix="/usr/local"
562		# Factoring default headers for most tests.
563		ac_includes_default="\
#	Line 594 | Line 597 | SUBDIRS
597
598		ac_subst_vars='LTLIBOBJS
599		SUBDIRS
600	<	OOPSE_HOME
601	<	OOPSE
600	>	OPENMD_HOME
601	>	OPENMD
602		MKINSTALLDIRS
603		BATEXT
604		enable_latex_docs
#	Line 647 | Line 650 | MPIFC
650		CPP
651		USE_MPI
652		MPIFC
653	+	MPICC
654	+	MPILIBS
655	+	MPICXX
656	+	LIBDL
657		ac_ct_FC
658		FCFLAGS
659		FC
653	–	MPICC
660		ac_ct_CC
661		CFLAGS
662		CC
657	–	MPILIBS
658	–	MPICXX
663		OBJEXT
664		EXEEXT
665		ac_ct_CXX
#	Line 663 | Line 667 | CXX
667		LDFLAGS
668		CXXFLAGS
669		CXX
666	–	ac_fc_path
667	–	ac_fc_set
668	–	ac_cxx_path
669	–	ac_cxx_set
670	–	ac_cc_path
671	–	ac_cc_set
670		USE_SINGLE_PRECISION
671		debug
672		PROGNAME
#	Line 721 | Line 719 | enable_option_checking
719		ac_subst_files=''
720		ac_user_opts='
721		enable_option_checking
722	<	enable_oopse_home
722	>	enable_openmd_home
723		enable_debug
724		enable_single
725		enable_float
#	Line 744 | Line 742 | CCC
742		LIBS
743		CPPFLAGS
744		CCC
747	–	MPICXX
745		CC
746		CFLAGS
750	–	MPICC
747		FC
748		FCFLAGS
749	+	MPICXX
750	+	MPICC
751		MPIFC
752		CPP
753		CXXCPP'
#	Line 1294 | Line 1292 | if test "$ac_init_help" = "long"; then
1292		# Omit some internal or obsolete options to make the list less imposing.
1293		# This message is too long to be a string in the A/UX 3.1 sh.
1294		cat <<_ACEOF
1295	<	\`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
1295	>	\`configure' configures OpenMD 1.0 to adapt to many kinds of systems.
1296
1297		Usage: $0 [OPTION]... [VAR=VALUE]...
1298
#	Line 1342 | Line 1340 | Fine tuning of the installation directories:
1340		--infodir=DIR           info documentation [DATAROOTDIR/info]
1341		--localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1342		--mandir=DIR            man documentation [DATAROOTDIR/man]
1343	<	--docdir=DIR            documentation root [DATAROOTDIR/doc/oopse]
1343	>	--docdir=DIR            documentation root [DATAROOTDIR/doc/openmd]
1344		--htmldir=DIR           html documentation [DOCDIR]
1345		--dvidir=DIR            dvi documentation [DOCDIR]
1346		--pdfdir=DIR            pdf documentation [DOCDIR]
#	Line 1359 | Line 1357 | if test -n "$ac_init_help"; then
1357
1358		if test -n "$ac_init_help"; then
1359		case $ac_init_help in
1360	<	short | recursive ) echo "Configuration of OOPSE 4.0:";;
1360	>	short | recursive ) echo "Configuration of OpenMD 1.0:";;
1361		esac
1362		cat <<\_ACEOF
1363
#	Line 1367 | Line 1365 | Optional Features:
1365		--disable-option-checking  ignore unrecognized --enable/--with options
1366		--disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1367		--enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1368	<	--enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
1369	<	--enable-debug          Compile OOPSE in debug mode
1370	<	--enable-single         compile OOPSE in single precision
1368	>	--enable-openmd-home=DIR      define OpenMD home dir PREFIX/openmd
1369	>	--enable-debug          Compile OpenMD in debug mode
1370	>	--enable-single         compile OpenMD in single precision
1371		--enable-float          synonym for --enable-single
1372		--enable-doxygen        enable documentation generation with doxygen (auto)
1373		--enable-dot            use 'dot' to generate graphs in doxygen (auto)
#	Line 1397 | Line 1395 | Some influential environment variables:
1395		LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1396		nonstandard directory <lib dir>
1397		LIBS        libraries to pass to the linker, e.g. -l<library>
1398	<	CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1398	>	CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1399		you have headers in a nonstandard directory <include dir>
1402	–	MPICXX      MPI C++ compiler command
1400		CC          C compiler command
1401		CFLAGS      C compiler flags
1405	–	MPICC       MPI C compiler command
1402		FC          Fortran compiler command
1403		FCFLAGS     Fortran compiler flags
1404	+	MPICXX      MPI C++ compiler command
1405	+	MPICC       MPI C compiler command
1406		MPIFC       MPI Fortran compiler command
1407		CPP         C preprocessor
1408		CXXCPP      C++ preprocessor
#	Line 1475 | Line 1473 | if $ac_init_version; then
1473		test -n "$ac_init_help" && exit $ac_status
1474		if $ac_init_version; then
1475		cat <<\_ACEOF
1476	<	OOPSE configure 4.0
1477	<	generated by GNU Autoconf 2.64
1476	>	OpenMD configure 1.0
1477	>	generated by GNU Autoconf 2.65
1478
1479		Copyright (C) 2009 Free Software Foundation, Inc.
1480		This configure script is free software; the Free Software Foundation
#	Line 1523 | Line 1521 | fi
1521		ac_retval=1
1522		fi
1523		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1524	<	return $ac_retval
1524	>	as_fn_set_status $ac_retval
1525
1526		} # ac_fn_cxx_try_compile
1527	+
1528	+	# ac_fn_c_try_compile LINENO
1529	+	# --------------------------
1530	+	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1531	+	ac_fn_c_try_compile ()
1532	+	{
1533	+	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1534	+	rm -f conftest.$ac_objext
1535	+	if { { ac_try="$ac_compile"
1536	+	case "(($ac_try" in
1537	+	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1538	+	*) ac_try_echo=$ac_try;;
1539	+	esac
1540	+	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1541	+	$as_echo "$ac_try_echo"; } >&5
1542	+	(eval "$ac_compile") 2>conftest.err
1543	+	ac_status=$?
1544	+	if test -s conftest.err; then
1545	+	grep -v '^ *+' conftest.err >conftest.er1
1546	+	cat conftest.er1 >&5
1547	+	mv -f conftest.er1 conftest.err
1548	+	fi
1549	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1550	+	test $ac_status = 0; } && {
1551	+	test -z "$ac_c_werror_flag" ||
1552	+	test ! -s conftest.err
1553	+	} && test -s conftest.$ac_objext; then :
1554	+	ac_retval=0
1555	+	else
1556	+	$as_echo "$as_me: failed program was:" >&5
1557	+	sed 's/^/| /' conftest.$ac_ext >&5
1558	+
1559	+	ac_retval=1
1560	+	fi
1561	+	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1562	+	as_fn_set_status $ac_retval
1563	+
1564	+	} # ac_fn_c_try_compile
1565	+
1566	+	# ac_fn_fc_try_compile LINENO
1567	+	# ---------------------------
1568	+	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1569	+	ac_fn_fc_try_compile ()
1570	+	{
1571	+	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1572	+	rm -f conftest.$ac_objext
1573	+	if { { ac_try="$ac_compile"
1574	+	case "(($ac_try" in
1575	+	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1576	+	*) ac_try_echo=$ac_try;;
1577	+	esac
1578	+	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1579	+	$as_echo "$ac_try_echo"; } >&5
1580	+	(eval "$ac_compile") 2>conftest.err
1581	+	ac_status=$?
1582	+	if test -s conftest.err; then
1583	+	grep -v '^ *+' conftest.err >conftest.er1
1584	+	cat conftest.er1 >&5
1585	+	mv -f conftest.er1 conftest.err
1586	+	fi
1587	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1588	+	test $ac_status = 0; } && {
1589	+	test -z "$ac_fc_werror_flag" ||
1590	+	test ! -s conftest.err
1591	+	} && test -s conftest.$ac_objext; then :
1592	+	ac_retval=0
1593	+	else
1594	+	$as_echo "$as_me: failed program was:" >&5
1595	+	sed 's/^/| /' conftest.$ac_ext >&5
1596
1597	+	ac_retval=1
1598	+	fi
1599	+	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1600	+	as_fn_set_status $ac_retval
1601	+
1602	+	} # ac_fn_fc_try_compile
1603	+
1604		# ac_fn_cxx_try_link LINENO
1605		# -------------------------
1606		# Try to link conftest.$ac_ext, and return whether this succeeded.
#	Line 1569 | Line 1643 | fi
1643		# left behind by Apple's compiler.  We do this before executing the actions.
1644		rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1645		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1646	<	return $ac_retval
1646	>	as_fn_set_status $ac_retval
1647
1648		} # ac_fn_cxx_try_link
1649
#	Line 1639 | Line 1713 | $as_echo "$ac_res" >&6; }
1713		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1714
1715		} # ac_fn_cxx_check_func
1642	–
1643	–	# ac_fn_c_try_compile LINENO
1644	–	# --------------------------
1645	–	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1646	–	ac_fn_c_try_compile ()
1647	–	{
1648	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1649	–	rm -f conftest.$ac_objext
1650	–	if { { ac_try="$ac_compile"
1651	–	case "(($ac_try" in
1652	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1653	–	*) ac_try_echo=$ac_try;;
1654	–	esac
1655	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1656	–	$as_echo "$ac_try_echo"; } >&5
1657	–	(eval "$ac_compile") 2>conftest.err
1658	–	ac_status=$?
1659	–	if test -s conftest.err; then
1660	–	grep -v '^ *+' conftest.err >conftest.er1
1661	–	cat conftest.er1 >&5
1662	–	mv -f conftest.er1 conftest.err
1663	–	fi
1664	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1665	–	test $ac_status = 0; } && {
1666	–	test -z "$ac_c_werror_flag" ||
1667	–	test ! -s conftest.err
1668	–	} && test -s conftest.$ac_objext; then :
1669	–	ac_retval=0
1670	–	else
1671	–	$as_echo "$as_me: failed program was:" >&5
1672	–	sed 's/^/| /' conftest.$ac_ext >&5
1716
1674	–	ac_retval=1
1675	–	fi
1676	–	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1677	–	return $ac_retval
1678	–
1679	–	} # ac_fn_c_try_compile
1680	–
1717		# ac_fn_c_try_link LINENO
1718		# -----------------------
1719		# Try to link conftest.$ac_ext, and return whether this succeeded.
#	Line 1720 | Line 1756 | fi
1756		# left behind by Apple's compiler.  We do this before executing the actions.
1757		rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1758		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1759	<	return $ac_retval
1759	>	as_fn_set_status $ac_retval
1760
1761		} # ac_fn_c_try_link
1762
#	Line 1791 | Line 1827 | $as_echo "$ac_res" >&6; }
1827
1828		} # ac_fn_c_check_func
1829
1794	–	# ac_fn_fc_try_compile LINENO
1795	–	# ---------------------------
1796	–	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1797	–	ac_fn_fc_try_compile ()
1798	–	{
1799	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1800	–	rm -f conftest.$ac_objext
1801	–	if { { ac_try="$ac_compile"
1802	–	case "(($ac_try" in
1803	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1804	–	*) ac_try_echo=$ac_try;;
1805	–	esac
1806	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1807	–	$as_echo "$ac_try_echo"; } >&5
1808	–	(eval "$ac_compile") 2>conftest.err
1809	–	ac_status=$?
1810	–	if test -s conftest.err; then
1811	–	grep -v '^ *+' conftest.err >conftest.er1
1812	–	cat conftest.er1 >&5
1813	–	mv -f conftest.er1 conftest.err
1814	–	fi
1815	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1816	–	test $ac_status = 0; } && {
1817	–	test -z "$ac_fc_werror_flag" ||
1818	–	test ! -s conftest.err
1819	–	} && test -s conftest.$ac_objext; then :
1820	–	ac_retval=0
1821	–	else
1822	–	$as_echo "$as_me: failed program was:" >&5
1823	–	sed 's/^/| /' conftest.$ac_ext >&5
1824	–
1825	–	ac_retval=1
1826	–	fi
1827	–	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1828	–	return $ac_retval
1829	–
1830	–	} # ac_fn_fc_try_compile
1831	–
1830		# ac_fn_fc_try_link LINENO
1831		# ------------------------
1832		# Try to link conftest.$ac_ext, and return whether this succeeded.
#	Line 1871 | Line 1869 | fi
1869		# left behind by Apple's compiler.  We do this before executing the actions.
1870		rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1871		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1872	<	return $ac_retval
1872	>	as_fn_set_status $ac_retval
1873
1874		} # ac_fn_fc_try_link
1875
#	Line 1908 | Line 1906 | fi
1906		ac_retval=1
1907		fi
1908		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1909	<	return $ac_retval
1909	>	as_fn_set_status $ac_retval
1910
1911		} # ac_fn_c_try_cpp
1912
#	Line 2043 | Line 2041 | fi
2041		fi
2042		rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2043		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2044	<	return $ac_retval
2044	>	as_fn_set_status $ac_retval
2045
2046		} # ac_fn_c_try_run
2047
#	Line 2111 | Line 2109 | fi
2109		ac_retval=1
2110		fi
2111		eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2112	<	return $ac_retval
2112	>	as_fn_set_status $ac_retval
2113
2114		} # ac_fn_cxx_try_cpp
2115
#	Line 2281 | Line 2279 | running configure, to aid debugging if configure makes
2279		This file contains any messages produced by compilers while
2280		running configure, to aid debugging if configure makes a mistake.
2281
2282	<	It was created by OOPSE $as_me 4.0, which was
2283	<	generated by GNU Autoconf 2.64.  Invocation command line was
2282	>	It was created by OpenMD $as_me 1.0, which was
2283	>	generated by GNU Autoconf 2.65.  Invocation command line was
2284
2285		$ $0 $@
2286
#	Line 2535 | Line 2533 | do
2533		for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2534		do
2535		test "x$ac_site_file" = xNONE && continue
2536	<	if test -r "$ac_site_file"; then
2536	>	if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2537		{ $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2538		$as_echo "$as_me: loading site script $ac_site_file" >&6;}
2539		sed 's/^/| /' "$ac_site_file" >&5
#	Line 2544 | Line 2542 | if test -r "$cache_file"; then
2542		done
2543
2544		if test -r "$cache_file"; then
2545	<	# Some versions of bash will fail to source /dev/null (special
2546	<	# files actually), so we avoid doing that.
2547	<	if test -f "$cache_file"; then
2545	>	# Some versions of bash will fail to source /dev/null (special files
2546	>	# actually), so we avoid doing that.  DJGPP emulates it as a regular file.
2547	>	if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2548		{ $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2549		$as_echo "$as_me: loading cache $cache_file" >&6;}
2550		case $cache_file in
#	Line 2969 | Line 2967 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2967
2968
2969		# set program name
2970	<	PROGNAME="oopse"
2970	>	PROGNAME="openmd"
2971
2972
2973
2974
2975		OBJEXT=".$OBJEXT"
2976
2977	<	OOPSE=oopse
2977	>	OPENMD=openmd
2978
2979		if test "x${prefix}" = "xNONE"
2980		then
2981	<	OOPSE_HOME=${ac_default_prefix}/oopse
2981	>	OPENMD_HOME=${ac_default_prefix}/openmd
2982		else
2983	<	OOPSE_HOME=${prefix}/oopse
2983	>	OPENMD_HOME=${prefix}/openmd
2984		fi
2985	<	# Check whether --enable-oopse-home was given.
2986	<	if test "${enable_oopse_home+set}" = set; then :
2987	<	enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
2985	>	# Check whether --enable-openmd-home was given.
2986	>	if test "${enable_openmd_home+set}" = set; then :
2987	>	enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2988		fi
2989
2990
#	Line 3027 | Line 3025 | fi
3025
3026		fi
3027
3030	–	if test x"$CC" != x; then
3031	–	for ac_prog in $CC
3032	–	do
3033	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
3034	–	set dummy $ac_prog; ac_word=$2
3035	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3036	–	$as_echo_n "checking for $ac_word... " >&6; }
3037	–	if test "${ac_cv_prog_ac_cc_set+set}" = set; then :
3038	–	$as_echo_n "(cached) " >&6
3039	–	else
3040	–	if test -n "$ac_cc_set"; then
3041	–	ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
3042	–	else
3043	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3044	–	for as_dir in $PATH
3045	–	do
3046	–	IFS=$as_save_IFS
3047	–	test -z "$as_dir" && as_dir=.
3048	–	for ac_exec_ext in '' $ac_executable_extensions; do
3049	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3050	–	ac_cv_prog_ac_cc_set="$ac_prog"
3051	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3052	–	break 2
3053	–	fi
3054	–	done
3055	–	done
3056	–	IFS=$as_save_IFS
3057	–
3058	–	fi
3059	–	fi
3060	–	ac_cc_set=$ac_cv_prog_ac_cc_set
3061	–	if test -n "$ac_cc_set"; then
3062	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_set" >&5
3063	–	$as_echo "$ac_cc_set" >&6; }
3064	–	else
3065	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3066	–	$as_echo "no" >&6; }
3067	–	fi
3068	–
3069	–
3070	–	test -n "$ac_cc_set" && break
3071	–	done
3072	–	test -n "$ac_cc_set" || ac_cc_set="no"
3073	–
3074	–	if test $ac_cc_set != no; then :
3075	–
3076	–	# Extract the first word of "$ac_cc_set", so it can be a program name with args.
3077	–	set dummy $ac_cc_set; ac_word=$2
3078	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3079	–	$as_echo_n "checking for $ac_word... " >&6; }
3080	–	if test "${ac_cv_path_ac_cc_path+set}" = set; then :
3081	–	$as_echo_n "(cached) " >&6
3082	–	else
3083	–	case $ac_cc_path in
3084	–	[\\/]* | ?:[\\/]*)
3085	–	ac_cv_path_ac_cc_path="$ac_cc_path" # Let the user override the test with a path.
3086	–	;;
3087	–	*)
3088	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3089	–	for as_dir in $PATH
3090	–	do
3091	–	IFS=$as_save_IFS
3092	–	test -z "$as_dir" && as_dir=.
3093	–	for ac_exec_ext in '' $ac_executable_extensions; do
3094	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3095	–	ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
3096	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3097	–	break 2
3098	–	fi
3099	–	done
3100	–	done
3101	–	IFS=$as_save_IFS
3102	–
3103	–	test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
3104	–	;;
3105	–	esac
3106	–	fi
3107	–	ac_cc_path=$ac_cv_path_ac_cc_path
3108	–	if test -n "$ac_cc_path"; then
3109	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_path" >&5
3110	–	$as_echo "$ac_cc_path" >&6; }
3111	–	else
3112	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3113	–	$as_echo "no" >&6; }
3114	–	fi
3115	–
3116	–
3117	–	else
3118	–
3119	–	as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3120	–	fi
3121	–
3122	–	if test $ac_cc_path != no; then :
3123	–
3124	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CC as C compiler" >&5
3125	–	$as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3126	–	MPICC=$CC
3127	–
3128	–	else
3129	–
3130	–	as_fn_error "Can't find path to user-specified C compiler $CC" "$LINENO" 5
3131	–	fi
3132	–	fi
3133	–
3134	–	if test x"$CXX" != x; then
3135	–	for ac_prog in $CXX
3136	–	do
3137	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
3138	–	set dummy $ac_prog; ac_word=$2
3139	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3140	–	$as_echo_n "checking for $ac_word... " >&6; }
3141	–	if test "${ac_cv_prog_ac_cxx_set+set}" = set; then :
3142	–	$as_echo_n "(cached) " >&6
3143	–	else
3144	–	if test -n "$ac_cxx_set"; then
3145	–	ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
3146	–	else
3147	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3148	–	for as_dir in $PATH
3149	–	do
3150	–	IFS=$as_save_IFS
3151	–	test -z "$as_dir" && as_dir=.
3152	–	for ac_exec_ext in '' $ac_executable_extensions; do
3153	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3154	–	ac_cv_prog_ac_cxx_set="$ac_prog"
3155	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3156	–	break 2
3157	–	fi
3158	–	done
3159	–	done
3160	–	IFS=$as_save_IFS
3161	–
3162	–	fi
3163	–	fi
3164	–	ac_cxx_set=$ac_cv_prog_ac_cxx_set
3165	–	if test -n "$ac_cxx_set"; then
3166	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_set" >&5
3167	–	$as_echo "$ac_cxx_set" >&6; }
3168	–	else
3169	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3170	–	$as_echo "no" >&6; }
3171	–	fi
3172	–
3173	–
3174	–	test -n "$ac_cxx_set" && break
3175	–	done
3176	–	test -n "$ac_cxx_set" || ac_cxx_set="no"
3177	–
3178	–	if test $ac_cxx_set != no; then :
3179	–
3180	–	# Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3181	–	set dummy $ac_cxx_set; ac_word=$2
3182	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3183	–	$as_echo_n "checking for $ac_word... " >&6; }
3184	–	if test "${ac_cv_path_ac_cxx_path+set}" = set; then :
3185	–	$as_echo_n "(cached) " >&6
3186	–	else
3187	–	case $ac_cxx_path in
3188	–	[\\/]* | ?:[\\/]*)
3189	–	ac_cv_path_ac_cxx_path="$ac_cxx_path" # Let the user override the test with a path.
3190	–	;;
3191	–	*)
3192	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3193	–	for as_dir in $PATH
3194	–	do
3195	–	IFS=$as_save_IFS
3196	–	test -z "$as_dir" && as_dir=.
3197	–	for ac_exec_ext in '' $ac_executable_extensions; do
3198	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3199	–	ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3200	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3201	–	break 2
3202	–	fi
3203	–	done
3204	–	done
3205	–	IFS=$as_save_IFS
3206	–
3207	–	test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3208	–	;;
3209	–	esac
3210	–	fi
3211	–	ac_cxx_path=$ac_cv_path_ac_cxx_path
3212	–	if test -n "$ac_cxx_path"; then
3213	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_path" >&5
3214	–	$as_echo "$ac_cxx_path" >&6; }
3215	–	else
3216	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3217	–	$as_echo "no" >&6; }
3218	–	fi
3219	–
3220	–
3221	–	else
3222	–
3223	–	as_fn_error "Specified C++ compiler $CXX doesn't seem to exist!" "$LINENO" 5
3224	–	fi
3225	–
3226	–	if test $ac_cxx_path != no; then :
3227	–
3228	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CXX as C++ compiler" >&5
3229	–	$as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3230	–	MPICXX=$CXX
3231	–
3232	–	else
3233	–
3234	–	as_fn_error "Can't find path to user-specified C++ compiler $CXX" "$LINENO" 5
3235	–	fi
3236	–	fi
3237	–
3238	–	if test x"$FC" != x; then
3239	–	for ac_prog in $FC
3240	–	do
3241	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
3242	–	set dummy $ac_prog; ac_word=$2
3243	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3244	–	$as_echo_n "checking for $ac_word... " >&6; }
3245	–	if test "${ac_cv_prog_ac_fc_set+set}" = set; then :
3246	–	$as_echo_n "(cached) " >&6
3247	–	else
3248	–	if test -n "$ac_fc_set"; then
3249	–	ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3250	–	else
3251	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3252	–	for as_dir in $PATH
3253	–	do
3254	–	IFS=$as_save_IFS
3255	–	test -z "$as_dir" && as_dir=.
3256	–	for ac_exec_ext in '' $ac_executable_extensions; do
3257	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3258	–	ac_cv_prog_ac_fc_set="$ac_prog"
3259	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3260	–	break 2
3261	–	fi
3262	–	done
3263	–	done
3264	–	IFS=$as_save_IFS
3265	–
3266	–	fi
3267	–	fi
3268	–	ac_fc_set=$ac_cv_prog_ac_fc_set
3269	–	if test -n "$ac_fc_set"; then
3270	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_set" >&5
3271	–	$as_echo "$ac_fc_set" >&6; }
3272	–	else
3273	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3274	–	$as_echo "no" >&6; }
3275	–	fi
3276	–
3277	–
3278	–	test -n "$ac_fc_set" && break
3279	–	done
3280	–	test -n "$ac_fc_set" || ac_fc_set="no"
3281	–
3282	–	if test $ac_fc_set != no; then :
3283	–
3284	–	# Extract the first word of "$ac_fc_set", so it can be a program name with args.
3285	–	set dummy $ac_fc_set; ac_word=$2
3286	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3287	–	$as_echo_n "checking for $ac_word... " >&6; }
3288	–	if test "${ac_cv_path_ac_fc_path+set}" = set; then :
3289	–	$as_echo_n "(cached) " >&6
3290	–	else
3291	–	case $ac_fc_path in
3292	–	[\\/]* | ?:[\\/]*)
3293	–	ac_cv_path_ac_fc_path="$ac_fc_path" # Let the user override the test with a path.
3294	–	;;
3295	–	*)
3296	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3297	–	for as_dir in $PATH
3298	–	do
3299	–	IFS=$as_save_IFS
3300	–	test -z "$as_dir" && as_dir=.
3301	–	for ac_exec_ext in '' $ac_executable_extensions; do
3302	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3303	–	ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3304	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3305	–	break 2
3306	–	fi
3307	–	done
3308	–	done
3309	–	IFS=$as_save_IFS
3310	–
3311	–	test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
3312	–	;;
3313	–	esac
3314	–	fi
3315	–	ac_fc_path=$ac_cv_path_ac_fc_path
3316	–	if test -n "$ac_fc_path"; then
3317	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_path" >&5
3318	–	$as_echo "$ac_fc_path" >&6; }
3319	–	else
3320	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3321	–	$as_echo "no" >&6; }
3322	–	fi
3323	–
3324	–
3325	–	else
3326	–
3327	–	as_fn_error "Specified Fortran compiler $FC doesn't seem to exist!" "$LINENO" 5
3328	–	fi
3329	–
3330	–	if test $ac_fc_path != no; then :
3331	–
3332	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $FC as Fortran compiler" >&5
3333	–	$as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3334	–	MPIFC=$FC
3335	–
3336	–	else
3337	–
3338	–	as_fn_error "Can't find path to user-specified Fortran compiler $FC" "$LINENO" 5
3339	–	fi
3340	–	fi
3341	–
3342	–
3028		ac_ext=cpp
3029		ac_cpp='$CXXCPP $CPPFLAGS'
3030		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3031		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3032		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3348	–
3349	–	ac_ext=cpp
3350	–	ac_cpp='$CXXCPP $CPPFLAGS'
3351	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3352	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3353	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3033		if test -z "$CXX"; then
3034		if test -n "$CCC"; then
3035		CXX=$CCC
3036		else
3037		if test -n "$ac_tool_prefix"; then
3038	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3038	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
3039		do
3040		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3041		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
#	Line 3400 | Line 3079 | if test -z "$CXX"; then
3079		fi
3080		if test -z "$CXX"; then
3081		ac_ct_CXX=$CXX
3082	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3082	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
3083		do
3084		# Extract the first word of "$ac_prog", so it can be a program name with args.
3085		set dummy $ac_prog; ac_word=$2
#	Line 3476 | Line 3155 | $as_echo "$ac_try_echo"; } >&5
3155		... rest of stderr output deleted ...
3156		10q' conftest.err >conftest.er1
3157		cat conftest.er1 >&5
3479	–	rm -f conftest.er1 conftest.err
3158		fi
3159	+	rm -f conftest.er1 conftest.err
3160		$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3161		test $ac_status = 0; }
3162		done
3163
3164		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3165		/* end confdefs.h.  */
3166	<	#include <stdio.h>
3166	>
3167		int
3168		main ()
3169		{
3491	–	FILE *f = fopen ("conftest.out", "w");
3492	–	return ferror (f) || fclose (f) != 0;
3170
3171		;
3172		return 0;
3173		}
3174		_ACEOF
3175		ac_clean_files_save=$ac_clean_files
3176	<	ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out conftest.out"
3176	>	ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3177		# Try to create an executable without -o first, disregard a.out.
3178		# It will help us diagnose broken compilers, and finding out an intuition
3179		# of exeext.
3180	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3181	<	$as_echo_n "checking for C++ compiler default output file name... " >&6; }
3180	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3181	>	$as_echo_n "checking whether the C++ compiler works... " >&6; }
3182		ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3183
3184		# The possible output files:
#	Line 3526 | Line 3203 | $as_echo "$ac_try_echo"; } >&5
3203		$as_echo "$ac_try_echo"; } >&5
3204		(eval "$ac_link_default") 2>&5
3205		ac_status=$?
3206	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3207	<	test $ac_status = 0; }; then :
3208	<	# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3209	<	# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3210	<	# in a Makefile.  We should not override ac_cv_exeext if it was cached,
3211	<	# so that the user can short-circuit this test for compilers unknown to
3212	<	# Autoconf.
3213	<	for ac_file in $ac_files ''
3214	<	do
3215	<	test -f "$ac_file" || continue
3216	<	case $ac_file in
3217	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3218	<	;;
3219	<	[ab].out )
3220	<	# We found the default executable, but exeext='' is most
3221	<	# certainly right.
3222	<	break;;
3223	<	*.* )
3224	<	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3225	<	then :; else
3226	<	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3227	<	fi
3228	<	# We set ac_cv_exeext here because the later test for it is not
3229	<	# safe: cross compilers may not add the suffix if given an `-o'
3230	<	# argument, so we may need to know it at that point already.
3231	<	# Even if this section looks crufty: it has the advantage of
3232	<	# actually working.
3233	<	break;;
3234	<	* )
3235	<	break;;
3236	<	esac
3560	<	done
3561	<	test "$ac_cv_exeext" = no && ac_cv_exeext=
3562	<
3563	<	else
3564	<	ac_file=''
3565	<	fi
3566	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3567	<	$as_echo "$ac_file" >&6; }
3568	<	if test -z "$ac_file"; then :
3569	<	$as_echo "$as_me: failed program was:" >&5
3570	<	sed 's/^/| /' conftest.$ac_ext >&5
3571	<
3572	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3573	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3574	<	{ as_fn_set_status 77
3575	<	as_fn_error "C++ compiler cannot create executables
3576	<	See \`config.log' for more details." "$LINENO" 5; }; }
3577	<	fi
3578	<	ac_exeext=$ac_cv_exeext
3579	<
3580	<	# Check that the compiler produces executables we can run.  If not, either
3581	<	# the compiler is broken, or we cross compile.
3582	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3583	<	$as_echo_n "checking whether the C++ compiler works... " >&6; }
3584	<	# If not cross compiling, check that we can run a simple program.
3585	<	if test "$cross_compiling" != yes; then
3586	<	if { ac_try='./$ac_file'
3587	<	{ { case "(($ac_try" in
3588	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3589	<	*) ac_try_echo=$ac_try;;
3590	<	esac
3591	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3592	<	$as_echo "$ac_try_echo"; } >&5
3593	<	(eval "$ac_try") 2>&5
3594	<	ac_status=$?
3595	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3596	<	test $ac_status = 0; }; }; then
3597	<	cross_compiling=no
3598	<	else
3599	<	if test "$cross_compiling" = maybe; then
3600	<	cross_compiling=yes
3601	<	else
3602	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3603	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3604	<	as_fn_error "cannot run C++ compiled programs.
3605	<	If you meant to cross compile, use \`--host'.
3606	<	See \`config.log' for more details." "$LINENO" 5; }
3607	<	fi
3608	<	fi
3609	<	fi
3610	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3611	<	$as_echo "yes" >&6; }
3612	<
3613	<	rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out conftest.out
3614	<	ac_clean_files=$ac_clean_files_save
3615	<	# Check that the compiler produces executables we can run.  If not, either
3616	<	# the compiler is broken, or we cross compile.
3617	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3618	<	$as_echo_n "checking whether we are cross compiling... " >&6; }
3619	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3620	<	$as_echo "$cross_compiling" >&6; }
3621	<
3622	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3623	<	$as_echo_n "checking for suffix of executables... " >&6; }
3624	<	if { { ac_try="$ac_link"
3625	<	case "(($ac_try" in
3626	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3627	<	*) ac_try_echo=$ac_try;;
3628	<	esac
3629	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3630	<	$as_echo "$ac_try_echo"; } >&5
3631	<	(eval "$ac_link") 2>&5
3632	<	ac_status=$?
3633	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3634	<	test $ac_status = 0; }; then :
3635	<	# If both `conftest.exe' and `conftest' are `present' (well, observable)
3636	<	# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3637	<	# work properly (i.e., refer to `conftest.exe'), while it won't with
3638	<	# `rm'.
3639	<	for ac_file in conftest.exe conftest conftest.*; do
3640	<	test -f "$ac_file" || continue
3641	<	case $ac_file in
3642	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3643	<	*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3644	<	break;;
3645	<	* ) break;;
3646	<	esac
3647	<	done
3648	<	else
3649	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3650	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3651	<	as_fn_error "cannot compute suffix of executables: cannot compile and link
3652	<	See \`config.log' for more details." "$LINENO" 5; }
3653	<	fi
3654	<	rm -f conftest$ac_cv_exeext
3655	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3656	<	$as_echo "$ac_cv_exeext" >&6; }
3657	<
3658	<	rm -f conftest.$ac_ext
3659	<	EXEEXT=$ac_cv_exeext
3660	<	ac_exeext=$EXEEXT
3661	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3662	<	$as_echo_n "checking for suffix of object files... " >&6; }
3663	<	if test "${ac_cv_objext+set}" = set; then :
3664	<	$as_echo_n "(cached) " >&6
3665	<	else
3666	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3667	<	/* end confdefs.h.  */
3668	<
3669	<	int
3670	<	main ()
3671	<	{
3672	<
3673	<	;
3674	<	return 0;
3675	<	}
3676	<	_ACEOF
3677	<	rm -f conftest.o conftest.obj
3678	<	if { { ac_try="$ac_compile"
3679	<	case "(($ac_try" in
3680	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3681	<	*) ac_try_echo=$ac_try;;
3682	<	esac
3683	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3684	<	$as_echo "$ac_try_echo"; } >&5
3685	<	(eval "$ac_compile") 2>&5
3686	<	ac_status=$?
3687	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3688	<	test $ac_status = 0; }; then :
3689	<	for ac_file in conftest.o conftest.obj conftest.*; do
3690	<	test -f "$ac_file" || continue;
3691	<	case $ac_file in
3692	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3693	<	*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3694	<	break;;
3695	<	esac
3696	<	done
3697	<	else
3698	<	$as_echo "$as_me: failed program was:" >&5
3699	<	sed 's/^/| /' conftest.$ac_ext >&5
3700	<
3701	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3702	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3703	<	as_fn_error "cannot compute suffix of object files: cannot compile
3704	<	See \`config.log' for more details." "$LINENO" 5; }
3705	<	fi
3706	<	rm -f conftest.$ac_cv_objext conftest.$ac_ext
3707	<	fi
3708	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3709	<	$as_echo "$ac_cv_objext" >&6; }
3710	<	OBJEXT=$ac_cv_objext
3711	<	ac_objext=$OBJEXT
3712	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3713	<	$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3714	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3715	<	$as_echo_n "(cached) " >&6
3716	<	else
3717	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3718	<	/* end confdefs.h.  */
3719	<
3720	<	int
3721	<	main ()
3722	<	{
3723	<	#ifndef __GNUC__
3724	<	choke me
3725	<	#endif
3726	<
3727	<	;
3728	<	return 0;
3729	<	}
3730	<	_ACEOF
3731	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3732	<	ac_compiler_gnu=yes
3733	<	else
3734	<	ac_compiler_gnu=no
3735	<	fi
3736	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3737	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3738	<
3739	<	fi
3740	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3741	<	$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3742	<	if test $ac_compiler_gnu = yes; then
3743	<	GXX=yes
3744	<	else
3745	<	GXX=
3746	<	fi
3747	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
3748	<	ac_save_CXXFLAGS=$CXXFLAGS
3749	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3750	<	$as_echo_n "checking whether $CXX accepts -g... " >&6; }
3751	<	if test "${ac_cv_prog_cxx_g+set}" = set; then :
3752	<	$as_echo_n "(cached) " >&6
3753	<	else
3754	<	ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3755	<	ac_cxx_werror_flag=yes
3756	<	ac_cv_prog_cxx_g=no
3757	<	CXXFLAGS="-g"
3758	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3759	<	/* end confdefs.h.  */
3760	<
3761	<	int
3762	<	main ()
3763	<	{
3764	<
3765	<	;
3766	<	return 0;
3767	<	}
3768	<	_ACEOF
3769	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3770	<	ac_cv_prog_cxx_g=yes
3771	<	else
3772	<	CXXFLAGS=""
3773	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3774	<	/* end confdefs.h.  */
3775	<
3776	<	int
3777	<	main ()
3778	<	{
3779	<
3780	<	;
3781	<	return 0;
3782	<	}
3783	<	_ACEOF
3784	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3785	<
3786	<	else
3787	<	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3788	<	CXXFLAGS="-g"
3789	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3790	<	/* end confdefs.h.  */
3791	<
3792	<	int
3793	<	main ()
3794	<	{
3795	<
3796	<	;
3797	<	return 0;
3798	<	}
3799	<	_ACEOF
3800	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3801	<	ac_cv_prog_cxx_g=yes
3802	<	fi
3803	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3804	<	fi
3805	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3806	<	fi
3807	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3808	<	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3809	<	fi
3810	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3811	<	$as_echo "$ac_cv_prog_cxx_g" >&6; }
3812	<	if test "$ac_test_CXXFLAGS" = set; then
3813	<	CXXFLAGS=$ac_save_CXXFLAGS
3814	<	elif test $ac_cv_prog_cxx_g = yes; then
3815	<	if test "$GXX" = yes; then
3816	<	CXXFLAGS="-g -O2"
3817	<	else
3818	<	CXXFLAGS="-g"
3819	<	fi
3820	<	else
3821	<	if test "$GXX" = yes; then
3822	<	CXXFLAGS="-O2"
3823	<	else
3824	<	CXXFLAGS=
3825	<	fi
3826	<	fi
3827	<	ac_ext=cpp
3828	<	ac_cpp='$CXXCPP $CPPFLAGS'
3829	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3830	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3831	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3832	<
3833	<
3834	<
3835	<
3836	<
3837	<
3838	<
3839	<	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3840	<	do
3841	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3842	<	set dummy $ac_prog; ac_word=$2
3843	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3844	<	$as_echo_n "checking for $ac_word... " >&6; }
3845	<	if test "${ac_cv_prog_MPICXX+set}" = set; then :
3846	<	$as_echo_n "(cached) " >&6
3847	<	else
3848	<	if test -n "$MPICXX"; then
3849	<	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3850	<	else
3851	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3852	<	for as_dir in $PATH
3853	<	do
3854	<	IFS=$as_save_IFS
3855	<	test -z "$as_dir" && as_dir=.
3856	<	for ac_exec_ext in '' $ac_executable_extensions; do
3857	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3858	<	ac_cv_prog_MPICXX="$ac_prog"
3859	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3860	<	break 2
3861	<	fi
3862	<	done
3863	<	done
3864	<	IFS=$as_save_IFS
3865	<
3866	<	fi
3867	<	fi
3868	<	MPICXX=$ac_cv_prog_MPICXX
3869	<	if test -n "$MPICXX"; then
3870	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3871	<	$as_echo "$MPICXX" >&6; }
3872	<	else
3873	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3874	<	$as_echo "no" >&6; }
3875	<	fi
3876	<
3877	<
3878	<	test -n "$MPICXX" && break
3879	<	done
3880	<	test -n "$MPICXX" || MPICXX="$CXX"
3881	<
3882	<	ax_mpi_save_CXX="$CXX"
3883	<	CXX="$MPICXX"
3884	<
3885	<
3886	<
3887	<	if test x = x"$MPILIBS"; then
3888	<	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3889	<	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3890	<	MPILIBS=" "
3891	<	fi
3892	<
3893	<	fi
3894	<
3895	<	if test x = x"$MPILIBS"; then
3896	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3897	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3898	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3899	<	$as_echo_n "(cached) " >&6
3900	<	else
3901	<	ac_check_lib_save_LIBS=$LIBS
3902	<	LIBS="-lmpi  $LIBS"
3903	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3904	<	/* end confdefs.h.  */
3905	<
3906	<	/* Override any GCC internal prototype to avoid an error.
3907	<	Use char because int might match the return type of a GCC
3908	<	builtin and then its argument prototype would still apply.  */
3909	<	#ifdef __cplusplus
3910	<	extern "C"
3911	<	#endif
3912	<	char MPI_Init ();
3913	<	int
3914	<	main ()
3915	<	{
3916	<	return MPI_Init ();
3917	<	;
3918	<	return 0;
3919	<	}
3920	<	_ACEOF
3921	<	if ac_fn_cxx_try_link "$LINENO"; then :
3922	<	ac_cv_lib_mpi_MPI_Init=yes
3923	<	else
3924	<	ac_cv_lib_mpi_MPI_Init=no
3925	<	fi
3926	<	rm -f core conftest.err conftest.$ac_objext \
3927	<	conftest$ac_exeext conftest.$ac_ext
3928	<	LIBS=$ac_check_lib_save_LIBS
3929	<	fi
3930	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3931	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3932	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
3933	<	MPILIBS="-lmpi"
3934	<	fi
3935	<
3936	<	fi
3937	<	if test x = x"$MPILIBS"; then
3938	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3939	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3940	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
3941	<	$as_echo_n "(cached) " >&6
3942	<	else
3943	<	ac_check_lib_save_LIBS=$LIBS
3944	<	LIBS="-lmpich  $LIBS"
3945	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3946	<	/* end confdefs.h.  */
3947	<
3948	<	/* Override any GCC internal prototype to avoid an error.
3949	<	Use char because int might match the return type of a GCC
3950	<	builtin and then its argument prototype would still apply.  */
3951	<	#ifdef __cplusplus
3952	<	extern "C"
3953	<	#endif
3954	<	char MPI_Init ();
3955	<	int
3956	<	main ()
3957	<	{
3958	<	return MPI_Init ();
3959	<	;
3960	<	return 0;
3961	<	}
3962	<	_ACEOF
3963	<	if ac_fn_cxx_try_link "$LINENO"; then :
3964	<	ac_cv_lib_mpich_MPI_Init=yes
3965	<	else
3966	<	ac_cv_lib_mpich_MPI_Init=no
3967	<	fi
3968	<	rm -f core conftest.err conftest.$ac_objext \
3969	<	conftest$ac_exeext conftest.$ac_ext
3970	<	LIBS=$ac_check_lib_save_LIBS
3971	<	fi
3972	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
3973	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
3974	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
3975	<	MPILIBS="-lmpich"
3976	<	fi
3977	<
3978	<	fi
3979	<
3980	<	if test x != x"$MPILIBS"; then
3981	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
3982	<	$as_echo_n "checking for mpi.h... " >&6; }
3983	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3984	<	/* end confdefs.h.  */
3985	<	#include <mpi.h>
3986	<	int
3987	<	main ()
3988	<	{
3989	<
3990	<	;
3991	<	return 0;
3992	<	}
3993	<	_ACEOF
3994	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3995	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3996	<	$as_echo "yes" >&6; }
3997	<	else
3998	<	MPILIBS=""
3999	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4000	<	$as_echo "no" >&6; }
4001	<	fi
4002	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4003	<	fi
4004	<
4005	<	CXX="$ax_mpi_save_CXX"
4006	<
4007	<
4008	<
4009	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4010	<	if test x = x"$MPILIBS"; then
4011	<	USE_MPI="no"
4012	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&5
4013	<	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&2;}
4014	<	:
4015	<	else
4016	<	USE_MPI="yes"
4017	<	:
4018	<	fi
4019	<
4020	<	ac_ext=c
4021	<	ac_cpp='$CPP $CPPFLAGS'
4022	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4023	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4024	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4025	<	if test -n "$ac_tool_prefix"; then
4026	<	# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4027	<	set dummy ${ac_tool_prefix}gcc; ac_word=$2
4028	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4029	<	$as_echo_n "checking for $ac_word... " >&6; }
4030	<	if test "${ac_cv_prog_CC+set}" = set; then :
4031	<	$as_echo_n "(cached) " >&6
4032	<	else
4033	<	if test -n "$CC"; then
4034	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4035	<	else
4036	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4037	<	for as_dir in $PATH
4038	<	do
4039	<	IFS=$as_save_IFS
4040	<	test -z "$as_dir" && as_dir=.
4041	<	for ac_exec_ext in '' $ac_executable_extensions; do
4042	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4043	<	ac_cv_prog_CC="${ac_tool_prefix}gcc"
4044	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4045	<	break 2
4046	<	fi
4047	<	done
4048	<	done
4049	<	IFS=$as_save_IFS
4050	<
4051	<	fi
4052	<	fi
4053	<	CC=$ac_cv_prog_CC
4054	<	if test -n "$CC"; then
4055	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4056	<	$as_echo "$CC" >&6; }
4057	<	else
4058	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4059	<	$as_echo "no" >&6; }
4060	<	fi
4061	<
4062	<
4063	<	fi
4064	<	if test -z "$ac_cv_prog_CC"; then
4065	<	ac_ct_CC=$CC
4066	<	# Extract the first word of "gcc", so it can be a program name with args.
4067	<	set dummy gcc; ac_word=$2
4068	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4069	<	$as_echo_n "checking for $ac_word... " >&6; }
4070	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4071	<	$as_echo_n "(cached) " >&6
4072	<	else
4073	<	if test -n "$ac_ct_CC"; then
4074	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4075	<	else
4076	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4077	<	for as_dir in $PATH
4078	<	do
4079	<	IFS=$as_save_IFS
4080	<	test -z "$as_dir" && as_dir=.
4081	<	for ac_exec_ext in '' $ac_executable_extensions; do
4082	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4083	<	ac_cv_prog_ac_ct_CC="gcc"
4084	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4085	<	break 2
4086	<	fi
4087	<	done
4088	<	done
4089	<	IFS=$as_save_IFS
4090	<
4091	<	fi
4092	<	fi
4093	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4094	<	if test -n "$ac_ct_CC"; then
4095	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4096	<	$as_echo "$ac_ct_CC" >&6; }
4097	<	else
4098	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4099	<	$as_echo "no" >&6; }
4100	<	fi
4101	<
4102	<	if test "x$ac_ct_CC" = x; then
4103	<	CC=""
4104	<	else
4105	<	case $cross_compiling:$ac_tool_warned in
4106	<	yes:)
4107	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4108	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4109	<	ac_tool_warned=yes ;;
4110	<	esac
4111	<	CC=$ac_ct_CC
4112	<	fi
4113	<	else
4114	<	CC="$ac_cv_prog_CC"
4115	<	fi
4116	<
4117	<	if test -z "$CC"; then
4118	<	if test -n "$ac_tool_prefix"; then
4119	<	# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4120	<	set dummy ${ac_tool_prefix}cc; ac_word=$2
4121	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4122	<	$as_echo_n "checking for $ac_word... " >&6; }
4123	<	if test "${ac_cv_prog_CC+set}" = set; then :
4124	<	$as_echo_n "(cached) " >&6
4125	<	else
4126	<	if test -n "$CC"; then
4127	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4128	<	else
4129	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4130	<	for as_dir in $PATH
4131	<	do
4132	<	IFS=$as_save_IFS
4133	<	test -z "$as_dir" && as_dir=.
4134	<	for ac_exec_ext in '' $ac_executable_extensions; do
4135	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4136	<	ac_cv_prog_CC="${ac_tool_prefix}cc"
4137	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4138	<	break 2
4139	<	fi
4140	<	done
4141	<	done
4142	<	IFS=$as_save_IFS
4143	<
4144	<	fi
4145	<	fi
4146	<	CC=$ac_cv_prog_CC
4147	<	if test -n "$CC"; then
4148	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4149	<	$as_echo "$CC" >&6; }
4150	<	else
4151	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4152	<	$as_echo "no" >&6; }
4153	<	fi
4154	<
4155	<
4156	<	fi
4157	<	fi
4158	<	if test -z "$CC"; then
4159	<	# Extract the first word of "cc", so it can be a program name with args.
4160	<	set dummy cc; ac_word=$2
4161	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4162	<	$as_echo_n "checking for $ac_word... " >&6; }
4163	<	if test "${ac_cv_prog_CC+set}" = set; then :
4164	<	$as_echo_n "(cached) " >&6
4165	<	else
4166	<	if test -n "$CC"; then
4167	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4168	<	else
4169	<	ac_prog_rejected=no
4170	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4171	<	for as_dir in $PATH
4172	<	do
4173	<	IFS=$as_save_IFS
4174	<	test -z "$as_dir" && as_dir=.
4175	<	for ac_exec_ext in '' $ac_executable_extensions; do
4176	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4177	<	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4178	<	ac_prog_rejected=yes
4179	<	continue
4180	<	fi
4181	<	ac_cv_prog_CC="cc"
4182	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4183	<	break 2
4184	<	fi
4185	<	done
4186	<	done
4187	<	IFS=$as_save_IFS
4188	<
4189	<	if test $ac_prog_rejected = yes; then
4190	<	# We found a bogon in the path, so make sure we never use it.
4191	<	set dummy $ac_cv_prog_CC
4192	<	shift
4193	<	if test $# != 0; then
4194	<	# We chose a different compiler from the bogus one.
4195	<	# However, it has the same basename, so the bogon will be chosen
4196	<	# first if we set CC to just the basename; use the full file name.
4197	<	shift
4198	<	ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4199	<	fi
4200	<	fi
4201	<	fi
4202	<	fi
4203	<	CC=$ac_cv_prog_CC
4204	<	if test -n "$CC"; then
4205	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4206	<	$as_echo "$CC" >&6; }
4207	<	else
4208	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4209	<	$as_echo "no" >&6; }
4210	<	fi
4211	<
4212	<
4213	<	fi
4214	<	if test -z "$CC"; then
4215	<	if test -n "$ac_tool_prefix"; then
4216	<	for ac_prog in cl.exe
4217	<	do
4218	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4219	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4220	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4221	<	$as_echo_n "checking for $ac_word... " >&6; }
4222	<	if test "${ac_cv_prog_CC+set}" = set; then :
4223	<	$as_echo_n "(cached) " >&6
4224	<	else
4225	<	if test -n "$CC"; then
4226	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4227	<	else
4228	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4229	<	for as_dir in $PATH
4230	<	do
4231	<	IFS=$as_save_IFS
4232	<	test -z "$as_dir" && as_dir=.
4233	<	for ac_exec_ext in '' $ac_executable_extensions; do
4234	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4235	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4236	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4237	<	break 2
4238	<	fi
4239	<	done
4240	<	done
4241	<	IFS=$as_save_IFS
4242	<
4243	<	fi
4244	<	fi
4245	<	CC=$ac_cv_prog_CC
4246	<	if test -n "$CC"; then
4247	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4248	<	$as_echo "$CC" >&6; }
4249	<	else
4250	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4251	<	$as_echo "no" >&6; }
4252	<	fi
4253	<
4254	<
4255	<	test -n "$CC" && break
4256	<	done
4257	<	fi
4258	<	if test -z "$CC"; then
4259	<	ac_ct_CC=$CC
4260	<	for ac_prog in cl.exe
4261	<	do
4262	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4263	<	set dummy $ac_prog; ac_word=$2
4264	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4265	<	$as_echo_n "checking for $ac_word... " >&6; }
4266	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4267	<	$as_echo_n "(cached) " >&6
4268	<	else
4269	<	if test -n "$ac_ct_CC"; then
4270	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4271	<	else
4272	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4273	<	for as_dir in $PATH
4274	<	do
4275	<	IFS=$as_save_IFS
4276	<	test -z "$as_dir" && as_dir=.
4277	<	for ac_exec_ext in '' $ac_executable_extensions; do
4278	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4279	<	ac_cv_prog_ac_ct_CC="$ac_prog"
4280	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4281	<	break 2
4282	<	fi
4283	<	done
4284	<	done
4285	<	IFS=$as_save_IFS
4286	<
4287	<	fi
4288	<	fi
4289	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4290	<	if test -n "$ac_ct_CC"; then
4291	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4292	<	$as_echo "$ac_ct_CC" >&6; }
4293	<	else
4294	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4295	<	$as_echo "no" >&6; }
4296	<	fi
4297	<
4298	<
4299	<	test -n "$ac_ct_CC" && break
4300	<	done
4301	<
4302	<	if test "x$ac_ct_CC" = x; then
4303	<	CC=""
4304	<	else
4305	<	case $cross_compiling:$ac_tool_warned in
4306	<	yes:)
4307	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4308	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4309	<	ac_tool_warned=yes ;;
4310	<	esac
4311	<	CC=$ac_ct_CC
4312	<	fi
4313	<	fi
4314	<
4315	<	fi
4316	<
4317	<
4318	<	test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4319	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4320	<	as_fn_error "no acceptable C compiler found in \$PATH
4321	<	See \`config.log' for more details." "$LINENO" 5; }
4322	<
4323	<	# Provide some information about the compiler.
4324	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4325	<	set X $ac_compile
4326	<	ac_compiler=$2
4327	<	for ac_option in --version -v -V -qversion; do
4328	<	{ { ac_try="$ac_compiler $ac_option >&5"
4329	<	case "(($ac_try" in
4330	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4331	<	*) ac_try_echo=$ac_try;;
4332	<	esac
4333	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4334	<	$as_echo "$ac_try_echo"; } >&5
4335	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4336	<	ac_status=$?
4337	<	if test -s conftest.err; then
4338	<	sed '10a\
4339	<	... rest of stderr output deleted ...
4340	<	10q' conftest.err >conftest.er1
4341	<	cat conftest.er1 >&5
4342	<	rm -f conftest.er1 conftest.err
4343	<	fi
4344	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4345	<	test $ac_status = 0; }
4346	<	done
4347	<
4348	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4349	<	$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4350	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4351	<	$as_echo_n "(cached) " >&6
4352	<	else
4353	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4354	<	/* end confdefs.h.  */
4355	<
4356	<	int
4357	<	main ()
4358	<	{
4359	<	#ifndef __GNUC__
4360	<	choke me
4361	<	#endif
4362	<
4363	<	;
4364	<	return 0;
4365	<	}
4366	<	_ACEOF
4367	<	if ac_fn_c_try_compile "$LINENO"; then :
4368	<	ac_compiler_gnu=yes
4369	<	else
4370	<	ac_compiler_gnu=no
4371	<	fi
4372	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4373	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
4374	<
4375	<	fi
4376	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
4377	<	$as_echo "$ac_cv_c_compiler_gnu" >&6; }
4378	<	if test $ac_compiler_gnu = yes; then
4379	<	GCC=yes
4380	<	else
4381	<	GCC=
4382	<	fi
4383	<	ac_test_CFLAGS=${CFLAGS+set}
4384	<	ac_save_CFLAGS=$CFLAGS
4385	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
4386	<	$as_echo_n "checking whether $CC accepts -g... " >&6; }
4387	<	if test "${ac_cv_prog_cc_g+set}" = set; then :
4388	<	$as_echo_n "(cached) " >&6
4389	<	else
4390	<	ac_save_c_werror_flag=$ac_c_werror_flag
4391	<	ac_c_werror_flag=yes
4392	<	ac_cv_prog_cc_g=no
4393	<	CFLAGS="-g"
4394	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4395	<	/* end confdefs.h.  */
4396	<
4397	<	int
4398	<	main ()
4399	<	{
4400	<
4401	<	;
4402	<	return 0;
4403	<	}
4404	<	_ACEOF
4405	<	if ac_fn_c_try_compile "$LINENO"; then :
4406	<	ac_cv_prog_cc_g=yes
4407	<	else
4408	<	CFLAGS=""
4409	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4410	<	/* end confdefs.h.  */
4411	<
4412	<	int
4413	<	main ()
4414	<	{
4415	<
4416	<	;
4417	<	return 0;
4418	<	}
4419	<	_ACEOF
4420	<	if ac_fn_c_try_compile "$LINENO"; then :
4421	<
4422	<	else
4423	<	ac_c_werror_flag=$ac_save_c_werror_flag
4424	<	CFLAGS="-g"
4425	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4426	<	/* end confdefs.h.  */
4427	<
4428	<	int
4429	<	main ()
4430	<	{
4431	<
4432	<	;
4433	<	return 0;
4434	<	}
4435	<	_ACEOF
4436	<	if ac_fn_c_try_compile "$LINENO"; then :
4437	<	ac_cv_prog_cc_g=yes
4438	<	fi
4439	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4440	<	fi
4441	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4442	<	fi
4443	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4444	<	ac_c_werror_flag=$ac_save_c_werror_flag
4445	<	fi
4446	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
4447	<	$as_echo "$ac_cv_prog_cc_g" >&6; }
4448	<	if test "$ac_test_CFLAGS" = set; then
4449	<	CFLAGS=$ac_save_CFLAGS
4450	<	elif test $ac_cv_prog_cc_g = yes; then
4451	<	if test "$GCC" = yes; then
4452	<	CFLAGS="-g -O2"
4453	<	else
4454	<	CFLAGS="-g"
4455	<	fi
4456	<	else
4457	<	if test "$GCC" = yes; then
4458	<	CFLAGS="-O2"
4459	<	else
4460	<	CFLAGS=
4461	<	fi
4462	<	fi
4463	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
4464	<	$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4465	<	if test "${ac_cv_prog_cc_c89+set}" = set; then :
4466	<	$as_echo_n "(cached) " >&6
4467	<	else
4468	<	ac_cv_prog_cc_c89=no
4469	<	ac_save_CC=$CC
4470	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4471	<	/* end confdefs.h.  */
4472	<	#include <stdarg.h>
4473	<	#include <stdio.h>
4474	<	#include <sys/types.h>
4475	<	#include <sys/stat.h>
4476	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4477	<	struct buf { int x; };
4478	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
4479	<	static char *e (p, i)
4480	<	char **p;
4481	<	int i;
4482	<	{
4483	<	return p[i];
4484	<	}
4485	<	static char *f (char * (*g) (char **, int), char **p, ...)
4486	<	{
4487	<	char *s;
4488	<	va_list v;
4489	<	va_start (v,p);
4490	<	s = g (p, va_arg (v,int));
4491	<	va_end (v);
4492	<	return s;
4493	<	}
4494	<
4495	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
4496	<	function prototypes and stuff, but not '\xHH' hex character constants.
4497	<	These don't provoke an error unfortunately, instead are silently treated
4498	<	as 'x'.  The following induces an error, until -std is added to get
4499	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4500	<	array size at least.  It's necessary to write '\x00'==0 to get something
4501	<	that's true only with -std.  */
4502	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
4503	<
4504	<	/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
4505	<	inside strings and character constants.  */
4506	<	#define FOO(x) 'x'
4507	<	int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
4508	<
4509	<	int test (int i, double x);
4510	<	struct s1 {int (*f) (int a);};
4511	<	struct s2 {int (*f) (double a);};
4512	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
4513	<	int argc;
4514	<	char **argv;
4515	<	int
4516	<	main ()
4517	<	{
4518	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
4519	<	;
4520	<	return 0;
4521	<	}
4522	<	_ACEOF
4523	<	for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
4524	<	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4525	<	do
4526	<	CC="$ac_save_CC $ac_arg"
4527	<	if ac_fn_c_try_compile "$LINENO"; then :
4528	<	ac_cv_prog_cc_c89=$ac_arg
4529	<	fi
4530	<	rm -f core conftest.err conftest.$ac_objext
4531	<	test "x$ac_cv_prog_cc_c89" != "xno" && break
4532	<	done
4533	<	rm -f conftest.$ac_ext
4534	<	CC=$ac_save_CC
4535	<
4536	<	fi
4537	<	# AC_CACHE_VAL
4538	<	case "x$ac_cv_prog_cc_c89" in
4539	<	x)
4540	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
4541	<	$as_echo "none needed" >&6; } ;;
4542	<	xno)
4543	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
4544	<	$as_echo "unsupported" >&6; } ;;
4545	<	*)
4546	<	CC="$CC $ac_cv_prog_cc_c89"
4547	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
4548	<	$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4549	<	esac
4550	<	if test "x$ac_cv_prog_cc_c89" != xno; then :
4551	<
4552	<	fi
4553	<
4554	<	ac_ext=c
4555	<	ac_cpp='$CPP $CPPFLAGS'
4556	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4557	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4558	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4559	<
4560	<
4561	<	if test $USE_MPI != no; then :
4562	<
4563	<	ac_ext=c
4564	<	ac_cpp='$CPP $CPPFLAGS'
4565	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4566	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4567	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4568	<
4569	<
4570	<
4571	<
4572	<
4573	<
4574	<	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4575	<	do
4576	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4577	<	set dummy $ac_prog; ac_word=$2
4578	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4579	<	$as_echo_n "checking for $ac_word... " >&6; }
4580	<	if test "${ac_cv_prog_MPICC+set}" = set; then :
4581	<	$as_echo_n "(cached) " >&6
4582	<	else
4583	<	if test -n "$MPICC"; then
4584	<	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4585	<	else
4586	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4587	<	for as_dir in $PATH
4588	<	do
4589	<	IFS=$as_save_IFS
4590	<	test -z "$as_dir" && as_dir=.
4591	<	for ac_exec_ext in '' $ac_executable_extensions; do
4592	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4593	<	ac_cv_prog_MPICC="$ac_prog"
4594	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4595	<	break 2
4596	<	fi
4597	<	done
4598	<	done
4599	<	IFS=$as_save_IFS
4600	<
4601	<	fi
4602	<	fi
4603	<	MPICC=$ac_cv_prog_MPICC
4604	<	if test -n "$MPICC"; then
4605	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4606	<	$as_echo "$MPICC" >&6; }
4607	<	else
4608	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4609	<	$as_echo "no" >&6; }
4610	<	fi
4611	<
4612	<
4613	<	test -n "$MPICC" && break
4614	<	done
4615	<	test -n "$MPICC" || MPICC="$CC"
4616	<
4617	<	ax_mpi_save_CC="$CC"
4618	<	CC="$MPICC"
4619	<
4620	<
4621	<
4622	<	if test x = x"$MPILIBS"; then
4623	<	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4624	<	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4625	<	MPILIBS=" "
4626	<	fi
4627	<
4628	<	fi
4629	<
4630	<	if test x = x"$MPILIBS"; then
4631	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4632	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4633	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4634	<	$as_echo_n "(cached) " >&6
4635	<	else
4636	<	ac_check_lib_save_LIBS=$LIBS
4637	<	LIBS="-lmpi  $LIBS"
4638	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4639	<	/* end confdefs.h.  */
4640	<
4641	<	/* Override any GCC internal prototype to avoid an error.
4642	<	Use char because int might match the return type of a GCC
4643	<	builtin and then its argument prototype would still apply.  */
4644	<	#ifdef __cplusplus
4645	<	extern "C"
4646	<	#endif
4647	<	char MPI_Init ();
4648	<	int
4649	<	main ()
4650	<	{
4651	<	return MPI_Init ();
4652	<	;
4653	<	return 0;
4654	<	}
4655	<	_ACEOF
4656	<	if ac_fn_c_try_link "$LINENO"; then :
4657	<	ac_cv_lib_mpi_MPI_Init=yes
4658	<	else
4659	<	ac_cv_lib_mpi_MPI_Init=no
4660	<	fi
4661	<	rm -f core conftest.err conftest.$ac_objext \
4662	<	conftest$ac_exeext conftest.$ac_ext
4663	<	LIBS=$ac_check_lib_save_LIBS
4664	<	fi
4665	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4666	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4667	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4668	<	MPILIBS="-lmpi"
4669	<	fi
4670	<
4671	<	fi
4672	<	if test x = x"$MPILIBS"; then
4673	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4674	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4675	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4676	<	$as_echo_n "(cached) " >&6
4677	<	else
4678	<	ac_check_lib_save_LIBS=$LIBS
4679	<	LIBS="-lmpich  $LIBS"
4680	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4681	<	/* end confdefs.h.  */
4682	<
4683	<	/* Override any GCC internal prototype to avoid an error.
4684	<	Use char because int might match the return type of a GCC
4685	<	builtin and then its argument prototype would still apply.  */
4686	<	#ifdef __cplusplus
4687	<	extern "C"
4688	<	#endif
4689	<	char MPI_Init ();
4690	<	int
4691	<	main ()
4692	<	{
4693	<	return MPI_Init ();
4694	<	;
4695	<	return 0;
4696	<	}
4697	<	_ACEOF
4698	<	if ac_fn_c_try_link "$LINENO"; then :
4699	<	ac_cv_lib_mpich_MPI_Init=yes
4700	<	else
4701	<	ac_cv_lib_mpich_MPI_Init=no
4702	<	fi
4703	<	rm -f core conftest.err conftest.$ac_objext \
4704	<	conftest$ac_exeext conftest.$ac_ext
4705	<	LIBS=$ac_check_lib_save_LIBS
4706	<	fi
4707	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4708	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4709	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4710	<	MPILIBS="-lmpich"
4711	<	fi
4712	<
4713	<	fi
4714	<
4715	<	if test x != x"$MPILIBS"; then
4716	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4717	<	$as_echo_n "checking for mpi.h... " >&6; }
4718	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4719	<	/* end confdefs.h.  */
4720	<	#include <mpi.h>
4721	<	int
4722	<	main ()
4723	<	{
4724	<
4725	<	;
4726	<	return 0;
4727	<	}
4728	<	_ACEOF
4729	<	if ac_fn_c_try_compile "$LINENO"; then :
4730	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4731	<	$as_echo "yes" >&6; }
4732	<	else
4733	<	MPILIBS=""
4734	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4735	<	$as_echo "no" >&6; }
4736	<	fi
4737	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4738	<	fi
4739	<
4740	<	CC="$ax_mpi_save_CC"
4741	<
4742	<
4743	<
4744	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4745	<	if test x = x"$MPILIBS"; then
4746	<	USE_MPI="no"
4747	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&5
4748	<	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&2;}
4749	<	:
4750	<	else
4751	<	USE_MPI="yes"
4752	<	:
4753	<	fi
4754	<
4755	<
4756	<	fi
4757	<	ac_ext=${ac_fc_srcext-f}
4758	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4759	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4760	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761	<	if test -n "$ac_tool_prefix"; then
4762	<	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4763	<	do
4764	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4765	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4766	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4767	<	$as_echo_n "checking for $ac_word... " >&6; }
4768	<	if test "${ac_cv_prog_FC+set}" = set; then :
4769	<	$as_echo_n "(cached) " >&6
4770	<	else
4771	<	if test -n "$FC"; then
4772	<	ac_cv_prog_FC="$FC" # Let the user override the test.
4773	<	else
4774	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4775	<	for as_dir in $PATH
4776	<	do
4777	<	IFS=$as_save_IFS
4778	<	test -z "$as_dir" && as_dir=.
4779	<	for ac_exec_ext in '' $ac_executable_extensions; do
4780	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4781	<	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4782	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4783	<	break 2
4784	<	fi
4785	<	done
4786	<	done
4787	<	IFS=$as_save_IFS
4788	<
4789	<	fi
4790	<	fi
4791	<	FC=$ac_cv_prog_FC
4792	<	if test -n "$FC"; then
4793	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4794	<	$as_echo "$FC" >&6; }
4795	<	else
4796	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4797	<	$as_echo "no" >&6; }
4798	<	fi
4799	<
4800	<
4801	<	test -n "$FC" && break
4802	<	done
4803	<	fi
4804	<	if test -z "$FC"; then
4805	<	ac_ct_FC=$FC
4806	<	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4807	<	do
4808	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4809	<	set dummy $ac_prog; ac_word=$2
4810	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4811	<	$as_echo_n "checking for $ac_word... " >&6; }
4812	<	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4813	<	$as_echo_n "(cached) " >&6
4814	<	else
4815	<	if test -n "$ac_ct_FC"; then
4816	<	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4817	<	else
4818	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4819	<	for as_dir in $PATH
4820	<	do
4821	<	IFS=$as_save_IFS
4822	<	test -z "$as_dir" && as_dir=.
4823	<	for ac_exec_ext in '' $ac_executable_extensions; do
4824	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4825	<	ac_cv_prog_ac_ct_FC="$ac_prog"
4826	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4827	<	break 2
4828	<	fi
4829	<	done
4830	<	done
4831	<	IFS=$as_save_IFS
4832	<
4833	<	fi
4834	<	fi
4835	<	ac_ct_FC=$ac_cv_prog_ac_ct_FC
4836	<	if test -n "$ac_ct_FC"; then
4837	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4838	<	$as_echo "$ac_ct_FC" >&6; }
4839	<	else
4840	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4841	<	$as_echo "no" >&6; }
4842	<	fi
4843	<
4844	<
4845	<	test -n "$ac_ct_FC" && break
4846	<	done
4847	<
4848	<	if test "x$ac_ct_FC" = x; then
4849	<	FC=""
4850	<	else
4851	<	case $cross_compiling:$ac_tool_warned in
4852	<	yes:)
4853	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4854	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4855	<	ac_tool_warned=yes ;;
4856	<	esac
4857	<	FC=$ac_ct_FC
4858	<	fi
4859	<	fi
4860	<
4861	<
4862	<	# Provide some information about the compiler.
4863	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4864	<	set X $ac_compile
4865	<	ac_compiler=$2
4866	<	for ac_option in --version -v -V -qversion; do
4867	<	{ { ac_try="$ac_compiler $ac_option >&5"
4868	<	case "(($ac_try" in
4869	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4870	<	*) ac_try_echo=$ac_try;;
4871	<	esac
4872	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4873	<	$as_echo "$ac_try_echo"; } >&5
4874	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4875	<	ac_status=$?
4876	<	if test -s conftest.err; then
4877	<	sed '10a\
4878	<	... rest of stderr output deleted ...
4879	<	10q' conftest.err >conftest.er1
4880	<	cat conftest.er1 >&5
4881	<	rm -f conftest.er1 conftest.err
4882	<	fi
4883	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4884	<	test $ac_status = 0; }
4885	<	done
4886	<	rm -f a.out
4887	<
4888	<	# If we don't use `.F' as extension, the preprocessor is not run on the
4889	<	# input file.  (Note that this only needs to work for GNU compilers.)
4890	<	ac_save_ext=$ac_ext
4891	<	ac_ext=F
4892	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4893	<	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4894	<	if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4895	<	$as_echo_n "(cached) " >&6
4896	<	else
4897	<	cat > conftest.$ac_ext <<_ACEOF
4898	<	program main
4899	<	#ifndef __GNUC__
4900	<	choke me
4901	<	#endif
4902	<
4903	<	end
4904	<	_ACEOF
4905	<	if ac_fn_fc_try_compile "$LINENO"; then :
4906	<	ac_compiler_gnu=yes
4907	<	else
4908	<	ac_compiler_gnu=no
4909	<	fi
4910	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4911	<	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4912	<
4913	<	fi
4914	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4915	<	$as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4916	<	ac_ext=$ac_save_ext
4917	<	ac_test_FCFLAGS=${FCFLAGS+set}
4918	<	ac_save_FCFLAGS=$FCFLAGS
4919	<	FCFLAGS=
4920	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4921	<	$as_echo_n "checking whether $FC accepts -g... " >&6; }
4922	<	if test "${ac_cv_prog_fc_g+set}" = set; then :
4923	<	$as_echo_n "(cached) " >&6
4924	<	else
4925	<	FCFLAGS=-g
4926	<	cat > conftest.$ac_ext <<_ACEOF
4927	<	program main
4928	<
4929	<	end
4930	<	_ACEOF
4931	<	if ac_fn_fc_try_compile "$LINENO"; then :
4932	<	ac_cv_prog_fc_g=yes
4933	<	else
4934	<	ac_cv_prog_fc_g=no
4935	<	fi
4936	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4937	<
4938	<	fi
4939	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
4940	<	$as_echo "$ac_cv_prog_fc_g" >&6; }
4941	<	if test "$ac_test_FCFLAGS" = set; then
4942	<	FCFLAGS=$ac_save_FCFLAGS
4943	<	elif test $ac_cv_prog_fc_g = yes; then
4944	<	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4945	<	FCFLAGS="-g -O2"
4946	<	else
4947	<	FCFLAGS="-g"
4948	<	fi
4949	<	else
4950	<	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4951	<	FCFLAGS="-O2"
4952	<	else
4953	<	FCFLAGS=
4954	<	fi
4955	<	fi
4956	<
4957	<	ac_ext=${ac_fc_srcext-f}
4958	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4959	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4960	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4961	<
4962	<
4963	<	if test $USE_MPI != no; then :
4964	<
4965	<	ac_ext=${ac_fc_srcext-f}
4966	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4967	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4968	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4969	<
4970	<
4971	<
4972	<
4973	<
4974	<
4975	<	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
4976	<	do
4977	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4978	<	set dummy $ac_prog; ac_word=$2
4979	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4980	<	$as_echo_n "checking for $ac_word... " >&6; }
4981	<	if test "${ac_cv_prog_MPIFC+set}" = set; then :
4982	<	$as_echo_n "(cached) " >&6
4983	<	else
4984	<	if test -n "$MPIFC"; then
4985	<	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
4986	<	else
4987	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4988	<	for as_dir in $PATH
4989	<	do
4990	<	IFS=$as_save_IFS
4991	<	test -z "$as_dir" && as_dir=.
4992	<	for ac_exec_ext in '' $ac_executable_extensions; do
4993	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4994	<	ac_cv_prog_MPIFC="$ac_prog"
4995	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4996	<	break 2
4997	<	fi
4998	<	done
4999	<	done
5000	<	IFS=$as_save_IFS
5001	<
5002	<	fi
5003	<	fi
5004	<	MPIFC=$ac_cv_prog_MPIFC
5005	<	if test -n "$MPIFC"; then
5006	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5007	<	$as_echo "$MPIFC" >&6; }
5008	<	else
5009	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5010	<	$as_echo "no" >&6; }
5011	<	fi
5012	<
5013	<
5014	<	test -n "$MPIFC" && break
5015	<	done
5016	<	test -n "$MPIFC" || MPIFC="$FC"
5017	<
5018	<	ax_mpi_save_FC="$FC"
5019	<	FC="$MPIFC"
5020	<
5021	<
5022	<
5023	<	if test x = x"$MPILIBS"; then
5024	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5025	<	$as_echo_n "checking for MPI_Init... " >&6; }
5026	<	cat > conftest.$ac_ext <<_ACEOF
5027	<	program main
5028	<	call MPI_Init
5029	<	end
5030	<	_ACEOF
5031	<	if ac_fn_fc_try_link "$LINENO"; then :
5032	<	MPILIBS=" "
5033	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5034	<	$as_echo "yes" >&6; }
5035	<	else
5036	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5037	<	$as_echo "no" >&6; }
5038	<	fi
5039	<	rm -f core conftest.err conftest.$ac_objext \
5040	<	conftest$ac_exeext conftest.$ac_ext
5041	<	fi
5042	<
5043	<	if test x = x"$MPILIBS"; then
5044	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5045	<	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5046	<	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5047	<	$as_echo_n "(cached) " >&6
5048	<	else
5049	<	ac_check_lib_save_LIBS=$LIBS
5050	<	LIBS="-lfmpi  $LIBS"
5051	<	cat > conftest.$ac_ext <<_ACEOF
5052	<	program main
5053	<	call MPI_Init
5054	<	end
5055	<	_ACEOF
5056	<	if ac_fn_fc_try_link "$LINENO"; then :
5057	<	ac_cv_lib_fmpi_MPI_Init=yes
5058	<	else
5059	<	ac_cv_lib_fmpi_MPI_Init=no
5060	<	fi
5061	<	rm -f core conftest.err conftest.$ac_objext \
5062	<	conftest$ac_exeext conftest.$ac_ext
5063	<	LIBS=$ac_check_lib_save_LIBS
5064	<	fi
5065	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
5066	<	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5067	<	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5068	<	MPILIBS="-lfmpi"
5069	<	fi
5070	<
5071	<	fi
5072	<	if test x = x"$MPILIBS"; then
5073	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5074	<	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5075	<	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5076	<	$as_echo_n "(cached) " >&6
5077	<	else
5078	<	ac_check_lib_save_LIBS=$LIBS
5079	<	LIBS="-lmpichf90  $LIBS"
5080	<	cat > conftest.$ac_ext <<_ACEOF
5081	<	program main
5082	<	call MPI_Init
5083	<	end
5084	<	_ACEOF
5085	<	if ac_fn_fc_try_link "$LINENO"; then :
5086	<	ac_cv_lib_mpichf90_MPI_Init=yes
5087	<	else
5088	<	ac_cv_lib_mpichf90_MPI_Init=no
5089	<	fi
5090	<	rm -f core conftest.err conftest.$ac_objext \
5091	<	conftest$ac_exeext conftest.$ac_ext
5092	<	LIBS=$ac_check_lib_save_LIBS
5093	<	fi
5094	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5095	<	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5096	<	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5097	<	MPILIBS="-lmpichf90"
5098	<	fi
5099	<
5100	<	fi
5101	<
5102	<	if test x = x"$MPILIBS"; then
5103	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5104	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5105	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5106	<	$as_echo_n "(cached) " >&6
5107	<	else
5108	<	ac_check_lib_save_LIBS=$LIBS
5109	<	LIBS="-lmpi  $LIBS"
5110	<	cat > conftest.$ac_ext <<_ACEOF
5111	<	program main
5112	<	call MPI_Init
5113	<	end
5114	<	_ACEOF
5115	<	if ac_fn_fc_try_link "$LINENO"; then :
5116	<	ac_cv_lib_mpi_MPI_Init=yes
5117	<	else
5118	<	ac_cv_lib_mpi_MPI_Init=no
5119	<	fi
5120	<	rm -f core conftest.err conftest.$ac_objext \
5121	<	conftest$ac_exeext conftest.$ac_ext
5122	<	LIBS=$ac_check_lib_save_LIBS
5123	<	fi
5124	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
5125	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5126	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5127	<	MPILIBS="-lmpi"
5128	<	fi
5129	<
5130	<	fi
5131	<	if test x = x"$MPILIBS"; then
5132	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
5133	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
5134	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
5135	<	$as_echo_n "(cached) " >&6
5136	<	else
5137	<	ac_check_lib_save_LIBS=$LIBS
5138	<	LIBS="-lmpich  $LIBS"
5139	<	cat > conftest.$ac_ext <<_ACEOF
5140	<	program main
5141	<	call MPI_Init
5142	<	end
5143	<	_ACEOF
5144	<	if ac_fn_fc_try_link "$LINENO"; then :
5145	<	ac_cv_lib_mpich_MPI_Init=yes
5146	<	else
5147	<	ac_cv_lib_mpich_MPI_Init=no
5148	<	fi
5149	<	rm -f core conftest.err conftest.$ac_objext \
5150	<	conftest$ac_exeext conftest.$ac_ext
5151	<	LIBS=$ac_check_lib_save_LIBS
5152	<	fi
5153	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5154	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5155	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5156	<	MPILIBS="-lmpich"
5157	<	fi
5158	<
5159	<	fi
5160	<
5161	<	if test x != x"$MPILIBS"; then
5162	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
5163	<	$as_echo_n "checking for mpif.h... " >&6; }
5164	<	cat > conftest.$ac_ext <<_ACEOF
5165	<	program main
5166	<	include 'mpif.h'
5167	<	end
5168	<	_ACEOF
5169	<	if ac_fn_fc_try_compile "$LINENO"; then :
5170	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5171	<	$as_echo "yes" >&6; }
5172	<	else
5173	<	MPILIBS=""
5174	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5175	<	$as_echo "no" >&6; }
5176	<	fi
5177	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5178	<	fi
5179	<
5180	<	FC="$ax_mpi_save_FC"
5181	<
5182	<
5183	<
5184	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
5185	<	if test x = x"$MPILIBS"; then
5186	<	USE_MPI="no"
5187	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&5
5188	<	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&2;}
5189	<	:
5190	<	else
5191	<	USE_MPI="yes"
5192	<	:
5193	<	fi
5194	<
5195	<
5196	<	fi
5197	<	if test $USE_MPI != no; then :
5198	<
5199	<	CXX=$MPICXX
5200	<	CC=$MPICC
5201	<	FC=$MPIFC
5202	<
5203	<	fi
5204	<
5205	<
5206	<	# Checks for programs.
5207	<	ac_ext=cpp
5208	<	ac_cpp='$CXXCPP $CPPFLAGS'
5209	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5210	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5211	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5212	<	if test -z "$CXX"; then
5213	<	if test -n "$CCC"; then
5214	<	CXX=$CCC
5215	<	else
5216	<	if test -n "$ac_tool_prefix"; then
5217	<	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5218	<	do
5219	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5220	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5221	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5222	<	$as_echo_n "checking for $ac_word... " >&6; }
5223	<	if test "${ac_cv_prog_CXX+set}" = set; then :
5224	<	$as_echo_n "(cached) " >&6
5225	<	else
5226	<	if test -n "$CXX"; then
5227	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
5228	<	else
5229	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5230	<	for as_dir in $PATH
5231	<	do
5232	<	IFS=$as_save_IFS
5233	<	test -z "$as_dir" && as_dir=.
5234	<	for ac_exec_ext in '' $ac_executable_extensions; do
5235	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5236	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
5237	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5238	<	break 2
5239	<	fi
5240	<	done
5241	<	done
5242	<	IFS=$as_save_IFS
5243	<
5244	<	fi
5245	<	fi
5246	<	CXX=$ac_cv_prog_CXX
5247	<	if test -n "$CXX"; then
5248	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
5249	<	$as_echo "$CXX" >&6; }
5250	<	else
5251	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5252	<	$as_echo "no" >&6; }
5253	<	fi
5254	<
5255	<
5256	<	test -n "$CXX" && break
5257	<	done
5258	<	fi
5259	<	if test -z "$CXX"; then
5260	<	ac_ct_CXX=$CXX
5261	<	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5262	<	do
5263	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
5264	<	set dummy $ac_prog; ac_word=$2
5265	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5266	<	$as_echo_n "checking for $ac_word... " >&6; }
5267	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
5268	<	$as_echo_n "(cached) " >&6
5269	<	else
5270	<	if test -n "$ac_ct_CXX"; then
5271	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
5272	<	else
5273	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5274	<	for as_dir in $PATH
5275	<	do
5276	<	IFS=$as_save_IFS
5277	<	test -z "$as_dir" && as_dir=.
5278	<	for ac_exec_ext in '' $ac_executable_extensions; do
5279	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5280	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
5281	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5282	<	break 2
5283	<	fi
3206	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3207	>	test $ac_status = 0; }; then :
3208	>	# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3209	>	# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3210	>	# in a Makefile.  We should not override ac_cv_exeext if it was cached,
3211	>	# so that the user can short-circuit this test for compilers unknown to
3212	>	# Autoconf.
3213	>	for ac_file in $ac_files ''
3214	>	do
3215	>	test -f "$ac_file" || continue
3216	>	case $ac_file in
3217	>	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3218	>	;;
3219	>	[ab].out )
3220	>	# We found the default executable, but exeext='' is most
3221	>	# certainly right.
3222	>	break;;
3223	>	*.* )
3224	>	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3225	>	then :; else
3226	>	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3227	>	fi
3228	>	# We set ac_cv_exeext here because the later test for it is not
3229	>	# safe: cross compilers may not add the suffix if given an `-o'
3230	>	# argument, so we may need to know it at that point already.
3231	>	# Even if this section looks crufty: it has the advantage of
3232	>	# actually working.
3233	>	break;;
3234	>	* )
3235	>	break;;
3236	>	esac
3237		done
3238	<	done
5286	<	IFS=$as_save_IFS
3238	>	test "$ac_cv_exeext" = no && ac_cv_exeext=
3239
5288	–	fi
5289	–	fi
5290	–	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
5291	–	if test -n "$ac_ct_CXX"; then
5292	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
5293	–	$as_echo "$ac_ct_CXX" >&6; }
3240		else
3241	+	ac_file=''
3242	+	fi
3243	+	if test -z "$ac_file"; then :
3244		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3245		$as_echo "no" >&6; }
3246	+	$as_echo "$as_me: failed program was:" >&5
3247	+	sed 's/^/| /' conftest.$ac_ext >&5
3248	+
3249	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3250	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3251	+	{ as_fn_set_status 77
3252	+	as_fn_error "C++ compiler cannot create executables
3253	+	See \`config.log' for more details." "$LINENO" 5; }; }
3254	+	else
3255	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3256	+	$as_echo "yes" >&6; }
3257		fi
3258	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3259	+	$as_echo_n "checking for C++ compiler default output file name... " >&6; }
3260	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3261	+	$as_echo "$ac_file" >&6; }
3262	+	ac_exeext=$ac_cv_exeext
3263
3264	<
3265	<	test -n "$ac_ct_CXX" && break
3264	>	rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3265	>	ac_clean_files=$ac_clean_files_save
3266	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3267	>	$as_echo_n "checking for suffix of executables... " >&6; }
3268	>	if { { ac_try="$ac_link"
3269	>	case "(($ac_try" in
3270	>	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3271	>	*) ac_try_echo=$ac_try;;
3272	>	esac
3273	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3274	>	$as_echo "$ac_try_echo"; } >&5
3275	>	(eval "$ac_link") 2>&5
3276	>	ac_status=$?
3277	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3278	>	test $ac_status = 0; }; then :
3279	>	# If both `conftest.exe' and `conftest' are `present' (well, observable)
3280	>	# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3281	>	# work properly (i.e., refer to `conftest.exe'), while it won't with
3282	>	# `rm'.
3283	>	for ac_file in conftest.exe conftest conftest.*; do
3284	>	test -f "$ac_file" || continue
3285	>	case $ac_file in
3286	>	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3287	>	*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3288	>	break;;
3289	>	* ) break;;
3290	>	esac
3291		done
3292	+	else
3293	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3294	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3295	+	as_fn_error "cannot compute suffix of executables: cannot compile and link
3296	+	See \`config.log' for more details." "$LINENO" 5; }
3297	+	fi
3298	+	rm -f conftest conftest$ac_cv_exeext
3299	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3300	+	$as_echo "$ac_cv_exeext" >&6; }
3301
3302	<	if test "x$ac_ct_CXX" = x; then
3303	<	CXX="g++"
3304	<	else
3305	<	case $cross_compiling:$ac_tool_warned in
3306	<	yes:)
3307	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3308	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3309	<	ac_tool_warned=yes ;;
3302	>	rm -f conftest.$ac_ext
3303	>	EXEEXT=$ac_cv_exeext
3304	>	ac_exeext=$EXEEXT
3305	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3306	>	/* end confdefs.h.  */
3307	>	#include <stdio.h>
3308	>	int
3309	>	main ()
3310	>	{
3311	>	FILE *f = fopen ("conftest.out", "w");
3312	>	return ferror (f) || fclose (f) != 0;
3313	>
3314	>	;
3315	>	return 0;
3316	>	}
3317	>	_ACEOF
3318	>	ac_clean_files="$ac_clean_files conftest.out"
3319	>	# Check that the compiler produces executables we can run.  If not, either
3320	>	# the compiler is broken, or we cross compile.
3321	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3322	>	$as_echo_n "checking whether we are cross compiling... " >&6; }
3323	>	if test "$cross_compiling" != yes; then
3324	>	{ { ac_try="$ac_link"
3325	>	case "(($ac_try" in
3326	>	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3327	>	*) ac_try_echo=$ac_try;;
3328		esac
3329	<	CXX=$ac_ct_CXX
3329	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3330	>	$as_echo "$ac_try_echo"; } >&5
3331	>	(eval "$ac_link") 2>&5
3332	>	ac_status=$?
3333	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3334	>	test $ac_status = 0; }
3335	>	if { ac_try='./conftest$ac_cv_exeext'
3336	>	{ { case "(($ac_try" in
3337	>	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3338	>	*) ac_try_echo=$ac_try;;
3339	>	esac
3340	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3341	>	$as_echo "$ac_try_echo"; } >&5
3342	>	(eval "$ac_try") 2>&5
3343	>	ac_status=$?
3344	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3345	>	test $ac_status = 0; }; }; then
3346	>	cross_compiling=no
3347	>	else
3348	>	if test "$cross_compiling" = maybe; then
3349	>	cross_compiling=yes
3350	>	else
3351	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3352	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3353	>	as_fn_error "cannot run C++ compiled programs.
3354	>	If you meant to cross compile, use \`--host'.
3355	>	See \`config.log' for more details." "$LINENO" 5; }
3356	>	fi
3357		fi
3358		fi
3359	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3360	+	$as_echo "$cross_compiling" >&6; }
3361
3362	<	fi
3363	<	fi
3364	<	# Provide some information about the compiler.
3365	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3366	<	set X $ac_compile
3367	<	ac_compiler=$2
3368	<	for ac_option in --version -v -V -qversion; do
3369	<	{ { ac_try="$ac_compiler $ac_option >&5"
3362	>	rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3363	>	ac_clean_files=$ac_clean_files_save
3364	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3365	>	$as_echo_n "checking for suffix of object files... " >&6; }
3366	>	if test "${ac_cv_objext+set}" = set; then :
3367	>	$as_echo_n "(cached) " >&6
3368	>	else
3369	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3370	>	/* end confdefs.h.  */
3371	>
3372	>	int
3373	>	main ()
3374	>	{
3375	>
3376	>	;
3377	>	return 0;
3378	>	}
3379	>	_ACEOF
3380	>	rm -f conftest.o conftest.obj
3381	>	if { { ac_try="$ac_compile"
3382		case "(($ac_try" in
3383		*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3384		*) ac_try_echo=$ac_try;;
3385		esac
3386		eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3387		$as_echo "$ac_try_echo"; } >&5
3388	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
3388	>	(eval "$ac_compile") 2>&5
3389		ac_status=$?
3390	<	if test -s conftest.err; then
3391	<	sed '10a\
3392	<	... rest of stderr output deleted ...
3393	<	10q' conftest.err >conftest.er1
3394	<	cat conftest.er1 >&5
3395	<	rm -f conftest.er1 conftest.err
3396	<	fi
3397	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3398	<	test $ac_status = 0; }
3390	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3391	>	test $ac_status = 0; }; then :
3392	>	for ac_file in conftest.o conftest.obj conftest.*; do
3393	>	test -f "$ac_file" || continue;
3394	>	case $ac_file in
3395	>	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3396	>	*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3397	>	break;;
3398	>	esac
3399		done
3400	+	else
3401	+	$as_echo "$as_me: failed program was:" >&5
3402	+	sed 's/^/| /' conftest.$ac_ext >&5
3403
3404	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3405	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3406	+	as_fn_error "cannot compute suffix of object files: cannot compile
3407	+	See \`config.log' for more details." "$LINENO" 5; }
3408	+	fi
3409	+	rm -f conftest.$ac_cv_objext conftest.$ac_ext
3410	+	fi
3411	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3412	+	$as_echo "$ac_cv_objext" >&6; }
3413	+	OBJEXT=$ac_cv_objext
3414	+	ac_objext=$OBJEXT
3415		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3416		$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3417		if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
#	Line 5455 | Line 3527 | fi
3527		CXXFLAGS=
3528		fi
3529		fi
3530	<	ac_ext=${ac_fc_srcext-f}
3531	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3532	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3533	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3530	>	ac_ext=c
3531	>	ac_cpp='$CPP $CPPFLAGS'
3532	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3533	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3534	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3535
3536		ac_ext=c
3537		ac_cpp='$CPP $CPPFLAGS'
#	Line 5590 | Line 3663 | $as_echo "$ac_try_echo"; } >&5
3663		... rest of stderr output deleted ...
3664		10q' conftest.err >conftest.er1
3665		cat conftest.er1 >&5
5593	–	rm -f conftest.er1 conftest.err
3666		fi
3667	+	rm -f conftest.er1 conftest.err
3668		$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3669		test $ac_status = 0; }
3670		done
#	Line 5802 | Line 3875 | fi
3875
3876		fi
3877
3878	<	ac_ext=${ac_fc_srcext-f}
3879	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3880	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3881	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3878	>	ac_ext=c
3879	>	ac_cpp='$CPP $CPPFLAGS'
3880	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3881	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3882	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3883
3884		ac_ext=${ac_fc_srcext-f}
3885		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
#	Line 5931 | Line 4005 | $as_echo "$ac_try_echo"; } >&5
4005		... rest of stderr output deleted ...
4006		10q' conftest.err >conftest.er1
4007		cat conftest.er1 >&5
5934	–	rm -f conftest.er1 conftest.err
4008		fi
4009	+	rm -f conftest.er1 conftest.err
4010		$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4011		test $ac_status = 0; }
4012		done
#	Line 6007 | Line 4081 | fi
4081		fi
4082		fi
4083
4084	+	ac_ext=c
4085	+	ac_cpp='$CPP $CPPFLAGS'
4086	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4087	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4088	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4089	+
4090	+
4091	+	save_CXX=$CXX
4092	+	save_CC=$CC
4093	+	save_FC=$FC
4094	+	save_LIBS=$LIBS
4095	+
4096	+	ac_ext=cpp
4097	+	ac_cpp='$CXXCPP $CPPFLAGS'
4098	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4099	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4100	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4101	+
4102	+
4103	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
4104	+	$as_echo_n "checking for dlopen in -lc... " >&6; }
4105	+	if test "${ac_cv_lib_c_dlopen+set}" = set; then :
4106	+	$as_echo_n "(cached) " >&6
4107	+	else
4108	+	ac_check_lib_save_LIBS=$LIBS
4109	+	LIBS="-lc  $LIBS"
4110	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4111	+	/* end confdefs.h.  */
4112	+
4113	+	/* Override any GCC internal prototype to avoid an error.
4114	+	Use char because int might match the return type of a GCC
4115	+	builtin and then its argument prototype would still apply.  */
4116	+	#ifdef __cplusplus
4117	+	extern "C"
4118	+	#endif
4119	+	char dlopen ();
4120	+	int
4121	+	main ()
4122	+	{
4123	+	return dlopen ();
4124	+	;
4125	+	return 0;
4126	+	}
4127	+	_ACEOF
4128	+	if ac_fn_cxx_try_link "$LINENO"; then :
4129	+	ac_cv_lib_c_dlopen=yes
4130	+	else
4131	+	ac_cv_lib_c_dlopen=no
4132	+	fi
4133	+	rm -f core conftest.err conftest.$ac_objext \
4134	+	conftest$ac_exeext conftest.$ac_ext
4135	+	LIBS=$ac_check_lib_save_LIBS
4136	+	fi
4137	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
4138	+	$as_echo "$ac_cv_lib_c_dlopen" >&6; }
4139	+	if test "x$ac_cv_lib_c_dlopen" = x""yes; then :
4140	+	LIBDL=""
4141	+	else
4142	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
4143	+	$as_echo_n "checking for dlopen in -ldl... " >&6; }
4144	+	if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
4145	+	$as_echo_n "(cached) " >&6
4146	+	else
4147	+	ac_check_lib_save_LIBS=$LIBS
4148	+	LIBS="-ldl  $LIBS"
4149	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4150	+	/* end confdefs.h.  */
4151	+
4152	+	/* Override any GCC internal prototype to avoid an error.
4153	+	Use char because int might match the return type of a GCC
4154	+	builtin and then its argument prototype would still apply.  */
4155	+	#ifdef __cplusplus
4156	+	extern "C"
4157	+	#endif
4158	+	char dlopen ();
4159	+	int
4160	+	main ()
4161	+	{
4162	+	return dlopen ();
4163	+	;
4164	+	return 0;
4165	+	}
4166	+	_ACEOF
4167	+	if ac_fn_cxx_try_link "$LINENO"; then :
4168	+	ac_cv_lib_dl_dlopen=yes
4169	+	else
4170	+	ac_cv_lib_dl_dlopen=no
4171	+	fi
4172	+	rm -f core conftest.err conftest.$ac_objext \
4173	+	conftest$ac_exeext conftest.$ac_ext
4174	+	LIBS=$ac_check_lib_save_LIBS
4175	+	fi
4176	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
4177	+	$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
4178	+	if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
4179	+	LIBDL="-ldl"
4180	+	fi
4181	+
4182	+	fi
4183	+
4184	+
4185	+
4186	+
4187	+
4188	+
4189	+
4190	+	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
4191	+	do
4192	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4193	+	set dummy $ac_prog; ac_word=$2
4194	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4195	+	$as_echo_n "checking for $ac_word... " >&6; }
4196	+	if test "${ac_cv_prog_MPICXX+set}" = set; then :
4197	+	$as_echo_n "(cached) " >&6
4198	+	else
4199	+	if test -n "$MPICXX"; then
4200	+	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
4201	+	else
4202	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4203	+	for as_dir in $PATH
4204	+	do
4205	+	IFS=$as_save_IFS
4206	+	test -z "$as_dir" && as_dir=.
4207	+	for ac_exec_ext in '' $ac_executable_extensions; do
4208	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4209	+	ac_cv_prog_MPICXX="$ac_prog"
4210	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4211	+	break 2
4212	+	fi
4213	+	done
4214	+	done
4215	+	IFS=$as_save_IFS
4216	+
4217	+	fi
4218	+	fi
4219	+	MPICXX=$ac_cv_prog_MPICXX
4220	+	if test -n "$MPICXX"; then
4221	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
4222	+	$as_echo "$MPICXX" >&6; }
4223	+	else
4224	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4225	+	$as_echo "no" >&6; }
4226	+	fi
4227	+
4228	+
4229	+	test -n "$MPICXX" && break
4230	+	done
4231	+	test -n "$MPICXX" || MPICXX="$CXX"
4232	+
4233	+	ax_mpi_save_CXX="$CXX"
4234	+	CXX="$MPICXX"
4235	+
4236	+
4237	+
4238	+	if test x = x"$MPILIBS"; then
4239	+	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4240	+	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4241	+	MPILIBS=" "
4242	+	fi
4243	+
4244	+	fi
4245	+
4246	+	if test x = x"$MPILIBS"; then
4247	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4248	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4249	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4250	+	$as_echo_n "(cached) " >&6
4251	+	else
4252	+	ac_check_lib_save_LIBS=$LIBS
4253	+	LIBS="-lmpi  $LIBS"
4254	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4255	+	/* end confdefs.h.  */
4256	+
4257	+	/* Override any GCC internal prototype to avoid an error.
4258	+	Use char because int might match the return type of a GCC
4259	+	builtin and then its argument prototype would still apply.  */
4260	+	#ifdef __cplusplus
4261	+	extern "C"
4262	+	#endif
4263	+	char MPI_Init ();
4264	+	int
4265	+	main ()
4266	+	{
4267	+	return MPI_Init ();
4268	+	;
4269	+	return 0;
4270	+	}
4271	+	_ACEOF
4272	+	if ac_fn_cxx_try_link "$LINENO"; then :
4273	+	ac_cv_lib_mpi_MPI_Init=yes
4274	+	else
4275	+	ac_cv_lib_mpi_MPI_Init=no
4276	+	fi
4277	+	rm -f core conftest.err conftest.$ac_objext \
4278	+	conftest$ac_exeext conftest.$ac_ext
4279	+	LIBS=$ac_check_lib_save_LIBS
4280	+	fi
4281	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4282	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4283	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4284	+	MPILIBS="-lmpi"
4285	+	fi
4286	+
4287	+	fi
4288	+	if test x = x"$MPILIBS"; then
4289	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4290	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4291	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4292	+	$as_echo_n "(cached) " >&6
4293	+	else
4294	+	ac_check_lib_save_LIBS=$LIBS
4295	+	LIBS="-lmpich  $LIBS"
4296	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4297	+	/* end confdefs.h.  */
4298	+
4299	+	/* Override any GCC internal prototype to avoid an error.
4300	+	Use char because int might match the return type of a GCC
4301	+	builtin and then its argument prototype would still apply.  */
4302	+	#ifdef __cplusplus
4303	+	extern "C"
4304	+	#endif
4305	+	char MPI_Init ();
4306	+	int
4307	+	main ()
4308	+	{
4309	+	return MPI_Init ();
4310	+	;
4311	+	return 0;
4312	+	}
4313	+	_ACEOF
4314	+	if ac_fn_cxx_try_link "$LINENO"; then :
4315	+	ac_cv_lib_mpich_MPI_Init=yes
4316	+	else
4317	+	ac_cv_lib_mpich_MPI_Init=no
4318	+	fi
4319	+	rm -f core conftest.err conftest.$ac_objext \
4320	+	conftest$ac_exeext conftest.$ac_ext
4321	+	LIBS=$ac_check_lib_save_LIBS
4322	+	fi
4323	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4324	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4325	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4326	+	MPILIBS="-lmpich"
4327	+	fi
4328	+
4329	+	fi
4330	+
4331	+	if test x != x"$MPILIBS"; then
4332	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4333	+	$as_echo_n "checking for mpi.h... " >&6; }
4334	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4335	+	/* end confdefs.h.  */
4336	+	#include <mpi.h>
4337	+	int
4338	+	main ()
4339	+	{
4340	+
4341	+	;
4342	+	return 0;
4343	+	}
4344	+	_ACEOF
4345	+	if ac_fn_cxx_try_compile "$LINENO"; then :
4346	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4347	+	$as_echo "yes" >&6; }
4348	+	else
4349	+	MPILIBS=""
4350	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4351	+	$as_echo "no" >&6; }
4352	+	fi
4353	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4354	+	fi
4355	+
4356	+	CXX="$ax_mpi_save_CXX"
4357	+
4358	+
4359	+
4360	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4361	+	if test x = x"$MPILIBS"; then
4362	+	USE_MPI="no"
4363	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4364	+	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4365	+	:
4366	+	else
4367	+	USE_MPI="yes"
4368	+	:
4369	+	fi
4370	+
4371	+
4372	+	if test $USE_MPI != no; then :
4373	+
4374	+	ac_ext=c
4375	+	ac_cpp='$CPP $CPPFLAGS'
4376	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4377	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4378	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4379	+
4380	+
4381	+
4382	+
4383	+
4384	+
4385	+	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4386	+	do
4387	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4388	+	set dummy $ac_prog; ac_word=$2
4389	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4390	+	$as_echo_n "checking for $ac_word... " >&6; }
4391	+	if test "${ac_cv_prog_MPICC+set}" = set; then :
4392	+	$as_echo_n "(cached) " >&6
4393	+	else
4394	+	if test -n "$MPICC"; then
4395	+	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4396	+	else
4397	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4398	+	for as_dir in $PATH
4399	+	do
4400	+	IFS=$as_save_IFS
4401	+	test -z "$as_dir" && as_dir=.
4402	+	for ac_exec_ext in '' $ac_executable_extensions; do
4403	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4404	+	ac_cv_prog_MPICC="$ac_prog"
4405	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4406	+	break 2
4407	+	fi
4408	+	done
4409	+	done
4410	+	IFS=$as_save_IFS
4411	+
4412	+	fi
4413	+	fi
4414	+	MPICC=$ac_cv_prog_MPICC
4415	+	if test -n "$MPICC"; then
4416	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4417	+	$as_echo "$MPICC" >&6; }
4418	+	else
4419	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4420	+	$as_echo "no" >&6; }
4421	+	fi
4422	+
4423	+
4424	+	test -n "$MPICC" && break
4425	+	done
4426	+	test -n "$MPICC" || MPICC="$CC"
4427	+
4428	+	ax_mpi_save_CC="$CC"
4429	+	CC="$MPICC"
4430	+
4431	+
4432	+
4433	+	if test x = x"$MPILIBS"; then
4434	+	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4435	+	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4436	+	MPILIBS=" "
4437	+	fi
4438	+
4439	+	fi
4440	+
4441	+	if test x = x"$MPILIBS"; then
4442	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4443	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4444	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4445	+	$as_echo_n "(cached) " >&6
4446	+	else
4447	+	ac_check_lib_save_LIBS=$LIBS
4448	+	LIBS="-lmpi  $LIBS"
4449	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4450	+	/* end confdefs.h.  */
4451	+
4452	+	/* Override any GCC internal prototype to avoid an error.
4453	+	Use char because int might match the return type of a GCC
4454	+	builtin and then its argument prototype would still apply.  */
4455	+	#ifdef __cplusplus
4456	+	extern "C"
4457	+	#endif
4458	+	char MPI_Init ();
4459	+	int
4460	+	main ()
4461	+	{
4462	+	return MPI_Init ();
4463	+	;
4464	+	return 0;
4465	+	}
4466	+	_ACEOF
4467	+	if ac_fn_c_try_link "$LINENO"; then :
4468	+	ac_cv_lib_mpi_MPI_Init=yes
4469	+	else
4470	+	ac_cv_lib_mpi_MPI_Init=no
4471	+	fi
4472	+	rm -f core conftest.err conftest.$ac_objext \
4473	+	conftest$ac_exeext conftest.$ac_ext
4474	+	LIBS=$ac_check_lib_save_LIBS
4475	+	fi
4476	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4477	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4478	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4479	+	MPILIBS="-lmpi"
4480	+	fi
4481	+
4482	+	fi
4483	+	if test x = x"$MPILIBS"; then
4484	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4485	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4486	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4487	+	$as_echo_n "(cached) " >&6
4488	+	else
4489	+	ac_check_lib_save_LIBS=$LIBS
4490	+	LIBS="-lmpich  $LIBS"
4491	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4492	+	/* end confdefs.h.  */
4493	+
4494	+	/* Override any GCC internal prototype to avoid an error.
4495	+	Use char because int might match the return type of a GCC
4496	+	builtin and then its argument prototype would still apply.  */
4497	+	#ifdef __cplusplus
4498	+	extern "C"
4499	+	#endif
4500	+	char MPI_Init ();
4501	+	int
4502	+	main ()
4503	+	{
4504	+	return MPI_Init ();
4505	+	;
4506	+	return 0;
4507	+	}
4508	+	_ACEOF
4509	+	if ac_fn_c_try_link "$LINENO"; then :
4510	+	ac_cv_lib_mpich_MPI_Init=yes
4511	+	else
4512	+	ac_cv_lib_mpich_MPI_Init=no
4513	+	fi
4514	+	rm -f core conftest.err conftest.$ac_objext \
4515	+	conftest$ac_exeext conftest.$ac_ext
4516	+	LIBS=$ac_check_lib_save_LIBS
4517	+	fi
4518	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4519	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4520	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4521	+	MPILIBS="-lmpich"
4522	+	fi
4523	+
4524	+	fi
4525	+
4526	+	if test x != x"$MPILIBS"; then
4527	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4528	+	$as_echo_n "checking for mpi.h... " >&6; }
4529	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4530	+	/* end confdefs.h.  */
4531	+	#include <mpi.h>
4532	+	int
4533	+	main ()
4534	+	{
4535	+
4536	+	;
4537	+	return 0;
4538	+	}
4539	+	_ACEOF
4540	+	if ac_fn_c_try_compile "$LINENO"; then :
4541	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4542	+	$as_echo "yes" >&6; }
4543	+	else
4544	+	MPILIBS=""
4545	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4546	+	$as_echo "no" >&6; }
4547	+	fi
4548	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4549	+	fi
4550	+
4551	+	CC="$ax_mpi_save_CC"
4552	+
4553	+
4554	+
4555	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4556	+	if test x = x"$MPILIBS"; then
4557	+	USE_MPI="no"
4558	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4559	+	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4560	+	:
4561	+	else
4562	+	USE_MPI="yes"
4563	+	:
4564	+	fi
4565	+
4566	+
4567	+	fi
4568	+
4569	+	if test $USE_MPI != no; then :
4570	+
4571		ac_ext=${ac_fc_srcext-f}
4572		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4573		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4574		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4575
4576	+
4577	+
4578	+
4579	+
4580	+
4581	+	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
4582	+	do
4583	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4584	+	set dummy $ac_prog; ac_word=$2
4585	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4586	+	$as_echo_n "checking for $ac_word... " >&6; }
4587	+	if test "${ac_cv_prog_MPIFC+set}" = set; then :
4588	+	$as_echo_n "(cached) " >&6
4589	+	else
4590	+	if test -n "$MPIFC"; then
4591	+	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
4592	+	else
4593	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4594	+	for as_dir in $PATH
4595	+	do
4596	+	IFS=$as_save_IFS
4597	+	test -z "$as_dir" && as_dir=.
4598	+	for ac_exec_ext in '' $ac_executable_extensions; do
4599	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4600	+	ac_cv_prog_MPIFC="$ac_prog"
4601	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4602	+	break 2
4603	+	fi
4604	+	done
4605	+	done
4606	+	IFS=$as_save_IFS
4607	+
4608	+	fi
4609	+	fi
4610	+	MPIFC=$ac_cv_prog_MPIFC
4611	+	if test -n "$MPIFC"; then
4612	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
4613	+	$as_echo "$MPIFC" >&6; }
4614	+	else
4615	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4616	+	$as_echo "no" >&6; }
4617	+	fi
4618	+
4619	+
4620	+	test -n "$MPIFC" && break
4621	+	done
4622	+	test -n "$MPIFC" || MPIFC="$FC"
4623	+
4624	+	ax_mpi_save_FC="$FC"
4625	+	FC="$MPIFC"
4626	+
4627	+
4628	+
4629	+	if test x = x"$MPILIBS"; then
4630	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
4631	+	$as_echo_n "checking for MPI_Init... " >&6; }
4632	+	cat > conftest.$ac_ext <<_ACEOF
4633	+	program main
4634	+	call MPI_Init
4635	+	end
4636	+	_ACEOF
4637	+	if ac_fn_fc_try_link "$LINENO"; then :
4638	+	MPILIBS=" "
4639	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4640	+	$as_echo "yes" >&6; }
4641	+	else
4642	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4643	+	$as_echo "no" >&6; }
4644	+	fi
4645	+	rm -f core conftest.err conftest.$ac_objext \
4646	+	conftest$ac_exeext conftest.$ac_ext
4647	+	fi
4648	+
4649	+	if test x = x"$MPILIBS"; then
4650	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
4651	+	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
4652	+	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
4653	+	$as_echo_n "(cached) " >&6
4654	+	else
4655	+	ac_check_lib_save_LIBS=$LIBS
4656	+	LIBS="-lfmpi  $LIBS"
4657	+	cat > conftest.$ac_ext <<_ACEOF
4658	+	program main
4659	+	call MPI_Init
4660	+	end
4661	+	_ACEOF
4662	+	if ac_fn_fc_try_link "$LINENO"; then :
4663	+	ac_cv_lib_fmpi_MPI_Init=yes
4664	+	else
4665	+	ac_cv_lib_fmpi_MPI_Init=no
4666	+	fi
4667	+	rm -f core conftest.err conftest.$ac_objext \
4668	+	conftest$ac_exeext conftest.$ac_ext
4669	+	LIBS=$ac_check_lib_save_LIBS
4670	+	fi
4671	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
4672	+	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
4673	+	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
4674	+	MPILIBS="-lfmpi"
4675	+	fi
4676	+
4677	+	fi
4678	+	if test x = x"$MPILIBS"; then
4679	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
4680	+	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
4681	+	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
4682	+	$as_echo_n "(cached) " >&6
4683	+	else
4684	+	ac_check_lib_save_LIBS=$LIBS
4685	+	LIBS="-lmpichf90  $LIBS"
4686	+	cat > conftest.$ac_ext <<_ACEOF
4687	+	program main
4688	+	call MPI_Init
4689	+	end
4690	+	_ACEOF
4691	+	if ac_fn_fc_try_link "$LINENO"; then :
4692	+	ac_cv_lib_mpichf90_MPI_Init=yes
4693	+	else
4694	+	ac_cv_lib_mpichf90_MPI_Init=no
4695	+	fi
4696	+	rm -f core conftest.err conftest.$ac_objext \
4697	+	conftest$ac_exeext conftest.$ac_ext
4698	+	LIBS=$ac_check_lib_save_LIBS
4699	+	fi
4700	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
4701	+	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
4702	+	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
4703	+	MPILIBS="-lmpichf90"
4704	+	fi
4705	+
4706	+	fi
4707	+
4708	+	if test x = x"$MPILIBS"; then
4709	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4710	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4711	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4712	+	$as_echo_n "(cached) " >&6
4713	+	else
4714	+	ac_check_lib_save_LIBS=$LIBS
4715	+	LIBS="-lmpi  $LIBS"
4716	+	cat > conftest.$ac_ext <<_ACEOF
4717	+	program main
4718	+	call MPI_Init
4719	+	end
4720	+	_ACEOF
4721	+	if ac_fn_fc_try_link "$LINENO"; then :
4722	+	ac_cv_lib_mpi_MPI_Init=yes
4723	+	else
4724	+	ac_cv_lib_mpi_MPI_Init=no
4725	+	fi
4726	+	rm -f core conftest.err conftest.$ac_objext \
4727	+	conftest$ac_exeext conftest.$ac_ext
4728	+	LIBS=$ac_check_lib_save_LIBS
4729	+	fi
4730	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4731	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4732	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4733	+	MPILIBS="-lmpi"
4734	+	fi
4735	+
4736	+	fi
4737	+	if test x = x"$MPILIBS"; then
4738	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4739	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4740	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4741	+	$as_echo_n "(cached) " >&6
4742	+	else
4743	+	ac_check_lib_save_LIBS=$LIBS
4744	+	LIBS="-lmpich  $LIBS"
4745	+	cat > conftest.$ac_ext <<_ACEOF
4746	+	program main
4747	+	call MPI_Init
4748	+	end
4749	+	_ACEOF
4750	+	if ac_fn_fc_try_link "$LINENO"; then :
4751	+	ac_cv_lib_mpich_MPI_Init=yes
4752	+	else
4753	+	ac_cv_lib_mpich_MPI_Init=no
4754	+	fi
4755	+	rm -f core conftest.err conftest.$ac_objext \
4756	+	conftest$ac_exeext conftest.$ac_ext
4757	+	LIBS=$ac_check_lib_save_LIBS
4758	+	fi
4759	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4760	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4761	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4762	+	MPILIBS="-lmpich"
4763	+	fi
4764	+
4765	+	fi
4766	+
4767	+	if test x != x"$MPILIBS"; then
4768	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
4769	+	$as_echo_n "checking for mpif.h... " >&6; }
4770	+	cat > conftest.$ac_ext <<_ACEOF
4771	+	program main
4772	+	include 'mpif.h'
4773	+	end
4774	+	_ACEOF
4775	+	if ac_fn_fc_try_compile "$LINENO"; then :
4776	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4777	+	$as_echo "yes" >&6; }
4778	+	else
4779	+	MPILIBS=""
4780	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4781	+	$as_echo "no" >&6; }
4782	+	fi
4783	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4784	+	fi
4785	+
4786	+	FC="$ax_mpi_save_FC"
4787	+
4788	+
4789	+
4790	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4791	+	if test x = x"$MPILIBS"; then
4792	+	USE_MPI="no"
4793	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
4794	+	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
4795	+	:
4796	+	else
4797	+	USE_MPI="yes"
4798	+	:
4799	+	fi
4800	+
4801	+
4802	+	fi
4803	+	if test $USE_MPI != no; then :
4804	+
4805	+	CXX=$MPICXX
4806	+	CC=$MPICC
4807	+	FC=$MPIFC
4808	+	LIBS="$MPILIBS $LIBS"
4809	+
4810	+	else
4811	+
4812	+	CXX=$save_CXX
4813	+	CC=$save_CC
4814	+	FC=$save_FC
4815	+	LIBS=$save_LIBS
4816	+
4817	+
4818	+	fi
4819	+
4820	+
4821	+	# Checks for programs.
4822		ac_ext=c
4823		ac_cpp='$CPP $CPPFLAGS'
4824		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 6629 | Line 5436 | esac
5436		x/*) ;;
5437		*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
5438		esac
5439	<	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
5439	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
5440		# Extract the first word of "ar", so it can be a program name with args.
5441		set dummy ar; ac_word=$2
5442		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
#	Line 8667 | Line 7474 | $as_echo "failed" >&6; }
7474		echo ""
7475		echo "*********************************************************"
7476		echo "* WARNING: Could not find a working zlib installation   *"
7477	<	echo "* If you need OOPSE to be able to deal with compressed  *"
7477	>	echo "* If you need OpenMD to be able to deal with compressed *"
7478		echo "* trajectory dump files be sure to specify a valid zlib *"
7479		echo "* installation with --with-zlib=DIR                     *"
7480		echo "*                                                       *"
7481	<	echo "* OOPSE will still work without zlib installed.         *"
7481	>	echo "* OpenMD will still work without zlib installed.        *"
7482		echo "*********************************************************"
7483		echo ""
7484		fi
#	Line 8943 | Line 7750 | $as_echo "failed" >&6; }
7750		echo "* compute undulation spectra, be sure to specify a      *"
7751		echo "* valid fftw installation with --with-fftw=DIR          *"
7752		echo "*                                                       *"
7753	<	echo "* OOPSE will still work without fftw installed.         *"
7753	>	echo "* OpenMD will still work without fftw installed.        *"
7754		echo "*********************************************************"
7755		echo ""
7756		fi
#	Line 9090 | Line 7897 | $as_echo "$as_me: WARNING: Could not find a working qh
7897		$as_echo "$as_me: WARNING: " >&2;}
7898		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
7899		$as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
7900	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OOPSE to be able to deal with convex    " >&5
7901	<	$as_echo "$as_me: WARNING: If you need OOPSE to be able to deal with convex    " >&2;}
7900	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OpenMD to be able to deal with convex    " >&5
7901	>	$as_echo "$as_me: WARNING: If you need OpenMD to be able to deal with convex    " >&2;}
7902		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
7903		$as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
7904		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
7905		$as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
7906		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
7907		$as_echo "$as_me: WARNING: " >&2;}
7908	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OOPSE will still work without qhull installed.      " >&5
7909	<	$as_echo "$as_me: WARNING: OOPSE will still work without qhull installed.      " >&2;}
7908	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OpenMD will still work without qhull installed.      " >&5
7909	>	$as_echo "$as_me: WARNING: OpenMD will still work without qhull installed.      " >&2;}
7910		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
7911		$as_echo "$as_me: WARNING: " >&2;}
7912		fi
#	Line 9373 | Line 8180 | $as_echo "failed" >&6; }
8180		echo ""
8181		echo "*********************************************************"
8182		echo "* WARNING: Could not find a working openbabel-2.x       *"
8183	<	echo "* installation If you need OOPSE to be able to convert  *"
8183	>	echo "* installation If you need OpenMD to be able to convert *"
8184		echo "* xyz or pdb files you need to specify a valid          *"
8185		echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
8186		echo "*                                                       *"
8187	<	echo "* OOPSE will still work without openbabel installed.    *"
8187	>	echo "* OpenMD will still work without openbabel installed.   *"
8188		echo "*********************************************************"
8189		echo ""
8190		fi
#	Line 11297 | Line 10104 | ac_log="
10104		# report actual input values of CONFIG_FILES etc. instead of their
10105		# values after options handling.
10106		ac_log="
10107	<	This file was extended by OOPSE $as_me 4.0, which was
10108	<	generated by GNU Autoconf 2.64.  Invocation command line was
10107	>	This file was extended by OpenMD $as_me 1.0, which was
10108	>	generated by GNU Autoconf 2.65.  Invocation command line was
10109
10110		CONFIG_FILES    = $CONFIG_FILES
10111		CONFIG_HEADERS  = $CONFIG_HEADERS
#	Line 11337 | Line 10144 | Usage: $0 [OPTION]... [TAG]...
10144
10145		-h, --help       print this help, then exit
10146		-V, --version    print version number and configuration settings, then exit
10147	+	--config     print configuration, then exit
10148		-q, --quiet, --silent
10149		do not print progress messages
10150		-d, --debug      don't remove temporary files
#	Line 11356 | Line 10164 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
10164
10165		_ACEOF
10166		cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
10167	+	ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
10168		ac_cs_version="\\
10169	<	OOPSE config.status 4.0
10170	<	configured by $0, generated by GNU Autoconf 2.64,
10171	<	with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
10169	>	OpenMD config.status 1.0
10170	>	configured by $0, generated by GNU Autoconf 2.65,
10171	>	with options \\"\$ac_cs_config\\"
10172
10173		Copyright (C) 2009 Free Software Foundation, Inc.
10174		This config.status script is free software; the Free Software Foundation
#	Line 11395 | Line 10204 | do
10204		ac_cs_recheck=: ;;
10205		--version | --versio | --versi | --vers | --ver | --ve | --v | -V )
10206		$as_echo "$ac_cs_version"; exit ;;
10207	+	--config | --confi | --conf | --con | --co | --c )
10208	+	$as_echo "$ac_cs_config"; exit ;;
10209		--debug | --debu | --deb | --de | --d | -d )
10210		debug=: ;;
10211		--file | --fil | --fi | --f )
#	Line 11580 | Line 10391 | h
10391		t delim
10392		:nl
10393		h
10394	<	s/\(.\{148\}\).*/\1/
10394	>	s/\(.\{148\}\)..*/\1/
10395		t more1
10396		s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
10397		p
#	Line 11594 | Line 10405 | h
10405		t nl
10406		:delim
10407		h
10408	<	s/\(.\{148\}\).*/\1/
10408	>	s/\(.\{148\}\)..*/\1/
10409		t more2
10410		s/["\\]/\\&/g; s/^/"/; s/$/"/
10411		p

Diff Legend

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