ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing:
trunk/configure (file contents), Revision 1395 by gezelter, Fri Dec 4 17:38:47 2009 UTC vs.
branches/development/configure (file contents), Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

#	Line 650 | 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
656	–	MPICC
660		ac_ct_CC
661		CFLAGS
662		CC
660	–	MPILIBS
661	–	MPICXX
663		OBJEXT
664		EXEEXT
665		ac_ct_CXX
#	Line 666 | Line 667 | CXX
667		LDFLAGS
668		CXXFLAGS
669		CXX
669	–	ac_fc_path
670	–	ac_fc_set
671	–	ac_cxx_path
672	–	ac_cxx_set
673	–	ac_cc_path
674	–	ac_cc_set
670		USE_SINGLE_PRECISION
671		debug
672		PROGNAME
#	Line 747 | Line 742 | CCC
742		LIBS
743		CPPFLAGS
744		CCC
750	–	MPICXX
745		CC
746		CFLAGS
753	–	MPICC
747		FC
748		FCFLAGS
749	+	MPICXX
750	+	MPICC
751		MPIFC
752		CPP
753		CXXCPP'
#	Line 1402 | Line 1397 | Some influential environment variables:
1397		LIBS        libraries to pass to the linker, e.g. -l<library>
1398		CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1399		you have headers in a nonstandard directory <include dir>
1405	–	MPICXX      MPI C++ compiler command
1400		CC          C compiler command
1401		CFLAGS      C compiler flags
1408	–	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 1529 | Line 1524 | fi
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 1642 | 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
1645	–
1646	–	# ac_fn_c_try_compile LINENO
1647	–	# --------------------------
1648	–	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1649	–	ac_fn_c_try_compile ()
1650	–	{
1651	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1652	–	rm -f conftest.$ac_objext
1653	–	if { { ac_try="$ac_compile"
1654	–	case "(($ac_try" in
1655	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1656	–	*) ac_try_echo=$ac_try;;
1657	–	esac
1658	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1659	–	$as_echo "$ac_try_echo"; } >&5
1660	–	(eval "$ac_compile") 2>conftest.err
1661	–	ac_status=$?
1662	–	if test -s conftest.err; then
1663	–	grep -v '^ *+' conftest.err >conftest.er1
1664	–	cat conftest.er1 >&5
1665	–	mv -f conftest.er1 conftest.err
1666	–	fi
1667	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1668	–	test $ac_status = 0; } && {
1669	–	test -z "$ac_c_werror_flag" ||
1670	–	test ! -s conftest.err
1671	–	} && test -s conftest.$ac_objext; then :
1672	–	ac_retval=0
1673	–	else
1674	–	$as_echo "$as_me: failed program was:" >&5
1675	–	sed 's/^/| /' conftest.$ac_ext >&5
1676	–
1677	–	ac_retval=1
1678	–	fi
1679	–	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1680	–	as_fn_set_status $ac_retval
1716
1682	–	} # ac_fn_c_try_compile
1683	–
1717		# ac_fn_c_try_link LINENO
1718		# -----------------------
1719		# Try to link conftest.$ac_ext, and return whether this succeeded.
#	Line 1794 | Line 1827 | $as_echo "$ac_res" >&6; }
1827
1828		} # ac_fn_c_check_func
1829
1797	–	# ac_fn_fc_try_compile LINENO
1798	–	# ---------------------------
1799	–	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1800	–	ac_fn_fc_try_compile ()
1801	–	{
1802	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1803	–	rm -f conftest.$ac_objext
1804	–	if { { ac_try="$ac_compile"
1805	–	case "(($ac_try" in
1806	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1807	–	*) ac_try_echo=$ac_try;;
1808	–	esac
1809	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1810	–	$as_echo "$ac_try_echo"; } >&5
1811	–	(eval "$ac_compile") 2>conftest.err
1812	–	ac_status=$?
1813	–	if test -s conftest.err; then
1814	–	grep -v '^ *+' conftest.err >conftest.er1
1815	–	cat conftest.er1 >&5
1816	–	mv -f conftest.er1 conftest.err
1817	–	fi
1818	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1819	–	test $ac_status = 0; } && {
1820	–	test -z "$ac_fc_werror_flag" ||
1821	–	test ! -s conftest.err
1822	–	} && test -s conftest.$ac_objext; then :
1823	–	ac_retval=0
1824	–	else
1825	–	$as_echo "$as_me: failed program was:" >&5
1826	–	sed 's/^/| /' conftest.$ac_ext >&5
1827	–
1828	–	ac_retval=1
1829	–	fi
1830	–	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1831	–	as_fn_set_status $ac_retval
1832	–
1833	–	} # ac_fn_fc_try_compile
1834	–
1830		# ac_fn_fc_try_link LINENO
1831		# ------------------------
1832		# Try to link conftest.$ac_ext, and return whether this succeeded.
#	Line 3007 | Line 3002 | $as_echo "#define debug 1" >>confdefs.h
3002		$as_echo "#define debug 1" >>confdefs.h
3003
3004		msg="$msg, debug mode"
3010	–	fi
3011	–
3012	–
3013	–	# Check whether --enable-single was given.
3014	–	if test "${enable_single+set}" = set; then :
3015	–	enableval=$enable_single; ok=$enableval
3016	–	else
3017	–	ok=no
3018	–	fi
3019	–
3020	–	# Check whether --enable-float was given.
3021	–	if test "${enable_float+set}" = set; then :
3022	–	enableval=$enable_float; ok=$enableval
3023	–	fi
3024	–
3025	–	if test "$ok" = "yes"; then
3026	–
3027	–	$as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3028	–
3029	–	USE_SINGLE_PRECISION=yes
3030	–
3031	–	fi
3032	–
3033	–	if test x"$CC" != x; then
3034	–	for ac_prog in $CC
3035	–	do
3036	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
3037	–	set dummy $ac_prog; ac_word=$2
3038	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3039	–	$as_echo_n "checking for $ac_word... " >&6; }
3040	–	if test "${ac_cv_prog_ac_cc_set+set}" = set; then :
3041	–	$as_echo_n "(cached) " >&6
3042	–	else
3043	–	if test -n "$ac_cc_set"; then
3044	–	ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
3045	–	else
3046	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3047	–	for as_dir in $PATH
3048	–	do
3049	–	IFS=$as_save_IFS
3050	–	test -z "$as_dir" && as_dir=.
3051	–	for ac_exec_ext in '' $ac_executable_extensions; do
3052	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3053	–	ac_cv_prog_ac_cc_set="$ac_prog"
3054	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3055	–	break 2
3056	–	fi
3057	–	done
3058	–	done
3059	–	IFS=$as_save_IFS
3060	–
3061	–	fi
3062	–	fi
3063	–	ac_cc_set=$ac_cv_prog_ac_cc_set
3064	–	if test -n "$ac_cc_set"; then
3065	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_set" >&5
3066	–	$as_echo "$ac_cc_set" >&6; }
3067	–	else
3068	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3069	–	$as_echo "no" >&6; }
3070	–	fi
3071	–
3072	–
3073	–	test -n "$ac_cc_set" && break
3074	–	done
3075	–	test -n "$ac_cc_set" || ac_cc_set="no"
3076	–
3077	–	if test $ac_cc_set != no; then :
3078	–
3079	–	# Extract the first word of "$ac_cc_set", so it can be a program name with args.
3080	–	set dummy $ac_cc_set; ac_word=$2
3081	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3082	–	$as_echo_n "checking for $ac_word... " >&6; }
3083	–	if test "${ac_cv_path_ac_cc_path+set}" = set; then :
3084	–	$as_echo_n "(cached) " >&6
3085	–	else
3086	–	case $ac_cc_path in
3087	–	[\\/]* | ?:[\\/]*)
3088	–	ac_cv_path_ac_cc_path="$ac_cc_path" # Let the user override the test with a path.
3089	–	;;
3090	–	*)
3091	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3092	–	for as_dir in $PATH
3093	–	do
3094	–	IFS=$as_save_IFS
3095	–	test -z "$as_dir" && as_dir=.
3096	–	for ac_exec_ext in '' $ac_executable_extensions; do
3097	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3098	–	ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
3099	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3100	–	break 2
3101	–	fi
3102	–	done
3103	–	done
3104	–	IFS=$as_save_IFS
3105	–
3106	–	test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
3107	–	;;
3108	–	esac
3005		fi
3110	–	ac_cc_path=$ac_cv_path_ac_cc_path
3111	–	if test -n "$ac_cc_path"; then
3112	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_path" >&5
3113	–	$as_echo "$ac_cc_path" >&6; }
3114	–	else
3115	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3116	–	$as_echo "no" >&6; }
3117	–	fi
3006
3007
3008	<	else
3009	<
3010	<	as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3123	<	fi
3124	<
3125	<	if test $ac_cc_path != no; then :
3126	<
3127	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CC as C compiler" >&5
3128	<	$as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3129	<	MPICC=$CC
3130	<
3131	<	else
3132	<
3133	<	as_fn_error "Can't find path to user-specified C compiler $CC" "$LINENO" 5
3134	<	fi
3135	<	fi
3136	<
3137	<	if test x"$CXX" != x; then
3138	<	for ac_prog in $CXX
3139	<	do
3140	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3141	<	set dummy $ac_prog; ac_word=$2
3142	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3143	<	$as_echo_n "checking for $ac_word... " >&6; }
3144	<	if test "${ac_cv_prog_ac_cxx_set+set}" = set; then :
3145	<	$as_echo_n "(cached) " >&6
3146	<	else
3147	<	if test -n "$ac_cxx_set"; then
3148	<	ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
3149	<	else
3150	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3151	<	for as_dir in $PATH
3152	<	do
3153	<	IFS=$as_save_IFS
3154	<	test -z "$as_dir" && as_dir=.
3155	<	for ac_exec_ext in '' $ac_executable_extensions; do
3156	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3157	<	ac_cv_prog_ac_cxx_set="$ac_prog"
3158	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3159	<	break 2
3160	<	fi
3161	<	done
3162	<	done
3163	<	IFS=$as_save_IFS
3164	<
3165	<	fi
3166	<	fi
3167	<	ac_cxx_set=$ac_cv_prog_ac_cxx_set
3168	<	if test -n "$ac_cxx_set"; then
3169	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_set" >&5
3170	<	$as_echo "$ac_cxx_set" >&6; }
3171	<	else
3172	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3173	<	$as_echo "no" >&6; }
3174	<	fi
3175	<
3176	<
3177	<	test -n "$ac_cxx_set" && break
3178	<	done
3179	<	test -n "$ac_cxx_set" || ac_cxx_set="no"
3180	<
3181	<	if test $ac_cxx_set != no; then :
3182	<
3183	<	# Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3184	<	set dummy $ac_cxx_set; ac_word=$2
3185	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3186	<	$as_echo_n "checking for $ac_word... " >&6; }
3187	<	if test "${ac_cv_path_ac_cxx_path+set}" = set; then :
3188	<	$as_echo_n "(cached) " >&6
3189	<	else
3190	<	case $ac_cxx_path in
3191	<	[\\/]* | ?:[\\/]*)
3192	<	ac_cv_path_ac_cxx_path="$ac_cxx_path" # Let the user override the test with a path.
3193	<	;;
3194	<	*)
3195	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3196	<	for as_dir in $PATH
3197	<	do
3198	<	IFS=$as_save_IFS
3199	<	test -z "$as_dir" && as_dir=.
3200	<	for ac_exec_ext in '' $ac_executable_extensions; do
3201	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3202	<	ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3203	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3204	<	break 2
3205	<	fi
3206	<	done
3207	<	done
3208	<	IFS=$as_save_IFS
3209	<
3210	<	test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3211	<	;;
3212	<	esac
3213	<	fi
3214	<	ac_cxx_path=$ac_cv_path_ac_cxx_path
3215	<	if test -n "$ac_cxx_path"; then
3216	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_path" >&5
3217	<	$as_echo "$ac_cxx_path" >&6; }
3218	<	else
3219	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3220	<	$as_echo "no" >&6; }
3221	<	fi
3222	<
3223	<
3224	<	else
3225	<
3226	<	as_fn_error "Specified C++ compiler $CXX doesn't seem to exist!" "$LINENO" 5
3227	<	fi
3228	<
3229	<	if test $ac_cxx_path != no; then :
3230	<
3231	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CXX as C++ compiler" >&5
3232	<	$as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3233	<	MPICXX=$CXX
3234	<
3235	<	else
3236	<
3237	<	as_fn_error "Can't find path to user-specified C++ compiler $CXX" "$LINENO" 5
3238	<	fi
3239	<	fi
3240	<
3241	<	if test x"$FC" != x; then
3242	<	for ac_prog in $FC
3243	<	do
3244	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3245	<	set dummy $ac_prog; ac_word=$2
3246	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3247	<	$as_echo_n "checking for $ac_word... " >&6; }
3248	<	if test "${ac_cv_prog_ac_fc_set+set}" = set; then :
3249	<	$as_echo_n "(cached) " >&6
3250	<	else
3251	<	if test -n "$ac_fc_set"; then
3252	<	ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3253	<	else
3254	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255	<	for as_dir in $PATH
3256	<	do
3257	<	IFS=$as_save_IFS
3258	<	test -z "$as_dir" && as_dir=.
3259	<	for ac_exec_ext in '' $ac_executable_extensions; do
3260	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3261	<	ac_cv_prog_ac_fc_set="$ac_prog"
3262	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3263	<	break 2
3264	<	fi
3265	<	done
3266	<	done
3267	<	IFS=$as_save_IFS
3268	<
3269	<	fi
3270	<	fi
3271	<	ac_fc_set=$ac_cv_prog_ac_fc_set
3272	<	if test -n "$ac_fc_set"; then
3273	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_set" >&5
3274	<	$as_echo "$ac_fc_set" >&6; }
3275	<	else
3276	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3277	<	$as_echo "no" >&6; }
3278	<	fi
3279	<
3280	<
3281	<	test -n "$ac_fc_set" && break
3282	<	done
3283	<	test -n "$ac_fc_set" || ac_fc_set="no"
3284	<
3285	<	if test $ac_fc_set != no; then :
3286	<
3287	<	# Extract the first word of "$ac_fc_set", so it can be a program name with args.
3288	<	set dummy $ac_fc_set; ac_word=$2
3289	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3290	<	$as_echo_n "checking for $ac_word... " >&6; }
3291	<	if test "${ac_cv_path_ac_fc_path+set}" = set; then :
3292	<	$as_echo_n "(cached) " >&6
3293	<	else
3294	<	case $ac_fc_path in
3295	<	[\\/]* | ?:[\\/]*)
3296	<	ac_cv_path_ac_fc_path="$ac_fc_path" # Let the user override the test with a path.
3297	<	;;
3298	<	*)
3299	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3300	<	for as_dir in $PATH
3301	<	do
3302	<	IFS=$as_save_IFS
3303	<	test -z "$as_dir" && as_dir=.
3304	<	for ac_exec_ext in '' $ac_executable_extensions; do
3305	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3306	<	ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3307	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3308	<	break 2
3309	<	fi
3310	<	done
3311	<	done
3312	<	IFS=$as_save_IFS
3313	<
3314	<	test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
3315	<	;;
3316	<	esac
3317	<	fi
3318	<	ac_fc_path=$ac_cv_path_ac_fc_path
3319	<	if test -n "$ac_fc_path"; then
3320	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_path" >&5
3321	<	$as_echo "$ac_fc_path" >&6; }
3322	<	else
3323	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3324	<	$as_echo "no" >&6; }
3325	<	fi
3326	<
3327	<
3328	<	else
3329	<
3330	<	as_fn_error "Specified Fortran compiler $FC doesn't seem to exist!" "$LINENO" 5
3331	<	fi
3332	<
3333	<	if test $ac_fc_path != no; then :
3334	<
3335	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $FC as Fortran compiler" >&5
3336	<	$as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3337	<	MPIFC=$FC
3338	<
3339	<	else
3340	<
3341	<	as_fn_error "Can't find path to user-specified Fortran compiler $FC" "$LINENO" 5
3342	<	fi
3343	<	fi
3344	<
3345	<
3346	<	save_LIBS_CHECK_CXX_LIB="$LIBS"
3347	<
3348	<	ac_ext=cpp
3349	<	ac_cpp='$CXXCPP $CPPFLAGS'
3350	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3351	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3352	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3353	<
3354	<	ac_ext=cpp
3355	<	ac_cpp='$CXXCPP $CPPFLAGS'
3356	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3357	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3358	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3359	<	if test -z "$CXX"; then
3360	<	if test -n "$CCC"; then
3361	<	CXX=$CCC
3362	<	else
3363	<	if test -n "$ac_tool_prefix"; then
3364	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3365	<	do
3366	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3367	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3368	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3369	<	$as_echo_n "checking for $ac_word... " >&6; }
3370	<	if test "${ac_cv_prog_CXX+set}" = set; then :
3371	<	$as_echo_n "(cached) " >&6
3372	<	else
3373	<	if test -n "$CXX"; then
3374	<	ac_cv_prog_CXX="$CXX" # Let the user override the test.
3375	<	else
3376	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3377	<	for as_dir in $PATH
3378	<	do
3379	<	IFS=$as_save_IFS
3380	<	test -z "$as_dir" && as_dir=.
3381	<	for ac_exec_ext in '' $ac_executable_extensions; do
3382	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3383	<	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3384	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3385	<	break 2
3386	<	fi
3387	<	done
3388	<	done
3389	<	IFS=$as_save_IFS
3390	<
3391	<	fi
3392	<	fi
3393	<	CXX=$ac_cv_prog_CXX
3394	<	if test -n "$CXX"; then
3395	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
3396	<	$as_echo "$CXX" >&6; }
3397	<	else
3398	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3399	<	$as_echo "no" >&6; }
3400	<	fi
3401	<
3402	<
3403	<	test -n "$CXX" && break
3404	<	done
3405	<	fi
3406	<	if test -z "$CXX"; then
3407	<	ac_ct_CXX=$CXX
3408	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3409	<	do
3410	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3411	<	set dummy $ac_prog; ac_word=$2
3412	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3413	<	$as_echo_n "checking for $ac_word... " >&6; }
3414	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3415	<	$as_echo_n "(cached) " >&6
3416	<	else
3417	<	if test -n "$ac_ct_CXX"; then
3418	<	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3419	<	else
3420	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3421	<	for as_dir in $PATH
3422	<	do
3423	<	IFS=$as_save_IFS
3424	<	test -z "$as_dir" && as_dir=.
3425	<	for ac_exec_ext in '' $ac_executable_extensions; do
3426	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3427	<	ac_cv_prog_ac_ct_CXX="$ac_prog"
3428	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3429	<	break 2
3430	<	fi
3431	<	done
3432	<	done
3433	<	IFS=$as_save_IFS
3434	<
3435	<	fi
3436	<	fi
3437	<	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3438	<	if test -n "$ac_ct_CXX"; then
3439	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
3440	<	$as_echo "$ac_ct_CXX" >&6; }
3441	<	else
3442	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3443	<	$as_echo "no" >&6; }
3444	<	fi
3445	<
3446	<
3447	<	test -n "$ac_ct_CXX" && break
3448	<	done
3449	<
3450	<	if test "x$ac_ct_CXX" = x; then
3451	<	CXX="g++"
3452	<	else
3453	<	case $cross_compiling:$ac_tool_warned in
3454	<	yes:)
3455	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3456	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3457	<	ac_tool_warned=yes ;;
3458	<	esac
3459	<	CXX=$ac_ct_CXX
3460	<	fi
3461	<	fi
3462	<
3463	<	fi
3464	<	fi
3465	<	# Provide some information about the compiler.
3466	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3467	<	set X $ac_compile
3468	<	ac_compiler=$2
3469	<	for ac_option in --version -v -V -qversion; do
3470	<	{ { ac_try="$ac_compiler $ac_option >&5"
3471	<	case "(($ac_try" in
3472	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3473	<	*) ac_try_echo=$ac_try;;
3474	<	esac
3475	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3476	<	$as_echo "$ac_try_echo"; } >&5
3477	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
3478	<	ac_status=$?
3479	<	if test -s conftest.err; then
3480	<	sed '10a\
3481	<	... rest of stderr output deleted ...
3482	<	10q' conftest.err >conftest.er1
3483	<	cat conftest.er1 >&5
3484	<	fi
3485	<	rm -f conftest.er1 conftest.err
3486	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3487	<	test $ac_status = 0; }
3488	<	done
3489	<
3490	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3491	<	/* end confdefs.h.  */
3492	<
3493	<	int
3494	<	main ()
3495	<	{
3496	<
3497	<	;
3498	<	return 0;
3499	<	}
3500	<	_ACEOF
3501	<	ac_clean_files_save=$ac_clean_files
3502	<	ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3503	<	# Try to create an executable without -o first, disregard a.out.
3504	<	# It will help us diagnose broken compilers, and finding out an intuition
3505	<	# of exeext.
3506	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3507	<	$as_echo_n "checking whether the C++ compiler works... " >&6; }
3508	<	ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3509	<
3510	<	# The possible output files:
3511	<	ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3512	<
3513	<	ac_rmfiles=
3514	<	for ac_file in $ac_files
3515	<	do
3516	<	case $ac_file in
3517	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3518	<	* ) ac_rmfiles="$ac_rmfiles $ac_file";;
3519	<	esac
3520	<	done
3521	<	rm -f $ac_rmfiles
3522	<
3523	<	if { { ac_try="$ac_link_default"
3524	<	case "(($ac_try" in
3525	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3526	<	*) ac_try_echo=$ac_try;;
3527	<	esac
3528	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3529	<	$as_echo "$ac_try_echo"; } >&5
3530	<	(eval "$ac_link_default") 2>&5
3531	<	ac_status=$?
3532	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3533	<	test $ac_status = 0; }; then :
3534	<	# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3535	<	# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3536	<	# in a Makefile.  We should not override ac_cv_exeext if it was cached,
3537	<	# so that the user can short-circuit this test for compilers unknown to
3538	<	# Autoconf.
3539	<	for ac_file in $ac_files ''
3540	<	do
3541	<	test -f "$ac_file" || continue
3542	<	case $ac_file in
3543	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3544	<	;;
3545	<	[ab].out )
3546	<	# We found the default executable, but exeext='' is most
3547	<	# certainly right.
3548	<	break;;
3549	<	*.* )
3550	<	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3551	<	then :; else
3552	<	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3553	<	fi
3554	<	# We set ac_cv_exeext here because the later test for it is not
3555	<	# safe: cross compilers may not add the suffix if given an `-o'
3556	<	# argument, so we may need to know it at that point already.
3557	<	# Even if this section looks crufty: it has the advantage of
3558	<	# actually working.
3559	<	break;;
3560	<	* )
3561	<	break;;
3562	<	esac
3563	<	done
3564	<	test "$ac_cv_exeext" = no && ac_cv_exeext=
3565	<
3566	<	else
3567	<	ac_file=''
3568	<	fi
3569	<	if test -z "$ac_file"; then :
3570	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3571	<	$as_echo "no" >&6; }
3572	<	$as_echo "$as_me: failed program was:" >&5
3573	<	sed 's/^/| /' conftest.$ac_ext >&5
3574	<
3575	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3576	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3577	<	{ as_fn_set_status 77
3578	<	as_fn_error "C++ compiler cannot create executables
3579	<	See \`config.log' for more details." "$LINENO" 5; }; }
3580	<	else
3581	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3582	<	$as_echo "yes" >&6; }
3583	<	fi
3584	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3585	<	$as_echo_n "checking for C++ compiler default output file name... " >&6; }
3586	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3587	<	$as_echo "$ac_file" >&6; }
3588	<	ac_exeext=$ac_cv_exeext
3589	<
3590	<	rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3591	<	ac_clean_files=$ac_clean_files_save
3592	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3593	<	$as_echo_n "checking for suffix of executables... " >&6; }
3594	<	if { { ac_try="$ac_link"
3595	<	case "(($ac_try" in
3596	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3597	<	*) ac_try_echo=$ac_try;;
3598	<	esac
3599	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3600	<	$as_echo "$ac_try_echo"; } >&5
3601	<	(eval "$ac_link") 2>&5
3602	<	ac_status=$?
3603	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3604	<	test $ac_status = 0; }; then :
3605	<	# If both `conftest.exe' and `conftest' are `present' (well, observable)
3606	<	# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3607	<	# work properly (i.e., refer to `conftest.exe'), while it won't with
3608	<	# `rm'.
3609	<	for ac_file in conftest.exe conftest conftest.*; do
3610	<	test -f "$ac_file" || continue
3611	<	case $ac_file in
3612	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3613	<	*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3614	<	break;;
3615	<	* ) break;;
3616	<	esac
3617	<	done
3618	<	else
3619	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3620	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3621	<	as_fn_error "cannot compute suffix of executables: cannot compile and link
3622	<	See \`config.log' for more details." "$LINENO" 5; }
3623	<	fi
3624	<	rm -f conftest conftest$ac_cv_exeext
3625	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3626	<	$as_echo "$ac_cv_exeext" >&6; }
3627	<
3628	<	rm -f conftest.$ac_ext
3629	<	EXEEXT=$ac_cv_exeext
3630	<	ac_exeext=$EXEEXT
3631	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3632	<	/* end confdefs.h.  */
3633	<	#include <stdio.h>
3634	<	int
3635	<	main ()
3636	<	{
3637	<	FILE *f = fopen ("conftest.out", "w");
3638	<	return ferror (f) || fclose (f) != 0;
3639	<
3640	<	;
3641	<	return 0;
3642	<	}
3643	<	_ACEOF
3644	<	ac_clean_files="$ac_clean_files conftest.out"
3645	<	# Check that the compiler produces executables we can run.  If not, either
3646	<	# the compiler is broken, or we cross compile.
3647	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3648	<	$as_echo_n "checking whether we are cross compiling... " >&6; }
3649	<	if test "$cross_compiling" != yes; then
3650	<	{ { ac_try="$ac_link"
3651	<	case "(($ac_try" in
3652	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3653	<	*) ac_try_echo=$ac_try;;
3654	<	esac
3655	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3656	<	$as_echo "$ac_try_echo"; } >&5
3657	<	(eval "$ac_link") 2>&5
3658	<	ac_status=$?
3659	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3660	<	test $ac_status = 0; }
3661	<	if { ac_try='./conftest$ac_cv_exeext'
3662	<	{ { case "(($ac_try" in
3663	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3664	<	*) ac_try_echo=$ac_try;;
3665	<	esac
3666	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3667	<	$as_echo "$ac_try_echo"; } >&5
3668	<	(eval "$ac_try") 2>&5
3669	<	ac_status=$?
3670	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3671	<	test $ac_status = 0; }; }; then
3672	<	cross_compiling=no
3673	<	else
3674	<	if test "$cross_compiling" = maybe; then
3675	<	cross_compiling=yes
3676	<	else
3677	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3678	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3679	<	as_fn_error "cannot run C++ compiled programs.
3680	<	If you meant to cross compile, use \`--host'.
3681	<	See \`config.log' for more details." "$LINENO" 5; }
3682	<	fi
3683	<	fi
3684	<	fi
3685	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3686	<	$as_echo "$cross_compiling" >&6; }
3687	<
3688	<	rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3689	<	ac_clean_files=$ac_clean_files_save
3690	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3691	<	$as_echo_n "checking for suffix of object files... " >&6; }
3692	<	if test "${ac_cv_objext+set}" = set; then :
3693	<	$as_echo_n "(cached) " >&6
3694	<	else
3695	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3696	<	/* end confdefs.h.  */
3697	<
3698	<	int
3699	<	main ()
3700	<	{
3701	<
3702	<	;
3703	<	return 0;
3704	<	}
3705	<	_ACEOF
3706	<	rm -f conftest.o conftest.obj
3707	<	if { { ac_try="$ac_compile"
3708	<	case "(($ac_try" in
3709	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3710	<	*) ac_try_echo=$ac_try;;
3711	<	esac
3712	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3713	<	$as_echo "$ac_try_echo"; } >&5
3714	<	(eval "$ac_compile") 2>&5
3715	<	ac_status=$?
3716	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3717	<	test $ac_status = 0; }; then :
3718	<	for ac_file in conftest.o conftest.obj conftest.*; do
3719	<	test -f "$ac_file" || continue;
3720	<	case $ac_file in
3721	<	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3722	<	*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3723	<	break;;
3724	<	esac
3725	<	done
3726	<	else
3727	<	$as_echo "$as_me: failed program was:" >&5
3728	<	sed 's/^/| /' conftest.$ac_ext >&5
3729	<
3730	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3731	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3732	<	as_fn_error "cannot compute suffix of object files: cannot compile
3733	<	See \`config.log' for more details." "$LINENO" 5; }
3734	<	fi
3735	<	rm -f conftest.$ac_cv_objext conftest.$ac_ext
3736	<	fi
3737	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3738	<	$as_echo "$ac_cv_objext" >&6; }
3739	<	OBJEXT=$ac_cv_objext
3740	<	ac_objext=$OBJEXT
3741	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3742	<	$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3743	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3744	<	$as_echo_n "(cached) " >&6
3745	<	else
3746	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3747	<	/* end confdefs.h.  */
3748	<
3749	<	int
3750	<	main ()
3751	<	{
3752	<	#ifndef __GNUC__
3753	<	choke me
3754	<	#endif
3755	<
3756	<	;
3757	<	return 0;
3758	<	}
3759	<	_ACEOF
3760	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3761	<	ac_compiler_gnu=yes
3762	<	else
3763	<	ac_compiler_gnu=no
3764	<	fi
3765	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3766	<	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3767	<
3768	<	fi
3769	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3770	<	$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3771	<	if test $ac_compiler_gnu = yes; then
3772	<	GXX=yes
3773	<	else
3774	<	GXX=
3775	<	fi
3776	<	ac_test_CXXFLAGS=${CXXFLAGS+set}
3777	<	ac_save_CXXFLAGS=$CXXFLAGS
3778	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3779	<	$as_echo_n "checking whether $CXX accepts -g... " >&6; }
3780	<	if test "${ac_cv_prog_cxx_g+set}" = set; then :
3781	<	$as_echo_n "(cached) " >&6
3782	<	else
3783	<	ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3784	<	ac_cxx_werror_flag=yes
3785	<	ac_cv_prog_cxx_g=no
3786	<	CXXFLAGS="-g"
3787	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3788	<	/* end confdefs.h.  */
3789	<
3790	<	int
3791	<	main ()
3792	<	{
3793	<
3794	<	;
3795	<	return 0;
3796	<	}
3797	<	_ACEOF
3798	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3799	<	ac_cv_prog_cxx_g=yes
3800	<	else
3801	<	CXXFLAGS=""
3802	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3803	<	/* end confdefs.h.  */
3804	<
3805	<	int
3806	<	main ()
3807	<	{
3808	<
3809	<	;
3810	<	return 0;
3811	<	}
3812	<	_ACEOF
3813	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3814	<
3815	<	else
3816	<	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3817	<	CXXFLAGS="-g"
3818	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3819	<	/* end confdefs.h.  */
3820	<
3821	<	int
3822	<	main ()
3823	<	{
3824	<
3825	<	;
3826	<	return 0;
3827	<	}
3828	<	_ACEOF
3829	<	if ac_fn_cxx_try_compile "$LINENO"; then :
3830	<	ac_cv_prog_cxx_g=yes
3831	<	fi
3832	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3833	<	fi
3834	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3835	<	fi
3836	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3837	<	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3838	<	fi
3839	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3840	<	$as_echo "$ac_cv_prog_cxx_g" >&6; }
3841	<	if test "$ac_test_CXXFLAGS" = set; then
3842	<	CXXFLAGS=$ac_save_CXXFLAGS
3843	<	elif test $ac_cv_prog_cxx_g = yes; then
3844	<	if test "$GXX" = yes; then
3845	<	CXXFLAGS="-g -O2"
3846	<	else
3847	<	CXXFLAGS="-g"
3848	<	fi
3849	<	else
3850	<	if test "$GXX" = yes; then
3851	<	CXXFLAGS="-O2"
3852	<	else
3853	<	CXXFLAGS=
3854	<	fi
3855	<	fi
3856	<	ac_ext=cpp
3857	<	ac_cpp='$CXXCPP $CPPFLAGS'
3858	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3859	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3860	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3861	<
3862	<
3863	<
3864	<
3865	<
3866	<
3867	<
3868	<	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3869	<	do
3870	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3871	<	set dummy $ac_prog; ac_word=$2
3872	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3873	<	$as_echo_n "checking for $ac_word... " >&6; }
3874	<	if test "${ac_cv_prog_MPICXX+set}" = set; then :
3875	<	$as_echo_n "(cached) " >&6
3876	<	else
3877	<	if test -n "$MPICXX"; then
3878	<	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3879	<	else
3880	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3881	<	for as_dir in $PATH
3882	<	do
3883	<	IFS=$as_save_IFS
3884	<	test -z "$as_dir" && as_dir=.
3885	<	for ac_exec_ext in '' $ac_executable_extensions; do
3886	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3887	<	ac_cv_prog_MPICXX="$ac_prog"
3888	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3889	<	break 2
3890	<	fi
3891	<	done
3892	<	done
3893	<	IFS=$as_save_IFS
3894	<
3895	<	fi
3896	<	fi
3897	<	MPICXX=$ac_cv_prog_MPICXX
3898	<	if test -n "$MPICXX"; then
3899	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3900	<	$as_echo "$MPICXX" >&6; }
3901	<	else
3902	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3903	<	$as_echo "no" >&6; }
3904	<	fi
3905	<
3906	<
3907	<	test -n "$MPICXX" && break
3908	<	done
3909	<	test -n "$MPICXX" || MPICXX="$CXX"
3910	<
3911	<	ax_mpi_save_CXX="$CXX"
3912	<	CXX="$MPICXX"
3913	<
3914	<
3915	<
3916	<	if test x = x"$MPILIBS"; then
3917	<	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3918	<	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3919	<	MPILIBS=" "
3920	<	fi
3921	<
3922	<	fi
3923	<
3924	<	if test x = x"$MPILIBS"; then
3925	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3926	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3927	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3928	<	$as_echo_n "(cached) " >&6
3929	<	else
3930	<	ac_check_lib_save_LIBS=$LIBS
3931	<	LIBS="-lmpi  $LIBS"
3932	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3933	<	/* end confdefs.h.  */
3934	<
3935	<	/* Override any GCC internal prototype to avoid an error.
3936	<	Use char because int might match the return type of a GCC
3937	<	builtin and then its argument prototype would still apply.  */
3938	<	#ifdef __cplusplus
3939	<	extern "C"
3940	<	#endif
3941	<	char MPI_Init ();
3942	<	int
3943	<	main ()
3944	<	{
3945	<	return MPI_Init ();
3946	<	;
3947	<	return 0;
3948	<	}
3949	<	_ACEOF
3950	<	if ac_fn_cxx_try_link "$LINENO"; then :
3951	<	ac_cv_lib_mpi_MPI_Init=yes
3952	<	else
3953	<	ac_cv_lib_mpi_MPI_Init=no
3954	<	fi
3955	<	rm -f core conftest.err conftest.$ac_objext \
3956	<	conftest$ac_exeext conftest.$ac_ext
3957	<	LIBS=$ac_check_lib_save_LIBS
3958	<	fi
3959	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3960	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3961	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
3962	<	MPILIBS="-lmpi"
3963	<	fi
3964	<
3965	<	fi
3966	<	if test x = x"$MPILIBS"; then
3967	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3968	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3969	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
3970	<	$as_echo_n "(cached) " >&6
3971	<	else
3972	<	ac_check_lib_save_LIBS=$LIBS
3973	<	LIBS="-lmpich  $LIBS"
3974	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3975	<	/* end confdefs.h.  */
3976	<
3977	<	/* Override any GCC internal prototype to avoid an error.
3978	<	Use char because int might match the return type of a GCC
3979	<	builtin and then its argument prototype would still apply.  */
3980	<	#ifdef __cplusplus
3981	<	extern "C"
3982	<	#endif
3983	<	char MPI_Init ();
3984	<	int
3985	<	main ()
3986	<	{
3987	<	return MPI_Init ();
3988	<	;
3989	<	return 0;
3990	<	}
3991	<	_ACEOF
3992	<	if ac_fn_cxx_try_link "$LINENO"; then :
3993	<	ac_cv_lib_mpich_MPI_Init=yes
3994	<	else
3995	<	ac_cv_lib_mpich_MPI_Init=no
3996	<	fi
3997	<	rm -f core conftest.err conftest.$ac_objext \
3998	<	conftest$ac_exeext conftest.$ac_ext
3999	<	LIBS=$ac_check_lib_save_LIBS
4000	<	fi
4001	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4002	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4003	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4004	<	MPILIBS="-lmpich"
4005	<	fi
4006	<
4007	<	fi
4008	<
4009	<	if test x != x"$MPILIBS"; then
4010	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4011	<	$as_echo_n "checking for mpi.h... " >&6; }
4012	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4013	<	/* end confdefs.h.  */
4014	<	#include <mpi.h>
4015	<	int
4016	<	main ()
4017	<	{
4018	<
4019	<	;
4020	<	return 0;
4021	<	}
4022	<	_ACEOF
4023	<	if ac_fn_cxx_try_compile "$LINENO"; then :
4024	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4025	<	$as_echo "yes" >&6; }
4026	<	else
4027	<	MPILIBS=""
4028	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4029	<	$as_echo "no" >&6; }
4030	<	fi
4031	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4032	<	fi
4033	<
4034	<	CXX="$ax_mpi_save_CXX"
4035	<
4036	<
4037	<
4038	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4039	<	if test x = x"$MPILIBS"; then
4040	<	USE_MPI="no"
4041	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4042	<	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4043	<	:
4044	<	else
4045	<	USE_MPI="yes"
4046	<	:
4047	<	fi
4048	<
4049	<	ac_ext=c
4050	<	ac_cpp='$CPP $CPPFLAGS'
4051	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4052	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4053	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4054	<	if test -n "$ac_tool_prefix"; then
4055	<	# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4056	<	set dummy ${ac_tool_prefix}gcc; ac_word=$2
4057	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4058	<	$as_echo_n "checking for $ac_word... " >&6; }
4059	<	if test "${ac_cv_prog_CC+set}" = set; then :
4060	<	$as_echo_n "(cached) " >&6
4061	<	else
4062	<	if test -n "$CC"; then
4063	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4064	<	else
4065	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4066	<	for as_dir in $PATH
4067	<	do
4068	<	IFS=$as_save_IFS
4069	<	test -z "$as_dir" && as_dir=.
4070	<	for ac_exec_ext in '' $ac_executable_extensions; do
4071	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4072	<	ac_cv_prog_CC="${ac_tool_prefix}gcc"
4073	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4074	<	break 2
4075	<	fi
4076	<	done
4077	<	done
4078	<	IFS=$as_save_IFS
4079	<
4080	<	fi
4081	<	fi
4082	<	CC=$ac_cv_prog_CC
4083	<	if test -n "$CC"; then
4084	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4085	<	$as_echo "$CC" >&6; }
4086	<	else
4087	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4088	<	$as_echo "no" >&6; }
4089	<	fi
4090	<
4091	<
4092	<	fi
4093	<	if test -z "$ac_cv_prog_CC"; then
4094	<	ac_ct_CC=$CC
4095	<	# Extract the first word of "gcc", so it can be a program name with args.
4096	<	set dummy gcc; ac_word=$2
4097	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4098	<	$as_echo_n "checking for $ac_word... " >&6; }
4099	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4100	<	$as_echo_n "(cached) " >&6
4101	<	else
4102	<	if test -n "$ac_ct_CC"; then
4103	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4104	<	else
4105	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4106	<	for as_dir in $PATH
4107	<	do
4108	<	IFS=$as_save_IFS
4109	<	test -z "$as_dir" && as_dir=.
4110	<	for ac_exec_ext in '' $ac_executable_extensions; do
4111	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4112	<	ac_cv_prog_ac_ct_CC="gcc"
4113	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4114	<	break 2
4115	<	fi
4116	<	done
4117	<	done
4118	<	IFS=$as_save_IFS
4119	<
4120	<	fi
4121	<	fi
4122	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4123	<	if test -n "$ac_ct_CC"; then
4124	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4125	<	$as_echo "$ac_ct_CC" >&6; }
4126	<	else
4127	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4128	<	$as_echo "no" >&6; }
4129	<	fi
4130	<
4131	<	if test "x$ac_ct_CC" = x; then
4132	<	CC=""
4133	<	else
4134	<	case $cross_compiling:$ac_tool_warned in
4135	<	yes:)
4136	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4137	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4138	<	ac_tool_warned=yes ;;
4139	<	esac
4140	<	CC=$ac_ct_CC
4141	<	fi
4142	<	else
4143	<	CC="$ac_cv_prog_CC"
4144	<	fi
4145	<
4146	<	if test -z "$CC"; then
4147	<	if test -n "$ac_tool_prefix"; then
4148	<	# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4149	<	set dummy ${ac_tool_prefix}cc; ac_word=$2
4150	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4151	<	$as_echo_n "checking for $ac_word... " >&6; }
4152	<	if test "${ac_cv_prog_CC+set}" = set; then :
4153	<	$as_echo_n "(cached) " >&6
4154	<	else
4155	<	if test -n "$CC"; then
4156	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4157	<	else
4158	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4159	<	for as_dir in $PATH
4160	<	do
4161	<	IFS=$as_save_IFS
4162	<	test -z "$as_dir" && as_dir=.
4163	<	for ac_exec_ext in '' $ac_executable_extensions; do
4164	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4165	<	ac_cv_prog_CC="${ac_tool_prefix}cc"
4166	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4167	<	break 2
4168	<	fi
4169	<	done
4170	<	done
4171	<	IFS=$as_save_IFS
4172	<
4173	<	fi
4174	<	fi
4175	<	CC=$ac_cv_prog_CC
4176	<	if test -n "$CC"; then
4177	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4178	<	$as_echo "$CC" >&6; }
4179	<	else
4180	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4181	<	$as_echo "no" >&6; }
4182	<	fi
4183	<
4184	<
4185	<	fi
4186	<	fi
4187	<	if test -z "$CC"; then
4188	<	# Extract the first word of "cc", so it can be a program name with args.
4189	<	set dummy cc; ac_word=$2
4190	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4191	<	$as_echo_n "checking for $ac_word... " >&6; }
4192	<	if test "${ac_cv_prog_CC+set}" = set; then :
4193	<	$as_echo_n "(cached) " >&6
4194	<	else
4195	<	if test -n "$CC"; then
4196	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4197	<	else
4198	<	ac_prog_rejected=no
4199	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4200	<	for as_dir in $PATH
4201	<	do
4202	<	IFS=$as_save_IFS
4203	<	test -z "$as_dir" && as_dir=.
4204	<	for ac_exec_ext in '' $ac_executable_extensions; do
4205	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4206	<	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4207	<	ac_prog_rejected=yes
4208	<	continue
4209	<	fi
4210	<	ac_cv_prog_CC="cc"
4211	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4212	<	break 2
4213	<	fi
4214	<	done
4215	<	done
4216	<	IFS=$as_save_IFS
4217	<
4218	<	if test $ac_prog_rejected = yes; then
4219	<	# We found a bogon in the path, so make sure we never use it.
4220	<	set dummy $ac_cv_prog_CC
4221	<	shift
4222	<	if test $# != 0; then
4223	<	# We chose a different compiler from the bogus one.
4224	<	# However, it has the same basename, so the bogon will be chosen
4225	<	# first if we set CC to just the basename; use the full file name.
4226	<	shift
4227	<	ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4228	<	fi
4229	<	fi
4230	<	fi
4231	<	fi
4232	<	CC=$ac_cv_prog_CC
4233	<	if test -n "$CC"; then
4234	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4235	<	$as_echo "$CC" >&6; }
4236	<	else
4237	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4238	<	$as_echo "no" >&6; }
4239	<	fi
4240	<
4241	<
4242	<	fi
4243	<	if test -z "$CC"; then
4244	<	if test -n "$ac_tool_prefix"; then
4245	<	for ac_prog in cl.exe
4246	<	do
4247	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4248	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4249	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4250	<	$as_echo_n "checking for $ac_word... " >&6; }
4251	<	if test "${ac_cv_prog_CC+set}" = set; then :
4252	<	$as_echo_n "(cached) " >&6
4253	<	else
4254	<	if test -n "$CC"; then
4255	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4256	<	else
4257	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4258	<	for as_dir in $PATH
4259	<	do
4260	<	IFS=$as_save_IFS
4261	<	test -z "$as_dir" && as_dir=.
4262	<	for ac_exec_ext in '' $ac_executable_extensions; do
4263	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4264	<	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4265	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4266	<	break 2
4267	<	fi
4268	<	done
4269	<	done
4270	<	IFS=$as_save_IFS
4271	<
4272	<	fi
4273	<	fi
4274	<	CC=$ac_cv_prog_CC
4275	<	if test -n "$CC"; then
4276	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4277	<	$as_echo "$CC" >&6; }
4278	<	else
4279	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4280	<	$as_echo "no" >&6; }
4281	<	fi
4282	<
4283	<
4284	<	test -n "$CC" && break
4285	<	done
4286	<	fi
4287	<	if test -z "$CC"; then
4288	<	ac_ct_CC=$CC
4289	<	for ac_prog in cl.exe
4290	<	do
4291	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4292	<	set dummy $ac_prog; ac_word=$2
4293	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4294	<	$as_echo_n "checking for $ac_word... " >&6; }
4295	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4296	<	$as_echo_n "(cached) " >&6
4297	<	else
4298	<	if test -n "$ac_ct_CC"; then
4299	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4300	<	else
4301	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4302	<	for as_dir in $PATH
4303	<	do
4304	<	IFS=$as_save_IFS
4305	<	test -z "$as_dir" && as_dir=.
4306	<	for ac_exec_ext in '' $ac_executable_extensions; do
4307	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4308	<	ac_cv_prog_ac_ct_CC="$ac_prog"
4309	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4310	<	break 2
4311	<	fi
4312	<	done
4313	<	done
4314	<	IFS=$as_save_IFS
4315	<
4316	<	fi
4317	<	fi
4318	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4319	<	if test -n "$ac_ct_CC"; then
4320	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4321	<	$as_echo "$ac_ct_CC" >&6; }
4322	<	else
4323	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4324	<	$as_echo "no" >&6; }
4325	<	fi
4326	<
4327	<
4328	<	test -n "$ac_ct_CC" && break
4329	<	done
4330	<
4331	<	if test "x$ac_ct_CC" = x; then
4332	<	CC=""
4333	<	else
4334	<	case $cross_compiling:$ac_tool_warned in
4335	<	yes:)
4336	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4337	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4338	<	ac_tool_warned=yes ;;
4339	<	esac
4340	<	CC=$ac_ct_CC
4341	<	fi
4342	<	fi
4343	<
4344	<	fi
4345	<
4346	<
4347	<	test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4348	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4349	<	as_fn_error "no acceptable C compiler found in \$PATH
4350	<	See \`config.log' for more details." "$LINENO" 5; }
4351	<
4352	<	# Provide some information about the compiler.
4353	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4354	<	set X $ac_compile
4355	<	ac_compiler=$2
4356	<	for ac_option in --version -v -V -qversion; do
4357	<	{ { ac_try="$ac_compiler $ac_option >&5"
4358	<	case "(($ac_try" in
4359	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4360	<	*) ac_try_echo=$ac_try;;
4361	<	esac
4362	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4363	<	$as_echo "$ac_try_echo"; } >&5
4364	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4365	<	ac_status=$?
4366	<	if test -s conftest.err; then
4367	<	sed '10a\
4368	<	... rest of stderr output deleted ...
4369	<	10q' conftest.err >conftest.er1
4370	<	cat conftest.er1 >&5
4371	<	fi
4372	<	rm -f conftest.er1 conftest.err
4373	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4374	<	test $ac_status = 0; }
4375	<	done
4376	<
4377	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4378	<	$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4379	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4380	<	$as_echo_n "(cached) " >&6
4381	<	else
4382	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4383	<	/* end confdefs.h.  */
4384	<
4385	<	int
4386	<	main ()
4387	<	{
4388	<	#ifndef __GNUC__
4389	<	choke me
4390	<	#endif
4391	<
4392	<	;
4393	<	return 0;
4394	<	}
4395	<	_ACEOF
4396	<	if ac_fn_c_try_compile "$LINENO"; then :
4397	<	ac_compiler_gnu=yes
4398	<	else
4399	<	ac_compiler_gnu=no
4400	<	fi
4401	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4402	<	ac_cv_c_compiler_gnu=$ac_compiler_gnu
4403	<
4404	<	fi
4405	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
4406	<	$as_echo "$ac_cv_c_compiler_gnu" >&6; }
4407	<	if test $ac_compiler_gnu = yes; then
4408	<	GCC=yes
4409	<	else
4410	<	GCC=
4411	<	fi
4412	<	ac_test_CFLAGS=${CFLAGS+set}
4413	<	ac_save_CFLAGS=$CFLAGS
4414	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
4415	<	$as_echo_n "checking whether $CC accepts -g... " >&6; }
4416	<	if test "${ac_cv_prog_cc_g+set}" = set; then :
4417	<	$as_echo_n "(cached) " >&6
4418	<	else
4419	<	ac_save_c_werror_flag=$ac_c_werror_flag
4420	<	ac_c_werror_flag=yes
4421	<	ac_cv_prog_cc_g=no
4422	<	CFLAGS="-g"
4423	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4424	<	/* end confdefs.h.  */
4425	<
4426	<	int
4427	<	main ()
4428	<	{
4429	<
4430	<	;
4431	<	return 0;
4432	<	}
4433	<	_ACEOF
4434	<	if ac_fn_c_try_compile "$LINENO"; then :
4435	<	ac_cv_prog_cc_g=yes
4436	<	else
4437	<	CFLAGS=""
4438	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4439	<	/* end confdefs.h.  */
4440	<
4441	<	int
4442	<	main ()
4443	<	{
4444	<
4445	<	;
4446	<	return 0;
4447	<	}
4448	<	_ACEOF
4449	<	if ac_fn_c_try_compile "$LINENO"; then :
4450	<
4451	<	else
4452	<	ac_c_werror_flag=$ac_save_c_werror_flag
4453	<	CFLAGS="-g"
4454	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4455	<	/* end confdefs.h.  */
4456	<
4457	<	int
4458	<	main ()
4459	<	{
4460	<
4461	<	;
4462	<	return 0;
4463	<	}
4464	<	_ACEOF
4465	<	if ac_fn_c_try_compile "$LINENO"; then :
4466	<	ac_cv_prog_cc_g=yes
4467	<	fi
4468	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4469	<	fi
4470	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4471	<	fi
4472	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4473	<	ac_c_werror_flag=$ac_save_c_werror_flag
4474	<	fi
4475	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
4476	<	$as_echo "$ac_cv_prog_cc_g" >&6; }
4477	<	if test "$ac_test_CFLAGS" = set; then
4478	<	CFLAGS=$ac_save_CFLAGS
4479	<	elif test $ac_cv_prog_cc_g = yes; then
4480	<	if test "$GCC" = yes; then
4481	<	CFLAGS="-g -O2"
4482	<	else
4483	<	CFLAGS="-g"
4484	<	fi
4485	<	else
4486	<	if test "$GCC" = yes; then
4487	<	CFLAGS="-O2"
4488	<	else
4489	<	CFLAGS=
4490	<	fi
4491	<	fi
4492	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
4493	<	$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4494	<	if test "${ac_cv_prog_cc_c89+set}" = set; then :
4495	<	$as_echo_n "(cached) " >&6
4496	<	else
4497	<	ac_cv_prog_cc_c89=no
4498	<	ac_save_CC=$CC
4499	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4500	<	/* end confdefs.h.  */
4501	<	#include <stdarg.h>
4502	<	#include <stdio.h>
4503	<	#include <sys/types.h>
4504	<	#include <sys/stat.h>
4505	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4506	<	struct buf { int x; };
4507	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
4508	<	static char *e (p, i)
4509	<	char **p;
4510	<	int i;
4511	<	{
4512	<	return p[i];
4513	<	}
4514	<	static char *f (char * (*g) (char **, int), char **p, ...)
4515	<	{
4516	<	char *s;
4517	<	va_list v;
4518	<	va_start (v,p);
4519	<	s = g (p, va_arg (v,int));
4520	<	va_end (v);
4521	<	return s;
4522	<	}
4523	<
4524	<	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
4525	<	function prototypes and stuff, but not '\xHH' hex character constants.
4526	<	These don't provoke an error unfortunately, instead are silently treated
4527	<	as 'x'.  The following induces an error, until -std is added to get
4528	<	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4529	<	array size at least.  It's necessary to write '\x00'==0 to get something
4530	<	that's true only with -std.  */
4531	<	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
4532	<
4533	<	/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
4534	<	inside strings and character constants.  */
4535	<	#define FOO(x) 'x'
4536	<	int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
4537	<
4538	<	int test (int i, double x);
4539	<	struct s1 {int (*f) (int a);};
4540	<	struct s2 {int (*f) (double a);};
4541	<	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
4542	<	int argc;
4543	<	char **argv;
4544	<	int
4545	<	main ()
4546	<	{
4547	<	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
4548	<	;
4549	<	return 0;
4550	<	}
4551	<	_ACEOF
4552	<	for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
4553	<	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4554	<	do
4555	<	CC="$ac_save_CC $ac_arg"
4556	<	if ac_fn_c_try_compile "$LINENO"; then :
4557	<	ac_cv_prog_cc_c89=$ac_arg
4558	<	fi
4559	<	rm -f core conftest.err conftest.$ac_objext
4560	<	test "x$ac_cv_prog_cc_c89" != "xno" && break
4561	<	done
4562	<	rm -f conftest.$ac_ext
4563	<	CC=$ac_save_CC
4564	<
4565	<	fi
4566	<	# AC_CACHE_VAL
4567	<	case "x$ac_cv_prog_cc_c89" in
4568	<	x)
4569	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
4570	<	$as_echo "none needed" >&6; } ;;
4571	<	xno)
4572	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
4573	<	$as_echo "unsupported" >&6; } ;;
4574	<	*)
4575	<	CC="$CC $ac_cv_prog_cc_c89"
4576	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
4577	<	$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4578	<	esac
4579	<	if test "x$ac_cv_prog_cc_c89" != xno; then :
4580	<
4581	<	fi
4582	<
4583	<	ac_ext=c
4584	<	ac_cpp='$CPP $CPPFLAGS'
4585	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4586	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4587	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4588	<
4589	<
4590	<	if test $USE_MPI != no; then :
4591	<
4592	<	ac_ext=c
4593	<	ac_cpp='$CPP $CPPFLAGS'
4594	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4595	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4596	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4597	<
4598	<
4599	<
4600	<
4601	<
4602	<
4603	<	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4604	<	do
4605	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4606	<	set dummy $ac_prog; ac_word=$2
4607	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4608	<	$as_echo_n "checking for $ac_word... " >&6; }
4609	<	if test "${ac_cv_prog_MPICC+set}" = set; then :
4610	<	$as_echo_n "(cached) " >&6
4611	<	else
4612	<	if test -n "$MPICC"; then
4613	<	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4614	<	else
4615	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4616	<	for as_dir in $PATH
4617	<	do
4618	<	IFS=$as_save_IFS
4619	<	test -z "$as_dir" && as_dir=.
4620	<	for ac_exec_ext in '' $ac_executable_extensions; do
4621	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4622	<	ac_cv_prog_MPICC="$ac_prog"
4623	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4624	<	break 2
4625	<	fi
4626	<	done
4627	<	done
4628	<	IFS=$as_save_IFS
4629	<
4630	<	fi
4631	<	fi
4632	<	MPICC=$ac_cv_prog_MPICC
4633	<	if test -n "$MPICC"; then
4634	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4635	<	$as_echo "$MPICC" >&6; }
4636	<	else
4637	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4638	<	$as_echo "no" >&6; }
4639	<	fi
4640	<
4641	<
4642	<	test -n "$MPICC" && break
4643	<	done
4644	<	test -n "$MPICC" || MPICC="$CC"
4645	<
4646	<	ax_mpi_save_CC="$CC"
4647	<	CC="$MPICC"
4648	<
4649	<
4650	<
4651	<	if test x = x"$MPILIBS"; then
4652	<	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4653	<	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4654	<	MPILIBS=" "
4655	<	fi
4656	<
4657	<	fi
4658	<
4659	<	if test x = x"$MPILIBS"; then
4660	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4661	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4662	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4663	<	$as_echo_n "(cached) " >&6
4664	<	else
4665	<	ac_check_lib_save_LIBS=$LIBS
4666	<	LIBS="-lmpi  $LIBS"
4667	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4668	<	/* end confdefs.h.  */
4669	<
4670	<	/* Override any GCC internal prototype to avoid an error.
4671	<	Use char because int might match the return type of a GCC
4672	<	builtin and then its argument prototype would still apply.  */
4673	<	#ifdef __cplusplus
4674	<	extern "C"
4675	<	#endif
4676	<	char MPI_Init ();
4677	<	int
4678	<	main ()
4679	<	{
4680	<	return MPI_Init ();
4681	<	;
4682	<	return 0;
4683	<	}
4684	<	_ACEOF
4685	<	if ac_fn_c_try_link "$LINENO"; then :
4686	<	ac_cv_lib_mpi_MPI_Init=yes
4687	<	else
4688	<	ac_cv_lib_mpi_MPI_Init=no
4689	<	fi
4690	<	rm -f core conftest.err conftest.$ac_objext \
4691	<	conftest$ac_exeext conftest.$ac_ext
4692	<	LIBS=$ac_check_lib_save_LIBS
4693	<	fi
4694	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4695	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4696	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4697	<	MPILIBS="-lmpi"
4698	<	fi
4699	<
4700	<	fi
4701	<	if test x = x"$MPILIBS"; then
4702	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4703	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4704	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4705	<	$as_echo_n "(cached) " >&6
4706	<	else
4707	<	ac_check_lib_save_LIBS=$LIBS
4708	<	LIBS="-lmpich  $LIBS"
4709	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4710	<	/* end confdefs.h.  */
4711	<
4712	<	/* Override any GCC internal prototype to avoid an error.
4713	<	Use char because int might match the return type of a GCC
4714	<	builtin and then its argument prototype would still apply.  */
4715	<	#ifdef __cplusplus
4716	<	extern "C"
4717	<	#endif
4718	<	char MPI_Init ();
4719	<	int
4720	<	main ()
4721	<	{
4722	<	return MPI_Init ();
4723	<	;
4724	<	return 0;
4725	<	}
4726	<	_ACEOF
4727	<	if ac_fn_c_try_link "$LINENO"; then :
4728	<	ac_cv_lib_mpich_MPI_Init=yes
4729	<	else
4730	<	ac_cv_lib_mpich_MPI_Init=no
4731	<	fi
4732	<	rm -f core conftest.err conftest.$ac_objext \
4733	<	conftest$ac_exeext conftest.$ac_ext
4734	<	LIBS=$ac_check_lib_save_LIBS
4735	<	fi
4736	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4737	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4738	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4739	<	MPILIBS="-lmpich"
4740	<	fi
4741	<
4742	<	fi
4743	<
4744	<	if test x != x"$MPILIBS"; then
4745	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4746	<	$as_echo_n "checking for mpi.h... " >&6; }
4747	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4748	<	/* end confdefs.h.  */
4749	<	#include <mpi.h>
4750	<	int
4751	<	main ()
4752	<	{
4753	<
4754	<	;
4755	<	return 0;
4756	<	}
4757	<	_ACEOF
4758	<	if ac_fn_c_try_compile "$LINENO"; then :
4759	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4760	<	$as_echo "yes" >&6; }
4761	<	else
4762	<	MPILIBS=""
4763	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4764	<	$as_echo "no" >&6; }
4765	<	fi
4766	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4767	<	fi
4768	<
4769	<	CC="$ax_mpi_save_CC"
4770	<
4771	<
4772	<
4773	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4774	<	if test x = x"$MPILIBS"; then
4775	<	USE_MPI="no"
4776	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4777	<	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4778	<	:
4779	<	else
4780	<	USE_MPI="yes"
4781	<	:
4782	<	fi
4783	<
4784	<
4785	<	fi
4786	<	ac_ext=${ac_fc_srcext-f}
4787	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4788	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4789	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4790	<	if test -n "$ac_tool_prefix"; then
4791	<	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
4792	<	do
4793	<	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4794	<	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4795	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4796	<	$as_echo_n "checking for $ac_word... " >&6; }
4797	<	if test "${ac_cv_prog_FC+set}" = set; then :
4798	<	$as_echo_n "(cached) " >&6
4799	<	else
4800	<	if test -n "$FC"; then
4801	<	ac_cv_prog_FC="$FC" # Let the user override the test.
4802	<	else
4803	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4804	<	for as_dir in $PATH
4805	<	do
4806	<	IFS=$as_save_IFS
4807	<	test -z "$as_dir" && as_dir=.
4808	<	for ac_exec_ext in '' $ac_executable_extensions; do
4809	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4810	<	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4811	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4812	<	break 2
4813	<	fi
4814	<	done
4815	<	done
4816	<	IFS=$as_save_IFS
4817	<
4818	<	fi
4819	<	fi
4820	<	FC=$ac_cv_prog_FC
4821	<	if test -n "$FC"; then
4822	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4823	<	$as_echo "$FC" >&6; }
4824	<	else
4825	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4826	<	$as_echo "no" >&6; }
4827	<	fi
4828	<
4829	<
4830	<	test -n "$FC" && break
4831	<	done
4832	<	fi
4833	<	if test -z "$FC"; then
4834	<	ac_ct_FC=$FC
4835	<	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
4836	<	do
4837	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
4838	<	set dummy $ac_prog; ac_word=$2
4839	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4840	<	$as_echo_n "checking for $ac_word... " >&6; }
4841	<	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4842	<	$as_echo_n "(cached) " >&6
4843	<	else
4844	<	if test -n "$ac_ct_FC"; then
4845	<	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4846	<	else
4847	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4848	<	for as_dir in $PATH
4849	<	do
4850	<	IFS=$as_save_IFS
4851	<	test -z "$as_dir" && as_dir=.
4852	<	for ac_exec_ext in '' $ac_executable_extensions; do
4853	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4854	<	ac_cv_prog_ac_ct_FC="$ac_prog"
4855	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4856	<	break 2
4857	<	fi
4858	<	done
4859	<	done
4860	<	IFS=$as_save_IFS
4861	<
4862	<	fi
4863	<	fi
4864	<	ac_ct_FC=$ac_cv_prog_ac_ct_FC
4865	<	if test -n "$ac_ct_FC"; then
4866	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4867	<	$as_echo "$ac_ct_FC" >&6; }
4868	<	else
4869	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4870	<	$as_echo "no" >&6; }
4871	<	fi
4872	<
4873	<
4874	<	test -n "$ac_ct_FC" && break
4875	<	done
4876	<
4877	<	if test "x$ac_ct_FC" = x; then
4878	<	FC=""
4879	<	else
4880	<	case $cross_compiling:$ac_tool_warned in
4881	<	yes:)
4882	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4883	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4884	<	ac_tool_warned=yes ;;
4885	<	esac
4886	<	FC=$ac_ct_FC
4887	<	fi
4888	<	fi
4889	<
4890	<
4891	<	# Provide some information about the compiler.
4892	<	$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4893	<	set X $ac_compile
4894	<	ac_compiler=$2
4895	<	for ac_option in --version -v -V -qversion; do
4896	<	{ { ac_try="$ac_compiler $ac_option >&5"
4897	<	case "(($ac_try" in
4898	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4899	<	*) ac_try_echo=$ac_try;;
4900	<	esac
4901	<	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4902	<	$as_echo "$ac_try_echo"; } >&5
4903	<	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4904	<	ac_status=$?
4905	<	if test -s conftest.err; then
4906	<	sed '10a\
4907	<	... rest of stderr output deleted ...
4908	<	10q' conftest.err >conftest.er1
4909	<	cat conftest.er1 >&5
4910	<	fi
4911	<	rm -f conftest.er1 conftest.err
4912	<	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4913	<	test $ac_status = 0; }
4914	<	done
4915	<	rm -f a.out
4916	<
4917	<	# If we don't use `.F' as extension, the preprocessor is not run on the
4918	<	# input file.  (Note that this only needs to work for GNU compilers.)
4919	<	ac_save_ext=$ac_ext
4920	<	ac_ext=F
4921	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4922	<	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4923	<	if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4924	<	$as_echo_n "(cached) " >&6
4925	<	else
4926	<	cat > conftest.$ac_ext <<_ACEOF
4927	<	program main
4928	<	#ifndef __GNUC__
4929	<	choke me
4930	<	#endif
4931	<
4932	<	end
4933	<	_ACEOF
4934	<	if ac_fn_fc_try_compile "$LINENO"; then :
4935	<	ac_compiler_gnu=yes
4936	<	else
4937	<	ac_compiler_gnu=no
4938	<	fi
4939	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4940	<	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4941	<
4942	<	fi
4943	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4944	<	$as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4945	<	ac_ext=$ac_save_ext
4946	<	ac_test_FCFLAGS=${FCFLAGS+set}
4947	<	ac_save_FCFLAGS=$FCFLAGS
4948	<	FCFLAGS=
4949	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4950	<	$as_echo_n "checking whether $FC accepts -g... " >&6; }
4951	<	if test "${ac_cv_prog_fc_g+set}" = set; then :
4952	<	$as_echo_n "(cached) " >&6
4953	<	else
4954	<	FCFLAGS=-g
4955	<	cat > conftest.$ac_ext <<_ACEOF
4956	<	program main
4957	<
4958	<	end
4959	<	_ACEOF
4960	<	if ac_fn_fc_try_compile "$LINENO"; then :
4961	<	ac_cv_prog_fc_g=yes
4962	<	else
4963	<	ac_cv_prog_fc_g=no
4964	<	fi
4965	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4966	<
4967	<	fi
4968	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
4969	<	$as_echo "$ac_cv_prog_fc_g" >&6; }
4970	<	if test "$ac_test_FCFLAGS" = set; then
4971	<	FCFLAGS=$ac_save_FCFLAGS
4972	<	elif test $ac_cv_prog_fc_g = yes; then
4973	<	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4974	<	FCFLAGS="-g -O2"
4975	<	else
4976	<	FCFLAGS="-g"
4977	<	fi
4978	<	else
4979	<	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4980	<	FCFLAGS="-O2"
4981	<	else
4982	<	FCFLAGS=
4983	<	fi
4984	<	fi
4985	<
4986	<	ac_ext=${ac_fc_srcext-f}
4987	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4988	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4989	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4990	<
4991	<
4992	<	if test $USE_MPI != no; then :
4993	<
4994	<	ac_ext=${ac_fc_srcext-f}
4995	<	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4996	<	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4997	<	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4998	<
4999	<
5000	<
5001	<
5002	<
5003	<
5004	<	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
5005	<	do
5006	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
5007	<	set dummy $ac_prog; ac_word=$2
5008	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5009	<	$as_echo_n "checking for $ac_word... " >&6; }
5010	<	if test "${ac_cv_prog_MPIFC+set}" = set; then :
5011	<	$as_echo_n "(cached) " >&6
5012	<	else
5013	<	if test -n "$MPIFC"; then
5014	<	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
5015	<	else
5016	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5017	<	for as_dir in $PATH
5018	<	do
5019	<	IFS=$as_save_IFS
5020	<	test -z "$as_dir" && as_dir=.
5021	<	for ac_exec_ext in '' $ac_executable_extensions; do
5022	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5023	<	ac_cv_prog_MPIFC="$ac_prog"
5024	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5025	<	break 2
5026	<	fi
5027	<	done
5028	<	done
5029	<	IFS=$as_save_IFS
5030	<
5031	<	fi
5032	<	fi
5033	<	MPIFC=$ac_cv_prog_MPIFC
5034	<	if test -n "$MPIFC"; then
5035	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5036	<	$as_echo "$MPIFC" >&6; }
5037	<	else
5038	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5039	<	$as_echo "no" >&6; }
5040	<	fi
5041	<
5042	<
5043	<	test -n "$MPIFC" && break
5044	<	done
5045	<	test -n "$MPIFC" || MPIFC="$FC"
5046	<
5047	<	ax_mpi_save_FC="$FC"
5048	<	FC="$MPIFC"
5049	<
5050	<
5051	<
5052	<	if test x = x"$MPILIBS"; then
5053	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5054	<	$as_echo_n "checking for MPI_Init... " >&6; }
5055	<	cat > conftest.$ac_ext <<_ACEOF
5056	<	program main
5057	<	call MPI_Init
5058	<	end
5059	<	_ACEOF
5060	<	if ac_fn_fc_try_link "$LINENO"; then :
5061	<	MPILIBS=" "
5062	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5063	<	$as_echo "yes" >&6; }
5064	<	else
5065	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5066	<	$as_echo "no" >&6; }
5067	<	fi
5068	<	rm -f core conftest.err conftest.$ac_objext \
5069	<	conftest$ac_exeext conftest.$ac_ext
5070	<	fi
5071	<
5072	<	if test x = x"$MPILIBS"; then
5073	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5074	<	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5075	<	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5076	<	$as_echo_n "(cached) " >&6
5077	<	else
5078	<	ac_check_lib_save_LIBS=$LIBS
5079	<	LIBS="-lfmpi  $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_fmpi_MPI_Init=yes
5087	<	else
5088	<	ac_cv_lib_fmpi_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_fmpi_MPI_Init" >&5
5095	<	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5096	<	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5097	<	MPILIBS="-lfmpi"
5098	<	fi
5099	<
5100	<	fi
5101	<	if test x = x"$MPILIBS"; then
5102	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5103	<	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5104	<	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5105	<	$as_echo_n "(cached) " >&6
5106	<	else
5107	<	ac_check_lib_save_LIBS=$LIBS
5108	<	LIBS="-lmpichf90  $LIBS"
5109	<	cat > conftest.$ac_ext <<_ACEOF
5110	<	program main
5111	<	call MPI_Init
5112	<	end
5113	<	_ACEOF
5114	<	if ac_fn_fc_try_link "$LINENO"; then :
5115	<	ac_cv_lib_mpichf90_MPI_Init=yes
5116	<	else
5117	<	ac_cv_lib_mpichf90_MPI_Init=no
5118	<	fi
5119	<	rm -f core conftest.err conftest.$ac_objext \
5120	<	conftest$ac_exeext conftest.$ac_ext
5121	<	LIBS=$ac_check_lib_save_LIBS
5122	<	fi
5123	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5124	<	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5125	<	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5126	<	MPILIBS="-lmpichf90"
5127	<	fi
5128	<
5129	<	fi
5130	<
5131	<	if test x = x"$MPILIBS"; then
5132	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5133	<	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5134	<	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5135	<	$as_echo_n "(cached) " >&6
5136	<	else
5137	<	ac_check_lib_save_LIBS=$LIBS
5138	<	LIBS="-lmpi  $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_mpi_MPI_Init=yes
5146	<	else
5147	<	ac_cv_lib_mpi_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_mpi_MPI_Init" >&5
5154	<	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5155	<	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5156	<	MPILIBS="-lmpi"
5157	<	fi
5158	<
5159	<	fi
5160	<	if test x = x"$MPILIBS"; then
5161	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
5162	<	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
5163	<	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
5164	<	$as_echo_n "(cached) " >&6
5165	<	else
5166	<	ac_check_lib_save_LIBS=$LIBS
5167	<	LIBS="-lmpich  $LIBS"
5168	<	cat > conftest.$ac_ext <<_ACEOF
5169	<	program main
5170	<	call MPI_Init
5171	<	end
5172	<	_ACEOF
5173	<	if ac_fn_fc_try_link "$LINENO"; then :
5174	<	ac_cv_lib_mpich_MPI_Init=yes
5175	<	else
5176	<	ac_cv_lib_mpich_MPI_Init=no
5177	<	fi
5178	<	rm -f core conftest.err conftest.$ac_objext \
5179	<	conftest$ac_exeext conftest.$ac_ext
5180	<	LIBS=$ac_check_lib_save_LIBS
5181	<	fi
5182	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5183	<	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5184	<	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5185	<	MPILIBS="-lmpich"
5186	<	fi
5187	<
5188	<	fi
5189	<
5190	<	if test x != x"$MPILIBS"; then
5191	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
5192	<	$as_echo_n "checking for mpif.h... " >&6; }
5193	<	cat > conftest.$ac_ext <<_ACEOF
5194	<	program main
5195	<	include 'mpif.h'
5196	<	end
5197	<	_ACEOF
5198	<	if ac_fn_fc_try_compile "$LINENO"; then :
5199	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5200	<	$as_echo "yes" >&6; }
5201	<	else
5202	<	MPILIBS=""
5203	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5204	<	$as_echo "no" >&6; }
5205	<	fi
5206	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5207	<	fi
5208	<
5209	<	FC="$ax_mpi_save_FC"
5210	<
5211	<
5212	<
5213	<	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
5214	<	if test x = x"$MPILIBS"; then
5215	<	USE_MPI="no"
5216	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
5217	<	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
5218	<	:
3008	>	# Check whether --enable-single was given.
3009	>	if test "${enable_single+set}" = set; then :
3010	>	enableval=$enable_single; ok=$enableval
3011		else
3012	<	USE_MPI="yes"
5221	<	:
3012	>	ok=no
3013		fi
3014
3015	<
3015	>	# Check whether --enable-float was given.
3016	>	if test "${enable_float+set}" = set; then :
3017	>	enableval=$enable_float; ok=$enableval
3018		fi
5226	–	if test $USE_MPI != no; then :
3019
3020	<	CXX=$MPICXX
5229	<	CC=$MPICC
5230	<	FC=$MPIFC
3020	>	if test "$ok" = "yes"; then
3021
3022	<	fi
3022	>	$as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3023
3024	+	USE_SINGLE_PRECISION=yes
3025
3026	<	# Checks for programs.
3026	>	fi
3027	>
3028		ac_ext=cpp
3029		ac_cpp='$CXXCPP $CPPFLAGS'
3030		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 5369 | Line 3161 | done
3161		test $ac_status = 0; }
3162		done
3163
3164	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3165	+	/* end confdefs.h.  */
3166	+
3167	+	int
3168	+	main ()
3169	+	{
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"
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 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:
3185	+	ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3186	+
3187	+	ac_rmfiles=
3188	+	for ac_file in $ac_files
3189	+	do
3190	+	case $ac_file in
3191	+	*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3192	+	* ) ac_rmfiles="$ac_rmfiles $ac_file";;
3193	+	esac
3194	+	done
3195	+	rm -f $ac_rmfiles
3196	+
3197	+	if { { ac_try="$ac_link_default"
3198	+	case "(($ac_try" in
3199	+	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3200	+	*) ac_try_echo=$ac_try;;
3201	+	esac
3202	+	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
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
3237	+	done
3238	+	test "$ac_cv_exeext" = no && ac_cv_exeext=
3239	+
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	+	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	+	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	+	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	+	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_compile") 2>&5
3389	+	ac_status=$?
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 5484 | 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 5831 | 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 6036 | 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'

Diff Legend

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