ViewVC Help

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

root/OpenMD/trunk/configure

Comparing trunk/configure (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1487 by gezelter, Mon Aug 2 14:22:55 2010 UTC

#	Line 613 | Line 613 | OPENBABEL_INC_DIR
613		OPENBABEL_LIB
614		OPENBABEL_LIB_DIR
615		OPENBABEL_INC_DIR
616	–	CXXCPP
616		USE_QHULL
617		QHULL
618		QHULL_LIB_DIR
619		QHULL_INC_DIR
620	+	CXXCPP
621		FFTW_LIBS
622		FFTW_LIB_DIR
623		FFTW_INC_DIR
#	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
1716
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
1681	–
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 3027 | Line 3022 | $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3022		$as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3023
3024		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
3109	–	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
3025
3119	–
3120	–	else
3121	–
3122	–	as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3026		fi
3027
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	–
3028		ac_ext=cpp
3029		ac_cpp='$CXXCPP $CPPFLAGS'
3030		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3031		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3032		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3351	–
3352	–	ac_ext=cpp
3353	–	ac_cpp='$CXXCPP $CPPFLAGS'
3354	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3355	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3356	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3033		if test -z "$CXX"; then
3034		if test -n "$CCC"; then
3035		CXX=$CCC
3036		else
3037		if test -n "$ac_tool_prefix"; then
3038	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3038	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
3039		do
3040		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3041		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
#	Line 3403 | Line 3079 | if test -z "$CXX"; then
3079		fi
3080		if test -z "$CXX"; then
3081		ac_ct_CXX=$CXX
3082	<	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3082	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
3083		do
3084		# Extract the first word of "$ac_prog", so it can be a program name with args.
3085		set dummy $ac_prog; ac_word=$2
#	Line 3851 | Line 3527 | fi
3527		CXXFLAGS=
3528		fi
3529		fi
3530	<	ac_ext=cpp
3531	<	ac_cpp='$CXXCPP $CPPFLAGS'
3532	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3533	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3534	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3859	<
3860	<
3861	<
3862	<
3863	<
3864	<
3865	<
3866	<	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3867	<	do
3868	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
3869	<	set dummy $ac_prog; ac_word=$2
3870	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3871	<	$as_echo_n "checking for $ac_word... " >&6; }
3872	<	if test "${ac_cv_prog_MPICXX+set}" = set; then :
3873	<	$as_echo_n "(cached) " >&6
3874	<	else
3875	<	if test -n "$MPICXX"; then
3876	<	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3877	<	else
3878	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3879	<	for as_dir in $PATH
3880	<	do
3881	<	IFS=$as_save_IFS
3882	<	test -z "$as_dir" && as_dir=.
3883	<	for ac_exec_ext in '' $ac_executable_extensions; do
3884	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3885	<	ac_cv_prog_MPICXX="$ac_prog"
3886	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3887	<	break 2
3888	<	fi
3889	<	done
3890	<	done
3891	<	IFS=$as_save_IFS
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
3893	–	fi
3894	–	fi
3895	–	MPICXX=$ac_cv_prog_MPICXX
3896	–	if test -n "$MPICXX"; then
3897	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3898	–	$as_echo "$MPICXX" >&6; }
3899	–	else
3900	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3901	–	$as_echo "no" >&6; }
3902	–	fi
3903	–
3904	–
3905	–	test -n "$MPICXX" && break
3906	–	done
3907	–	test -n "$MPICXX" || MPICXX="$CXX"
3908	–
3909	–	ax_mpi_save_CXX="$CXX"
3910	–	CXX="$MPICXX"
3911	–
3912	–
3913	–
3914	–	if test x = x"$MPILIBS"; then
3915	–	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3916	–	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3917	–	MPILIBS=" "
3918	–	fi
3919	–
3920	–	fi
3921	–
3922	–	if test x = x"$MPILIBS"; then
3923	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3924	–	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3925	–	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3926	–	$as_echo_n "(cached) " >&6
3927	–	else
3928	–	ac_check_lib_save_LIBS=$LIBS
3929	–	LIBS="-lmpi  $LIBS"
3930	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3931	–	/* end confdefs.h.  */
3932	–
3933	–	/* Override any GCC internal prototype to avoid an error.
3934	–	Use char because int might match the return type of a GCC
3935	–	builtin and then its argument prototype would still apply.  */
3936	–	#ifdef __cplusplus
3937	–	extern "C"
3938	–	#endif
3939	–	char MPI_Init ();
3940	–	int
3941	–	main ()
3942	–	{
3943	–	return MPI_Init ();
3944	–	;
3945	–	return 0;
3946	–	}
3947	–	_ACEOF
3948	–	if ac_fn_cxx_try_link "$LINENO"; then :
3949	–	ac_cv_lib_mpi_MPI_Init=yes
3950	–	else
3951	–	ac_cv_lib_mpi_MPI_Init=no
3952	–	fi
3953	–	rm -f core conftest.err conftest.$ac_objext \
3954	–	conftest$ac_exeext conftest.$ac_ext
3955	–	LIBS=$ac_check_lib_save_LIBS
3956	–	fi
3957	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3958	–	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3959	–	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
3960	–	MPILIBS="-lmpi"
3961	–	fi
3962	–
3963	–	fi
3964	–	if test x = x"$MPILIBS"; then
3965	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3966	–	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3967	–	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
3968	–	$as_echo_n "(cached) " >&6
3969	–	else
3970	–	ac_check_lib_save_LIBS=$LIBS
3971	–	LIBS="-lmpich  $LIBS"
3972	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3973	–	/* end confdefs.h.  */
3974	–
3975	–	/* Override any GCC internal prototype to avoid an error.
3976	–	Use char because int might match the return type of a GCC
3977	–	builtin and then its argument prototype would still apply.  */
3978	–	#ifdef __cplusplus
3979	–	extern "C"
3980	–	#endif
3981	–	char MPI_Init ();
3982	–	int
3983	–	main ()
3984	–	{
3985	–	return MPI_Init ();
3986	–	;
3987	–	return 0;
3988	–	}
3989	–	_ACEOF
3990	–	if ac_fn_cxx_try_link "$LINENO"; then :
3991	–	ac_cv_lib_mpich_MPI_Init=yes
3992	–	else
3993	–	ac_cv_lib_mpich_MPI_Init=no
3994	–	fi
3995	–	rm -f core conftest.err conftest.$ac_objext \
3996	–	conftest$ac_exeext conftest.$ac_ext
3997	–	LIBS=$ac_check_lib_save_LIBS
3998	–	fi
3999	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4000	–	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4001	–	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4002	–	MPILIBS="-lmpich"
4003	–	fi
4004	–
4005	–	fi
4006	–
4007	–	if test x != x"$MPILIBS"; then
4008	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4009	–	$as_echo_n "checking for mpi.h... " >&6; }
4010	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4011	–	/* end confdefs.h.  */
4012	–	#include <mpi.h>
4013	–	int
4014	–	main ()
4015	–	{
4016	–
4017	–	;
4018	–	return 0;
4019	–	}
4020	–	_ACEOF
4021	–	if ac_fn_cxx_try_compile "$LINENO"; then :
4022	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4023	–	$as_echo "yes" >&6; }
4024	–	else
4025	–	MPILIBS=""
4026	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4027	–	$as_echo "no" >&6; }
4028	–	fi
4029	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4030	–	fi
4031	–
4032	–	CXX="$ax_mpi_save_CXX"
4033	–
4034	–
4035	–
4036	–	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4037	–	if test x = x"$MPILIBS"; then
4038	–	USE_MPI="no"
4039	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4040	–	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4041	–	:
4042	–	else
4043	–	USE_MPI="yes"
4044	–	:
4045	–	fi
4046	–
3536		ac_ext=c
3537		ac_cpp='$CPP $CPPFLAGS'
3538		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3539		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3540		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3541		if test -n "$ac_tool_prefix"; then
3542	<	# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4054	<	set dummy ${ac_tool_prefix}gcc; ac_word=$2
4055	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4056	<	$as_echo_n "checking for $ac_word... " >&6; }
4057	<	if test "${ac_cv_prog_CC+set}" = set; then :
4058	<	$as_echo_n "(cached) " >&6
4059	<	else
4060	<	if test -n "$CC"; then
4061	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4062	<	else
4063	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4064	<	for as_dir in $PATH
4065	<	do
4066	<	IFS=$as_save_IFS
4067	<	test -z "$as_dir" && as_dir=.
4068	<	for ac_exec_ext in '' $ac_executable_extensions; do
4069	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4070	<	ac_cv_prog_CC="${ac_tool_prefix}gcc"
4071	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4072	<	break 2
4073	<	fi
4074	<	done
4075	<	done
4076	<	IFS=$as_save_IFS
4077	<
4078	<	fi
4079	<	fi
4080	<	CC=$ac_cv_prog_CC
4081	<	if test -n "$CC"; then
4082	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4083	<	$as_echo "$CC" >&6; }
4084	<	else
4085	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4086	<	$as_echo "no" >&6; }
4087	<	fi
4088	<
4089	<
4090	<	fi
4091	<	if test -z "$ac_cv_prog_CC"; then
4092	<	ac_ct_CC=$CC
4093	<	# Extract the first word of "gcc", so it can be a program name with args.
4094	<	set dummy gcc; ac_word=$2
4095	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4096	<	$as_echo_n "checking for $ac_word... " >&6; }
4097	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4098	<	$as_echo_n "(cached) " >&6
4099	<	else
4100	<	if test -n "$ac_ct_CC"; then
4101	<	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4102	<	else
4103	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4104	<	for as_dir in $PATH
4105	<	do
4106	<	IFS=$as_save_IFS
4107	<	test -z "$as_dir" && as_dir=.
4108	<	for ac_exec_ext in '' $ac_executable_extensions; do
4109	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4110	<	ac_cv_prog_ac_ct_CC="gcc"
4111	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4112	<	break 2
4113	<	fi
4114	<	done
4115	<	done
4116	<	IFS=$as_save_IFS
4117	<
4118	<	fi
4119	<	fi
4120	<	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4121	<	if test -n "$ac_ct_CC"; then
4122	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4123	<	$as_echo "$ac_ct_CC" >&6; }
4124	<	else
4125	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4126	<	$as_echo "no" >&6; }
4127	<	fi
4128	<
4129	<	if test "x$ac_ct_CC" = x; then
4130	<	CC=""
4131	<	else
4132	<	case $cross_compiling:$ac_tool_warned in
4133	<	yes:)
4134	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4135	<	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4136	<	ac_tool_warned=yes ;;
4137	<	esac
4138	<	CC=$ac_ct_CC
4139	<	fi
4140	<	else
4141	<	CC="$ac_cv_prog_CC"
4142	<	fi
4143	<
4144	<	if test -z "$CC"; then
4145	<	if test -n "$ac_tool_prefix"; then
4146	<	# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4147	<	set dummy ${ac_tool_prefix}cc; ac_word=$2
4148	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4149	<	$as_echo_n "checking for $ac_word... " >&6; }
4150	<	if test "${ac_cv_prog_CC+set}" = set; then :
4151	<	$as_echo_n "(cached) " >&6
4152	<	else
4153	<	if test -n "$CC"; then
4154	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4155	<	else
4156	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4157	<	for as_dir in $PATH
4158	<	do
4159	<	IFS=$as_save_IFS
4160	<	test -z "$as_dir" && as_dir=.
4161	<	for ac_exec_ext in '' $ac_executable_extensions; do
4162	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4163	<	ac_cv_prog_CC="${ac_tool_prefix}cc"
4164	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4165	<	break 2
4166	<	fi
4167	<	done
4168	<	done
4169	<	IFS=$as_save_IFS
4170	<
4171	<	fi
4172	<	fi
4173	<	CC=$ac_cv_prog_CC
4174	<	if test -n "$CC"; then
4175	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4176	<	$as_echo "$CC" >&6; }
4177	<	else
4178	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4179	<	$as_echo "no" >&6; }
4180	<	fi
4181	<
4182	<
4183	<	fi
4184	<	fi
4185	<	if test -z "$CC"; then
4186	<	# Extract the first word of "cc", so it can be a program name with args.
4187	<	set dummy cc; ac_word=$2
4188	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4189	<	$as_echo_n "checking for $ac_word... " >&6; }
4190	<	if test "${ac_cv_prog_CC+set}" = set; then :
4191	<	$as_echo_n "(cached) " >&6
4192	<	else
4193	<	if test -n "$CC"; then
4194	<	ac_cv_prog_CC="$CC" # Let the user override the test.
4195	<	else
4196	<	ac_prog_rejected=no
4197	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4198	<	for as_dir in $PATH
4199	<	do
4200	<	IFS=$as_save_IFS
4201	<	test -z "$as_dir" && as_dir=.
4202	<	for ac_exec_ext in '' $ac_executable_extensions; do
4203	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4204	<	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4205	<	ac_prog_rejected=yes
4206	<	continue
4207	<	fi
4208	<	ac_cv_prog_CC="cc"
4209	<	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4210	<	break 2
4211	<	fi
4212	<	done
4213	<	done
4214	<	IFS=$as_save_IFS
4215	<
4216	<	if test $ac_prog_rejected = yes; then
4217	<	# We found a bogon in the path, so make sure we never use it.
4218	<	set dummy $ac_cv_prog_CC
4219	<	shift
4220	<	if test $# != 0; then
4221	<	# We chose a different compiler from the bogus one.
4222	<	# However, it has the same basename, so the bogon will be chosen
4223	<	# first if we set CC to just the basename; use the full file name.
4224	<	shift
4225	<	ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4226	<	fi
4227	<	fi
4228	<	fi
4229	<	fi
4230	<	CC=$ac_cv_prog_CC
4231	<	if test -n "$CC"; then
4232	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4233	<	$as_echo "$CC" >&6; }
4234	<	else
4235	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4236	<	$as_echo "no" >&6; }
4237	<	fi
4238	<
4239	<
4240	<	fi
4241	<	if test -z "$CC"; then
4242	<	if test -n "$ac_tool_prefix"; then
4243	<	for ac_prog in cl.exe
3542	>	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3543		do
3544		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3545		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
#	Line 4284 | Line 3583 | if test -z "$CC"; then
3583		fi
3584		if test -z "$CC"; then
3585		ac_ct_CC=$CC
3586	<	for ac_prog in cl.exe
3586	>	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3587		do
3588		# Extract the first word of "$ac_prog", so it can be a program name with args.
3589		set dummy $ac_prog; ac_word=$2
#	Line 4339 | Line 3638 | fi
3638		fi
3639		fi
3640
4342	–	fi
3641
4344	–
3642		test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3643		$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3644		as_fn_error "no acceptable C compiler found in \$PATH
#	Line 4583 | Line 3880 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
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
4586	–
4587	–
4588	–	if test $USE_MPI != no; then :
4589	–
4590	–	ac_ext=c
4591	–	ac_cpp='$CPP $CPPFLAGS'
4592	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4593	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4594	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4595	–
4596	–
4597	–
4598	–
4599	–
4600	–
4601	–	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4602	–	do
4603	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
4604	–	set dummy $ac_prog; ac_word=$2
4605	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4606	–	$as_echo_n "checking for $ac_word... " >&6; }
4607	–	if test "${ac_cv_prog_MPICC+set}" = set; then :
4608	–	$as_echo_n "(cached) " >&6
4609	–	else
4610	–	if test -n "$MPICC"; then
4611	–	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4612	–	else
4613	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4614	–	for as_dir in $PATH
4615	–	do
4616	–	IFS=$as_save_IFS
4617	–	test -z "$as_dir" && as_dir=.
4618	–	for ac_exec_ext in '' $ac_executable_extensions; do
4619	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4620	–	ac_cv_prog_MPICC="$ac_prog"
4621	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4622	–	break 2
4623	–	fi
4624	–	done
4625	–	done
4626	–	IFS=$as_save_IFS
4627	–
4628	–	fi
4629	–	fi
4630	–	MPICC=$ac_cv_prog_MPICC
4631	–	if test -n "$MPICC"; then
4632	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4633	–	$as_echo "$MPICC" >&6; }
4634	–	else
4635	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4636	–	$as_echo "no" >&6; }
4637	–	fi
4638	–
4639	–
4640	–	test -n "$MPICC" && break
4641	–	done
4642	–	test -n "$MPICC" || MPICC="$CC"
4643	–
4644	–	ax_mpi_save_CC="$CC"
4645	–	CC="$MPICC"
4646	–
4647	–
4648	–
4649	–	if test x = x"$MPILIBS"; then
4650	–	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4651	–	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4652	–	MPILIBS=" "
4653	–	fi
4654	–
4655	–	fi
4656	–
4657	–	if test x = x"$MPILIBS"; then
4658	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4659	–	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4660	–	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4661	–	$as_echo_n "(cached) " >&6
4662	–	else
4663	–	ac_check_lib_save_LIBS=$LIBS
4664	–	LIBS="-lmpi  $LIBS"
4665	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4666	–	/* end confdefs.h.  */
4667	–
4668	–	/* Override any GCC internal prototype to avoid an error.
4669	–	Use char because int might match the return type of a GCC
4670	–	builtin and then its argument prototype would still apply.  */
4671	–	#ifdef __cplusplus
4672	–	extern "C"
4673	–	#endif
4674	–	char MPI_Init ();
4675	–	int
4676	–	main ()
4677	–	{
4678	–	return MPI_Init ();
4679	–	;
4680	–	return 0;
4681	–	}
4682	–	_ACEOF
4683	–	if ac_fn_c_try_link "$LINENO"; then :
4684	–	ac_cv_lib_mpi_MPI_Init=yes
4685	–	else
4686	–	ac_cv_lib_mpi_MPI_Init=no
4687	–	fi
4688	–	rm -f core conftest.err conftest.$ac_objext \
4689	–	conftest$ac_exeext conftest.$ac_ext
4690	–	LIBS=$ac_check_lib_save_LIBS
4691	–	fi
4692	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4693	–	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4694	–	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4695	–	MPILIBS="-lmpi"
4696	–	fi
4697	–
4698	–	fi
4699	–	if test x = x"$MPILIBS"; then
4700	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4701	–	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4702	–	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4703	–	$as_echo_n "(cached) " >&6
4704	–	else
4705	–	ac_check_lib_save_LIBS=$LIBS
4706	–	LIBS="-lmpich  $LIBS"
4707	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4708	–	/* end confdefs.h.  */
4709	–
4710	–	/* Override any GCC internal prototype to avoid an error.
4711	–	Use char because int might match the return type of a GCC
4712	–	builtin and then its argument prototype would still apply.  */
4713	–	#ifdef __cplusplus
4714	–	extern "C"
4715	–	#endif
4716	–	char MPI_Init ();
4717	–	int
4718	–	main ()
4719	–	{
4720	–	return MPI_Init ();
4721	–	;
4722	–	return 0;
4723	–	}
4724	–	_ACEOF
4725	–	if ac_fn_c_try_link "$LINENO"; then :
4726	–	ac_cv_lib_mpich_MPI_Init=yes
4727	–	else
4728	–	ac_cv_lib_mpich_MPI_Init=no
4729	–	fi
4730	–	rm -f core conftest.err conftest.$ac_objext \
4731	–	conftest$ac_exeext conftest.$ac_ext
4732	–	LIBS=$ac_check_lib_save_LIBS
4733	–	fi
4734	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4735	–	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4736	–	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4737	–	MPILIBS="-lmpich"
4738	–	fi
4739	–
4740	–	fi
4741	–
4742	–	if test x != x"$MPILIBS"; then
4743	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4744	–	$as_echo_n "checking for mpi.h... " >&6; }
4745	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4746	–	/* end confdefs.h.  */
4747	–	#include <mpi.h>
4748	–	int
4749	–	main ()
4750	–	{
4751	–
4752	–	;
4753	–	return 0;
4754	–	}
4755	–	_ACEOF
4756	–	if ac_fn_c_try_compile "$LINENO"; then :
4757	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4758	–	$as_echo "yes" >&6; }
4759	–	else
4760	–	MPILIBS=""
4761	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4762	–	$as_echo "no" >&6; }
4763	–	fi
4764	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4765	–	fi
4766	–
4767	–	CC="$ax_mpi_save_CC"
4768	–
4769	–
4770	–
4771	–	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4772	–	if test x = x"$MPILIBS"; then
4773	–	USE_MPI="no"
4774	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4775	–	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4776	–	:
4777	–	else
4778	–	USE_MPI="yes"
4779	–	:
4780	–	fi
4781	–
4782	–
4783	–	fi
4784	–	ac_ext=${ac_fc_srcext-f}
4785	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4786	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4787	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4788	–	if test -n "$ac_tool_prefix"; then
4789	–	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
4790	–	do
4791	–	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4792	–	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4793	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4794	–	$as_echo_n "checking for $ac_word... " >&6; }
4795	–	if test "${ac_cv_prog_FC+set}" = set; then :
4796	–	$as_echo_n "(cached) " >&6
4797	–	else
4798	–	if test -n "$FC"; then
4799	–	ac_cv_prog_FC="$FC" # Let the user override the test.
4800	–	else
4801	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4802	–	for as_dir in $PATH
4803	–	do
4804	–	IFS=$as_save_IFS
4805	–	test -z "$as_dir" && as_dir=.
4806	–	for ac_exec_ext in '' $ac_executable_extensions; do
4807	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4808	–	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4809	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4810	–	break 2
4811	–	fi
4812	–	done
4813	–	done
4814	–	IFS=$as_save_IFS
4815	–
4816	–	fi
4817	–	fi
4818	–	FC=$ac_cv_prog_FC
4819	–	if test -n "$FC"; then
4820	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4821	–	$as_echo "$FC" >&6; }
4822	–	else
4823	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4824	–	$as_echo "no" >&6; }
4825	–	fi
4826	–
4827	–
4828	–	test -n "$FC" && break
4829	–	done
4830	–	fi
4831	–	if test -z "$FC"; then
4832	–	ac_ct_FC=$FC
4833	–	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
4834	–	do
4835	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
4836	–	set dummy $ac_prog; ac_word=$2
4837	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4838	–	$as_echo_n "checking for $ac_word... " >&6; }
4839	–	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4840	–	$as_echo_n "(cached) " >&6
4841	–	else
4842	–	if test -n "$ac_ct_FC"; then
4843	–	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4844	–	else
4845	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4846	–	for as_dir in $PATH
4847	–	do
4848	–	IFS=$as_save_IFS
4849	–	test -z "$as_dir" && as_dir=.
4850	–	for ac_exec_ext in '' $ac_executable_extensions; do
4851	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4852	–	ac_cv_prog_ac_ct_FC="$ac_prog"
4853	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4854	–	break 2
4855	–	fi
4856	–	done
4857	–	done
4858	–	IFS=$as_save_IFS
4859	–
4860	–	fi
4861	–	fi
4862	–	ac_ct_FC=$ac_cv_prog_ac_ct_FC
4863	–	if test -n "$ac_ct_FC"; then
4864	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4865	–	$as_echo "$ac_ct_FC" >&6; }
4866	–	else
4867	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4868	–	$as_echo "no" >&6; }
4869	–	fi
4870	–
4871	–
4872	–	test -n "$ac_ct_FC" && break
4873	–	done
4874	–
4875	–	if test "x$ac_ct_FC" = x; then
4876	–	FC=""
4877	–	else
4878	–	case $cross_compiling:$ac_tool_warned in
4879	–	yes:)
4880	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4881	–	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4882	–	ac_tool_warned=yes ;;
4883	–	esac
4884	–	FC=$ac_ct_FC
4885	–	fi
4886	–	fi
4887	–
4888	–
4889	–	# Provide some information about the compiler.
4890	–	$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4891	–	set X $ac_compile
4892	–	ac_compiler=$2
4893	–	for ac_option in --version -v -V -qversion; do
4894	–	{ { ac_try="$ac_compiler $ac_option >&5"
4895	–	case "(($ac_try" in
4896	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4897	–	*) ac_try_echo=$ac_try;;
4898	–	esac
4899	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4900	–	$as_echo "$ac_try_echo"; } >&5
4901	–	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4902	–	ac_status=$?
4903	–	if test -s conftest.err; then
4904	–	sed '10a\
4905	–	... rest of stderr output deleted ...
4906	–	10q' conftest.err >conftest.er1
4907	–	cat conftest.er1 >&5
4908	–	fi
4909	–	rm -f conftest.er1 conftest.err
4910	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4911	–	test $ac_status = 0; }
4912	–	done
4913	–	rm -f a.out
4914	–
4915	–	# If we don't use `.F' as extension, the preprocessor is not run on the
4916	–	# input file.  (Note that this only needs to work for GNU compilers.)
4917	–	ac_save_ext=$ac_ext
4918	–	ac_ext=F
4919	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4920	–	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4921	–	if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4922	–	$as_echo_n "(cached) " >&6
4923	–	else
4924	–	cat > conftest.$ac_ext <<_ACEOF
4925	–	program main
4926	–	#ifndef __GNUC__
4927	–	choke me
4928	–	#endif
4929	–
4930	–	end
4931	–	_ACEOF
4932	–	if ac_fn_fc_try_compile "$LINENO"; then :
4933	–	ac_compiler_gnu=yes
4934	–	else
4935	–	ac_compiler_gnu=no
4936	–	fi
4937	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4938	–	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4939	–
4940	–	fi
4941	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4942	–	$as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4943	–	ac_ext=$ac_save_ext
4944	–	ac_test_FCFLAGS=${FCFLAGS+set}
4945	–	ac_save_FCFLAGS=$FCFLAGS
4946	–	FCFLAGS=
4947	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4948	–	$as_echo_n "checking whether $FC accepts -g... " >&6; }
4949	–	if test "${ac_cv_prog_fc_g+set}" = set; then :
4950	–	$as_echo_n "(cached) " >&6
4951	–	else
4952	–	FCFLAGS=-g
4953	–	cat > conftest.$ac_ext <<_ACEOF
4954	–	program main
4955	–
4956	–	end
4957	–	_ACEOF
4958	–	if ac_fn_fc_try_compile "$LINENO"; then :
4959	–	ac_cv_prog_fc_g=yes
4960	–	else
4961	–	ac_cv_prog_fc_g=no
4962	–	fi
4963	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4964	–
4965	–	fi
4966	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
4967	–	$as_echo "$ac_cv_prog_fc_g" >&6; }
4968	–	if test "$ac_test_FCFLAGS" = set; then
4969	–	FCFLAGS=$ac_save_FCFLAGS
4970	–	elif test $ac_cv_prog_fc_g = yes; then
4971	–	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4972	–	FCFLAGS="-g -O2"
4973	–	else
4974	–	FCFLAGS="-g"
4975	–	fi
4976	–	else
4977	–	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4978	–	FCFLAGS="-O2"
4979	–	else
4980	–	FCFLAGS=
4981	–	fi
4982	–	fi
4983	–
4984	–	ac_ext=${ac_fc_srcext-f}
4985	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4986	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4987	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4988	–
4989	–
4990	–	if test $USE_MPI != no; then :
4991	–
4992	–	ac_ext=${ac_fc_srcext-f}
4993	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4994	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4995	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4996	–
4997	–
4998	–
4999	–
5000	–
5001	–
5002	–	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
5003	–	do
5004	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
5005	–	set dummy $ac_prog; ac_word=$2
5006	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5007	–	$as_echo_n "checking for $ac_word... " >&6; }
5008	–	if test "${ac_cv_prog_MPIFC+set}" = set; then :
5009	–	$as_echo_n "(cached) " >&6
5010	–	else
5011	–	if test -n "$MPIFC"; then
5012	–	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
5013	–	else
5014	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5015	–	for as_dir in $PATH
5016	–	do
5017	–	IFS=$as_save_IFS
5018	–	test -z "$as_dir" && as_dir=.
5019	–	for ac_exec_ext in '' $ac_executable_extensions; do
5020	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5021	–	ac_cv_prog_MPIFC="$ac_prog"
5022	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5023	–	break 2
5024	–	fi
5025	–	done
5026	–	done
5027	–	IFS=$as_save_IFS
5028	–
5029	–	fi
5030	–	fi
5031	–	MPIFC=$ac_cv_prog_MPIFC
5032	–	if test -n "$MPIFC"; then
5033	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5034	–	$as_echo "$MPIFC" >&6; }
5035	–	else
5036	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5037	–	$as_echo "no" >&6; }
5038	–	fi
5039	–
5040	–
5041	–	test -n "$MPIFC" && break
5042	–	done
5043	–	test -n "$MPIFC" || MPIFC="$FC"
5044	–
5045	–	ax_mpi_save_FC="$FC"
5046	–	FC="$MPIFC"
5047	–
5048	–
5049	–
5050	–	if test x = x"$MPILIBS"; then
5051	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5052	–	$as_echo_n "checking for MPI_Init... " >&6; }
5053	–	cat > conftest.$ac_ext <<_ACEOF
5054	–	program main
5055	–	call MPI_Init
5056	–	end
5057	–	_ACEOF
5058	–	if ac_fn_fc_try_link "$LINENO"; then :
5059	–	MPILIBS=" "
5060	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5061	–	$as_echo "yes" >&6; }
5062	–	else
5063	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5064	–	$as_echo "no" >&6; }
5065	–	fi
5066	–	rm -f core conftest.err conftest.$ac_objext \
5067	–	conftest$ac_exeext conftest.$ac_ext
5068	–	fi
5069	–
5070	–	if test x = x"$MPILIBS"; then
5071	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5072	–	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5073	–	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5074	–	$as_echo_n "(cached) " >&6
5075	–	else
5076	–	ac_check_lib_save_LIBS=$LIBS
5077	–	LIBS="-lfmpi  $LIBS"
5078	–	cat > conftest.$ac_ext <<_ACEOF
5079	–	program main
5080	–	call MPI_Init
5081	–	end
5082	–	_ACEOF
5083	–	if ac_fn_fc_try_link "$LINENO"; then :
5084	–	ac_cv_lib_fmpi_MPI_Init=yes
5085	–	else
5086	–	ac_cv_lib_fmpi_MPI_Init=no
5087	–	fi
5088	–	rm -f core conftest.err conftest.$ac_objext \
5089	–	conftest$ac_exeext conftest.$ac_ext
5090	–	LIBS=$ac_check_lib_save_LIBS
5091	–	fi
5092	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
5093	–	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5094	–	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5095	–	MPILIBS="-lfmpi"
5096	–	fi
5097	–
5098	–	fi
5099	–	if test x = x"$MPILIBS"; then
5100	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5101	–	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5102	–	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5103	–	$as_echo_n "(cached) " >&6
5104	–	else
5105	–	ac_check_lib_save_LIBS=$LIBS
5106	–	LIBS="-lmpichf90  $LIBS"
5107	–	cat > conftest.$ac_ext <<_ACEOF
5108	–	program main
5109	–	call MPI_Init
5110	–	end
5111	–	_ACEOF
5112	–	if ac_fn_fc_try_link "$LINENO"; then :
5113	–	ac_cv_lib_mpichf90_MPI_Init=yes
5114	–	else
5115	–	ac_cv_lib_mpichf90_MPI_Init=no
5116	–	fi
5117	–	rm -f core conftest.err conftest.$ac_objext \
5118	–	conftest$ac_exeext conftest.$ac_ext
5119	–	LIBS=$ac_check_lib_save_LIBS
5120	–	fi
5121	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5122	–	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5123	–	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5124	–	MPILIBS="-lmpichf90"
5125	–	fi
5126	–
5127	–	fi
5128	–
5129	–	if test x = x"$MPILIBS"; then
5130	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5131	–	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5132	–	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5133	–	$as_echo_n "(cached) " >&6
5134	–	else
5135	–	ac_check_lib_save_LIBS=$LIBS
5136	–	LIBS="-lmpi  $LIBS"
5137	–	cat > conftest.$ac_ext <<_ACEOF
5138	–	program main
5139	–	call MPI_Init
5140	–	end
5141	–	_ACEOF
5142	–	if ac_fn_fc_try_link "$LINENO"; then :
5143	–	ac_cv_lib_mpi_MPI_Init=yes
5144	–	else
5145	–	ac_cv_lib_mpi_MPI_Init=no
5146	–	fi
5147	–	rm -f core conftest.err conftest.$ac_objext \
5148	–	conftest$ac_exeext conftest.$ac_ext
5149	–	LIBS=$ac_check_lib_save_LIBS
5150	–	fi
5151	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
5152	–	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5153	–	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5154	–	MPILIBS="-lmpi"
5155	–	fi
5156	–
5157	–	fi
5158	–	if test x = x"$MPILIBS"; then
5159	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
5160	–	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
5161	–	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
5162	–	$as_echo_n "(cached) " >&6
5163	–	else
5164	–	ac_check_lib_save_LIBS=$LIBS
5165	–	LIBS="-lmpich  $LIBS"
5166	–	cat > conftest.$ac_ext <<_ACEOF
5167	–	program main
5168	–	call MPI_Init
5169	–	end
5170	–	_ACEOF
5171	–	if ac_fn_fc_try_link "$LINENO"; then :
5172	–	ac_cv_lib_mpich_MPI_Init=yes
5173	–	else
5174	–	ac_cv_lib_mpich_MPI_Init=no
5175	–	fi
5176	–	rm -f core conftest.err conftest.$ac_objext \
5177	–	conftest$ac_exeext conftest.$ac_ext
5178	–	LIBS=$ac_check_lib_save_LIBS
5179	–	fi
5180	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5181	–	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5182	–	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5183	–	MPILIBS="-lmpich"
5184	–	fi
5185	–
5186	–	fi
5187	–
5188	–	if test x != x"$MPILIBS"; then
5189	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
5190	–	$as_echo_n "checking for mpif.h... " >&6; }
5191	–	cat > conftest.$ac_ext <<_ACEOF
5192	–	program main
5193	–	include 'mpif.h'
5194	–	end
5195	–	_ACEOF
5196	–	if ac_fn_fc_try_compile "$LINENO"; then :
5197	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5198	–	$as_echo "yes" >&6; }
5199	–	else
5200	–	MPILIBS=""
5201	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5202	–	$as_echo "no" >&6; }
5203	–	fi
5204	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5205	–	fi
5206	–
5207	–	FC="$ax_mpi_save_FC"
5208	–
5209	–
5210	–
5211	–	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
5212	–	if test x = x"$MPILIBS"; then
5213	–	USE_MPI="no"
5214	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
5215	–	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
5216	–	:
5217	–	else
5218	–	USE_MPI="yes"
5219	–	:
5220	–	fi
5221	–
5222	–
5223	–	fi
5224	–	if test $USE_MPI != no; then :
5225	–
5226	–	CXX=$MPICXX
5227	–	CC=$MPICC
5228	–	FC=$MPIFC
5229	–
5230	–	fi
5231	–
5232	–
5233	–	# Checks for programs.
5234	–	ac_ext=cpp
5235	–	ac_cpp='$CXXCPP $CPPFLAGS'
5236	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5237	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5238	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5239	–	if test -z "$CXX"; then
5240	–	if test -n "$CCC"; then
5241	–	CXX=$CCC
5242	–	else
5243	–	if test -n "$ac_tool_prefix"; then
5244	–	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5245	–	do
5246	–	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5247	–	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5248	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5249	–	$as_echo_n "checking for $ac_word... " >&6; }
5250	–	if test "${ac_cv_prog_CXX+set}" = set; then :
5251	–	$as_echo_n "(cached) " >&6
5252	–	else
5253	–	if test -n "$CXX"; then
5254	–	ac_cv_prog_CXX="$CXX" # Let the user override the test.
5255	–	else
5256	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5257	–	for as_dir in $PATH
5258	–	do
5259	–	IFS=$as_save_IFS
5260	–	test -z "$as_dir" && as_dir=.
5261	–	for ac_exec_ext in '' $ac_executable_extensions; do
5262	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5263	–	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
5264	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5265	–	break 2
5266	–	fi
5267	–	done
5268	–	done
5269	–	IFS=$as_save_IFS
5270	–
5271	–	fi
5272	–	fi
5273	–	CXX=$ac_cv_prog_CXX
5274	–	if test -n "$CXX"; then
5275	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
5276	–	$as_echo "$CXX" >&6; }
5277	–	else
5278	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5279	–	$as_echo "no" >&6; }
5280	–	fi
5281	–
5282	–
5283	–	test -n "$CXX" && break
5284	–	done
5285	–	fi
5286	–	if test -z "$CXX"; then
5287	–	ac_ct_CXX=$CXX
5288	–	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5289	–	do
5290	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
5291	–	set dummy $ac_prog; ac_word=$2
5292	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5293	–	$as_echo_n "checking for $ac_word... " >&6; }
5294	–	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
5295	–	$as_echo_n "(cached) " >&6
5296	–	else
5297	–	if test -n "$ac_ct_CXX"; then
5298	–	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
5299	–	else
5300	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5301	–	for as_dir in $PATH
5302	–	do
5303	–	IFS=$as_save_IFS
5304	–	test -z "$as_dir" && as_dir=.
5305	–	for ac_exec_ext in '' $ac_executable_extensions; do
5306	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5307	–	ac_cv_prog_ac_ct_CXX="$ac_prog"
5308	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5309	–	break 2
5310	–	fi
5311	–	done
5312	–	done
5313	–	IFS=$as_save_IFS
5314	–
5315	–	fi
5316	–	fi
5317	–	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
5318	–	if test -n "$ac_ct_CXX"; then
5319	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
5320	–	$as_echo "$ac_ct_CXX" >&6; }
5321	–	else
5322	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5323	–	$as_echo "no" >&6; }
5324	–	fi
5325	–
5326	–
5327	–	test -n "$ac_ct_CXX" && break
5328	–	done
5329	–
5330	–	if test "x$ac_ct_CXX" = x; then
5331	–	CXX="g++"
5332	–	else
5333	–	case $cross_compiling:$ac_tool_warned in
5334	–	yes:)
5335	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5336	–	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5337	–	ac_tool_warned=yes ;;
5338	–	esac
5339	–	CXX=$ac_ct_CXX
5340	–	fi
5341	–	fi
5342	–
5343	–	fi
5344	–	fi
5345	–	# Provide some information about the compiler.
5346	–	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
5347	–	set X $ac_compile
5348	–	ac_compiler=$2
5349	–	for ac_option in --version -v -V -qversion; do
5350	–	{ { ac_try="$ac_compiler $ac_option >&5"
5351	–	case "(($ac_try" in
5352	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5353	–	*) ac_try_echo=$ac_try;;
5354	–	esac
5355	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5356	–	$as_echo "$ac_try_echo"; } >&5
5357	–	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
5358	–	ac_status=$?
5359	–	if test -s conftest.err; then
5360	–	sed '10a\
5361	–	... rest of stderr output deleted ...
5362	–	10q' conftest.err >conftest.er1
5363	–	cat conftest.er1 >&5
5364	–	fi
5365	–	rm -f conftest.er1 conftest.err
5366	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5367	–	test $ac_status = 0; }
5368	–	done
5369	–
5370	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
5371	–	$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
5372	–	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
5373	–	$as_echo_n "(cached) " >&6
5374	–	else
5375	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5376	–	/* end confdefs.h.  */
5377	–
5378	–	int
5379	–	main ()
5380	–	{
5381	–	#ifndef __GNUC__
5382	–	choke me
5383	–	#endif
5384	–
5385	–	;
5386	–	return 0;
5387	–	}
5388	–	_ACEOF
5389	–	if ac_fn_cxx_try_compile "$LINENO"; then :
5390	–	ac_compiler_gnu=yes
5391	–	else
5392	–	ac_compiler_gnu=no
5393	–	fi
5394	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5395	–	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
5396	–
5397	–	fi
5398	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
5399	–	$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
5400	–	if test $ac_compiler_gnu = yes; then
5401	–	GXX=yes
5402	–	else
5403	–	GXX=
5404	–	fi
5405	–	ac_test_CXXFLAGS=${CXXFLAGS+set}
5406	–	ac_save_CXXFLAGS=$CXXFLAGS
5407	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
5408	–	$as_echo_n "checking whether $CXX accepts -g... " >&6; }
5409	–	if test "${ac_cv_prog_cxx_g+set}" = set; then :
5410	–	$as_echo_n "(cached) " >&6
5411	–	else
5412	–	ac_save_cxx_werror_flag=$ac_cxx_werror_flag
5413	–	ac_cxx_werror_flag=yes
5414	–	ac_cv_prog_cxx_g=no
5415	–	CXXFLAGS="-g"
5416	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5417	–	/* end confdefs.h.  */
5418	–
5419	–	int
5420	–	main ()
5421	–	{
5422	–
5423	–	;
5424	–	return 0;
5425	–	}
5426	–	_ACEOF
5427	–	if ac_fn_cxx_try_compile "$LINENO"; then :
5428	–	ac_cv_prog_cxx_g=yes
5429	–	else
5430	–	CXXFLAGS=""
5431	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5432	–	/* end confdefs.h.  */
5433	–
5434	–	int
5435	–	main ()
5436	–	{
5437	–
5438	–	;
5439	–	return 0;
5440	–	}
5441	–	_ACEOF
5442	–	if ac_fn_cxx_try_compile "$LINENO"; then :
5443	–
5444	–	else
5445	–	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5446	–	CXXFLAGS="-g"
5447	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5448	–	/* end confdefs.h.  */
5449	–
5450	–	int
5451	–	main ()
5452	–	{
5453	–
5454	–	;
5455	–	return 0;
5456	–	}
5457	–	_ACEOF
5458	–	if ac_fn_cxx_try_compile "$LINENO"; then :
5459	–	ac_cv_prog_cxx_g=yes
5460	–	fi
5461	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5462	–	fi
5463	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5464	–	fi
5465	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5466	–	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5467	–	fi
5468	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
5469	–	$as_echo "$ac_cv_prog_cxx_g" >&6; }
5470	–	if test "$ac_test_CXXFLAGS" = set; then
5471	–	CXXFLAGS=$ac_save_CXXFLAGS
5472	–	elif test $ac_cv_prog_cxx_g = yes; then
5473	–	if test "$GXX" = yes; then
5474	–	CXXFLAGS="-g -O2"
5475	–	else
5476	–	CXXFLAGS="-g"
5477	–	fi
5478	–	else
5479	–	if test "$GXX" = yes; then
5480	–	CXXFLAGS="-O2"
5481	–	else
5482	–	CXXFLAGS=
5483	–	fi
5484	–	fi
5485	–	ac_ext=${ac_fc_srcext-f}
5486	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5487	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5488	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5489	–
5490	–	ac_ext=c
5491	–	ac_cpp='$CPP $CPPFLAGS'
5492	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5493	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5494	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5495	–	if test -n "$ac_tool_prefix"; then
5496	–	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5497	–	do
5498	–	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5499	–	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5500	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5501	–	$as_echo_n "checking for $ac_word... " >&6; }
5502	–	if test "${ac_cv_prog_CC+set}" = set; then :
5503	–	$as_echo_n "(cached) " >&6
5504	–	else
5505	–	if test -n "$CC"; then
5506	–	ac_cv_prog_CC="$CC" # Let the user override the test.
5507	–	else
5508	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5509	–	for as_dir in $PATH
5510	–	do
5511	–	IFS=$as_save_IFS
5512	–	test -z "$as_dir" && as_dir=.
5513	–	for ac_exec_ext in '' $ac_executable_extensions; do
5514	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5515	–	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
5516	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5517	–	break 2
5518	–	fi
5519	–	done
5520	–	done
5521	–	IFS=$as_save_IFS
5522	–
5523	–	fi
5524	–	fi
5525	–	CC=$ac_cv_prog_CC
5526	–	if test -n "$CC"; then
5527	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
5528	–	$as_echo "$CC" >&6; }
5529	–	else
5530	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5531	–	$as_echo "no" >&6; }
5532	–	fi
5533	–
5534	–
5535	–	test -n "$CC" && break
5536	–	done
5537	–	fi
5538	–	if test -z "$CC"; then
5539	–	ac_ct_CC=$CC
5540	–	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5541	–	do
5542	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
5543	–	set dummy $ac_prog; ac_word=$2
5544	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5545	–	$as_echo_n "checking for $ac_word... " >&6; }
5546	–	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
5547	–	$as_echo_n "(cached) " >&6
5548	–	else
5549	–	if test -n "$ac_ct_CC"; then
5550	–	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
5551	–	else
5552	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5553	–	for as_dir in $PATH
5554	–	do
5555	–	IFS=$as_save_IFS
5556	–	test -z "$as_dir" && as_dir=.
5557	–	for ac_exec_ext in '' $ac_executable_extensions; do
5558	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5559	–	ac_cv_prog_ac_ct_CC="$ac_prog"
5560	–	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5561	–	break 2
5562	–	fi
5563	–	done
5564	–	done
5565	–	IFS=$as_save_IFS
5566	–
5567	–	fi
5568	–	fi
5569	–	ac_ct_CC=$ac_cv_prog_ac_ct_CC
5570	–	if test -n "$ac_ct_CC"; then
5571	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
5572	–	$as_echo "$ac_ct_CC" >&6; }
5573	–	else
5574	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5575	–	$as_echo "no" >&6; }
5576	–	fi
5577	–
5578	–
5579	–	test -n "$ac_ct_CC" && break
5580	–	done
5581	–
5582	–	if test "x$ac_ct_CC" = x; then
5583	–	CC=""
5584	–	else
5585	–	case $cross_compiling:$ac_tool_warned in
5586	–	yes:)
5587	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5588	–	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5589	–	ac_tool_warned=yes ;;
5590	–	esac
5591	–	CC=$ac_ct_CC
5592	–	fi
5593	–	fi
5594	–
5595	–
5596	–	test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5597	–	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5598	–	as_fn_error "no acceptable C compiler found in \$PATH
5599	–	See \`config.log' for more details." "$LINENO" 5; }
5600	–
5601	–	# Provide some information about the compiler.
5602	–	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
5603	–	set X $ac_compile
5604	–	ac_compiler=$2
5605	–	for ac_option in --version -v -V -qversion; do
5606	–	{ { ac_try="$ac_compiler $ac_option >&5"
5607	–	case "(($ac_try" in
5608	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5609	–	*) ac_try_echo=$ac_try;;
5610	–	esac
5611	–	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5612	–	$as_echo "$ac_try_echo"; } >&5
5613	–	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
5614	–	ac_status=$?
5615	–	if test -s conftest.err; then
5616	–	sed '10a\
5617	–	... rest of stderr output deleted ...
5618	–	10q' conftest.err >conftest.er1
5619	–	cat conftest.er1 >&5
5620	–	fi
5621	–	rm -f conftest.er1 conftest.err
5622	–	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5623	–	test $ac_status = 0; }
5624	–	done
5625	–
5626	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
5627	–	$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
5628	–	if test "${ac_cv_c_compiler_gnu+set}" = set; then :
5629	–	$as_echo_n "(cached) " >&6
5630	–	else
5631	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5632	–	/* end confdefs.h.  */
5633	–
5634	–	int
5635	–	main ()
5636	–	{
5637	–	#ifndef __GNUC__
5638	–	choke me
5639	–	#endif
5640	–
5641	–	;
5642	–	return 0;
5643	–	}
5644	–	_ACEOF
5645	–	if ac_fn_c_try_compile "$LINENO"; then :
5646	–	ac_compiler_gnu=yes
5647	–	else
5648	–	ac_compiler_gnu=no
5649	–	fi
5650	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5651	–	ac_cv_c_compiler_gnu=$ac_compiler_gnu
5652	–
5653	–	fi
5654	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
5655	–	$as_echo "$ac_cv_c_compiler_gnu" >&6; }
5656	–	if test $ac_compiler_gnu = yes; then
5657	–	GCC=yes
5658	–	else
5659	–	GCC=
5660	–	fi
5661	–	ac_test_CFLAGS=${CFLAGS+set}
5662	–	ac_save_CFLAGS=$CFLAGS
5663	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
5664	–	$as_echo_n "checking whether $CC accepts -g... " >&6; }
5665	–	if test "${ac_cv_prog_cc_g+set}" = set; then :
5666	–	$as_echo_n "(cached) " >&6
5667	–	else
5668	–	ac_save_c_werror_flag=$ac_c_werror_flag
5669	–	ac_c_werror_flag=yes
5670	–	ac_cv_prog_cc_g=no
5671	–	CFLAGS="-g"
5672	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5673	–	/* end confdefs.h.  */
5674	–
5675	–	int
5676	–	main ()
5677	–	{
5678	–
5679	–	;
5680	–	return 0;
5681	–	}
5682	–	_ACEOF
5683	–	if ac_fn_c_try_compile "$LINENO"; then :
5684	–	ac_cv_prog_cc_g=yes
5685	–	else
5686	–	CFLAGS=""
5687	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5688	–	/* end confdefs.h.  */
5689	–
5690	–	int
5691	–	main ()
5692	–	{
5693	–
5694	–	;
5695	–	return 0;
5696	–	}
5697	–	_ACEOF
5698	–	if ac_fn_c_try_compile "$LINENO"; then :
5699	–
5700	–	else
5701	–	ac_c_werror_flag=$ac_save_c_werror_flag
5702	–	CFLAGS="-g"
5703	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5704	–	/* end confdefs.h.  */
5705	–
5706	–	int
5707	–	main ()
5708	–	{
5709	–
5710	–	;
5711	–	return 0;
5712	–	}
5713	–	_ACEOF
5714	–	if ac_fn_c_try_compile "$LINENO"; then :
5715	–	ac_cv_prog_cc_g=yes
5716	–	fi
5717	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5718	–	fi
5719	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5720	–	fi
5721	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5722	–	ac_c_werror_flag=$ac_save_c_werror_flag
5723	–	fi
5724	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
5725	–	$as_echo "$ac_cv_prog_cc_g" >&6; }
5726	–	if test "$ac_test_CFLAGS" = set; then
5727	–	CFLAGS=$ac_save_CFLAGS
5728	–	elif test $ac_cv_prog_cc_g = yes; then
5729	–	if test "$GCC" = yes; then
5730	–	CFLAGS="-g -O2"
5731	–	else
5732	–	CFLAGS="-g"
5733	–	fi
5734	–	else
5735	–	if test "$GCC" = yes; then
5736	–	CFLAGS="-O2"
5737	–	else
5738	–	CFLAGS=
5739	–	fi
5740	–	fi
5741	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
5742	–	$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
5743	–	if test "${ac_cv_prog_cc_c89+set}" = set; then :
5744	–	$as_echo_n "(cached) " >&6
5745	–	else
5746	–	ac_cv_prog_cc_c89=no
5747	–	ac_save_CC=$CC
5748	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5749	–	/* end confdefs.h.  */
5750	–	#include <stdarg.h>
5751	–	#include <stdio.h>
5752	–	#include <sys/types.h>
5753	–	#include <sys/stat.h>
5754	–	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
5755	–	struct buf { int x; };
5756	–	FILE * (*rcsopen) (struct buf *, struct stat *, int);
5757	–	static char *e (p, i)
5758	–	char **p;
5759	–	int i;
5760	–	{
5761	–	return p[i];
5762	–	}
5763	–	static char *f (char * (*g) (char **, int), char **p, ...)
5764	–	{
5765	–	char *s;
5766	–	va_list v;
5767	–	va_start (v,p);
5768	–	s = g (p, va_arg (v,int));
5769	–	va_end (v);
5770	–	return s;
5771	–	}
5772	–
5773	–	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
5774	–	function prototypes and stuff, but not '\xHH' hex character constants.
5775	–	These don't provoke an error unfortunately, instead are silently treated
5776	–	as 'x'.  The following induces an error, until -std is added to get
5777	–	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
5778	–	array size at least.  It's necessary to write '\x00'==0 to get something
5779	–	that's true only with -std.  */
5780	–	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
5781	–
5782	–	/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
5783	–	inside strings and character constants.  */
5784	–	#define FOO(x) 'x'
5785	–	int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
5786	–
5787	–	int test (int i, double x);
5788	–	struct s1 {int (*f) (int a);};
5789	–	struct s2 {int (*f) (double a);};
5790	–	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
5791	–	int argc;
5792	–	char **argv;
5793	–	int
5794	–	main ()
5795	–	{
5796	–	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
5797	–	;
5798	–	return 0;
5799	–	}
5800	–	_ACEOF
5801	–	for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
5802	–	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
5803	–	do
5804	–	CC="$ac_save_CC $ac_arg"
5805	–	if ac_fn_c_try_compile "$LINENO"; then :
5806	–	ac_cv_prog_cc_c89=$ac_arg
5807	–	fi
5808	–	rm -f core conftest.err conftest.$ac_objext
5809	–	test "x$ac_cv_prog_cc_c89" != "xno" && break
5810	–	done
5811	–	rm -f conftest.$ac_ext
5812	–	CC=$ac_save_CC
5813	–
5814	–	fi
5815	–	# AC_CACHE_VAL
5816	–	case "x$ac_cv_prog_cc_c89" in
5817	–	x)
5818	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
5819	–	$as_echo "none needed" >&6; } ;;
5820	–	xno)
5821	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
5822	–	$as_echo "unsupported" >&6; } ;;
5823	–	*)
5824	–	CC="$CC $ac_cv_prog_cc_c89"
5825	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
5826	–	$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
5827	–	esac
5828	–	if test "x$ac_cv_prog_cc_c89" != xno; then :
5829	–
5830	–	fi
5831	–
5832	–	ac_ext=${ac_fc_srcext-f}
5833	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5834	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5835	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3883
3884		ac_ext=${ac_fc_srcext-f}
3885		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
#	Line 6031 | Line 4078 | else
4078		FCFLAGS="-O2"
4079		else
4080		FCFLAGS=
4081	+	fi
4082	+	fi
4083	+
4084	+	ac_ext=c
4085	+	ac_cpp='$CPP $CPPFLAGS'
4086	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4087	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4088	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4089	+
4090	+
4091	+	save_CXX=$CXX
4092	+	save_CC=$CC
4093	+	save_FC=$FC
4094	+	save_LIBS=$LIBS
4095	+
4096	+	ac_ext=cpp
4097	+	ac_cpp='$CXXCPP $CPPFLAGS'
4098	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4099	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4100	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4101	+
4102	+
4103	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
4104	+	$as_echo_n "checking for dlopen in -lc... " >&6; }
4105	+	if test "${ac_cv_lib_c_dlopen+set}" = set; then :
4106	+	$as_echo_n "(cached) " >&6
4107	+	else
4108	+	ac_check_lib_save_LIBS=$LIBS
4109	+	LIBS="-lc  $LIBS"
4110	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4111	+	/* end confdefs.h.  */
4112	+
4113	+	/* Override any GCC internal prototype to avoid an error.
4114	+	Use char because int might match the return type of a GCC
4115	+	builtin and then its argument prototype would still apply.  */
4116	+	#ifdef __cplusplus
4117	+	extern "C"
4118	+	#endif
4119	+	char dlopen ();
4120	+	int
4121	+	main ()
4122	+	{
4123	+	return dlopen ();
4124	+	;
4125	+	return 0;
4126	+	}
4127	+	_ACEOF
4128	+	if ac_fn_cxx_try_link "$LINENO"; then :
4129	+	ac_cv_lib_c_dlopen=yes
4130	+	else
4131	+	ac_cv_lib_c_dlopen=no
4132	+	fi
4133	+	rm -f core conftest.err conftest.$ac_objext \
4134	+	conftest$ac_exeext conftest.$ac_ext
4135	+	LIBS=$ac_check_lib_save_LIBS
4136	+	fi
4137	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
4138	+	$as_echo "$ac_cv_lib_c_dlopen" >&6; }
4139	+	if test "x$ac_cv_lib_c_dlopen" = x""yes; then :
4140	+	LIBDL=""
4141	+	else
4142	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
4143	+	$as_echo_n "checking for dlopen in -ldl... " >&6; }
4144	+	if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
4145	+	$as_echo_n "(cached) " >&6
4146	+	else
4147	+	ac_check_lib_save_LIBS=$LIBS
4148	+	LIBS="-ldl  $LIBS"
4149	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4150	+	/* end confdefs.h.  */
4151	+
4152	+	/* Override any GCC internal prototype to avoid an error.
4153	+	Use char because int might match the return type of a GCC
4154	+	builtin and then its argument prototype would still apply.  */
4155	+	#ifdef __cplusplus
4156	+	extern "C"
4157	+	#endif
4158	+	char dlopen ();
4159	+	int
4160	+	main ()
4161	+	{
4162	+	return dlopen ();
4163	+	;
4164	+	return 0;
4165	+	}
4166	+	_ACEOF
4167	+	if ac_fn_cxx_try_link "$LINENO"; then :
4168	+	ac_cv_lib_dl_dlopen=yes
4169	+	else
4170	+	ac_cv_lib_dl_dlopen=no
4171	+	fi
4172	+	rm -f core conftest.err conftest.$ac_objext \
4173	+	conftest$ac_exeext conftest.$ac_ext
4174	+	LIBS=$ac_check_lib_save_LIBS
4175	+	fi
4176	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
4177	+	$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
4178	+	if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
4179	+	LIBDL="-ldl"
4180	+	fi
4181	+
4182	+	fi
4183	+
4184	+
4185	+
4186	+
4187	+
4188	+
4189	+
4190	+	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
4191	+	do
4192	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4193	+	set dummy $ac_prog; ac_word=$2
4194	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4195	+	$as_echo_n "checking for $ac_word... " >&6; }
4196	+	if test "${ac_cv_prog_MPICXX+set}" = set; then :
4197	+	$as_echo_n "(cached) " >&6
4198	+	else
4199	+	if test -n "$MPICXX"; then
4200	+	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
4201	+	else
4202	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4203	+	for as_dir in $PATH
4204	+	do
4205	+	IFS=$as_save_IFS
4206	+	test -z "$as_dir" && as_dir=.
4207	+	for ac_exec_ext in '' $ac_executable_extensions; do
4208	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4209	+	ac_cv_prog_MPICXX="$ac_prog"
4210	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4211	+	break 2
4212	+	fi
4213	+	done
4214	+	done
4215	+	IFS=$as_save_IFS
4216	+
4217	+	fi
4218	+	fi
4219	+	MPICXX=$ac_cv_prog_MPICXX
4220	+	if test -n "$MPICXX"; then
4221	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
4222	+	$as_echo "$MPICXX" >&6; }
4223	+	else
4224	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4225	+	$as_echo "no" >&6; }
4226	+	fi
4227	+
4228	+
4229	+	test -n "$MPICXX" && break
4230	+	done
4231	+	test -n "$MPICXX" || MPICXX="$CXX"
4232	+
4233	+	ax_mpi_save_CXX="$CXX"
4234	+	CXX="$MPICXX"
4235	+
4236	+
4237	+
4238	+	if test x = x"$MPILIBS"; then
4239	+	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4240	+	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4241	+	MPILIBS=" "
4242	+	fi
4243	+
4244	+	fi
4245	+
4246	+	if test x = x"$MPILIBS"; then
4247	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4248	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4249	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4250	+	$as_echo_n "(cached) " >&6
4251	+	else
4252	+	ac_check_lib_save_LIBS=$LIBS
4253	+	LIBS="-lmpi  $LIBS"
4254	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4255	+	/* end confdefs.h.  */
4256	+
4257	+	/* Override any GCC internal prototype to avoid an error.
4258	+	Use char because int might match the return type of a GCC
4259	+	builtin and then its argument prototype would still apply.  */
4260	+	#ifdef __cplusplus
4261	+	extern "C"
4262	+	#endif
4263	+	char MPI_Init ();
4264	+	int
4265	+	main ()
4266	+	{
4267	+	return MPI_Init ();
4268	+	;
4269	+	return 0;
4270	+	}
4271	+	_ACEOF
4272	+	if ac_fn_cxx_try_link "$LINENO"; then :
4273	+	ac_cv_lib_mpi_MPI_Init=yes
4274	+	else
4275	+	ac_cv_lib_mpi_MPI_Init=no
4276	+	fi
4277	+	rm -f core conftest.err conftest.$ac_objext \
4278	+	conftest$ac_exeext conftest.$ac_ext
4279	+	LIBS=$ac_check_lib_save_LIBS
4280	+	fi
4281	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4282	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4283	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4284	+	MPILIBS="-lmpi"
4285	+	fi
4286	+
4287	+	fi
4288	+	if test x = x"$MPILIBS"; then
4289	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4290	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4291	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4292	+	$as_echo_n "(cached) " >&6
4293	+	else
4294	+	ac_check_lib_save_LIBS=$LIBS
4295	+	LIBS="-lmpich  $LIBS"
4296	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4297	+	/* end confdefs.h.  */
4298	+
4299	+	/* Override any GCC internal prototype to avoid an error.
4300	+	Use char because int might match the return type of a GCC
4301	+	builtin and then its argument prototype would still apply.  */
4302	+	#ifdef __cplusplus
4303	+	extern "C"
4304	+	#endif
4305	+	char MPI_Init ();
4306	+	int
4307	+	main ()
4308	+	{
4309	+	return MPI_Init ();
4310	+	;
4311	+	return 0;
4312	+	}
4313	+	_ACEOF
4314	+	if ac_fn_cxx_try_link "$LINENO"; then :
4315	+	ac_cv_lib_mpich_MPI_Init=yes
4316	+	else
4317	+	ac_cv_lib_mpich_MPI_Init=no
4318	+	fi
4319	+	rm -f core conftest.err conftest.$ac_objext \
4320	+	conftest$ac_exeext conftest.$ac_ext
4321	+	LIBS=$ac_check_lib_save_LIBS
4322	+	fi
4323	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4324	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4325	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4326	+	MPILIBS="-lmpich"
4327	+	fi
4328	+
4329	+	fi
4330	+
4331	+	if test x != x"$MPILIBS"; then
4332	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4333	+	$as_echo_n "checking for mpi.h... " >&6; }
4334	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4335	+	/* end confdefs.h.  */
4336	+	#include <mpi.h>
4337	+	int
4338	+	main ()
4339	+	{
4340	+
4341	+	;
4342	+	return 0;
4343	+	}
4344	+	_ACEOF
4345	+	if ac_fn_cxx_try_compile "$LINENO"; then :
4346	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4347	+	$as_echo "yes" >&6; }
4348	+	else
4349	+	MPILIBS=""
4350	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4351	+	$as_echo "no" >&6; }
4352	+	fi
4353	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4354	+	fi
4355	+
4356	+	CXX="$ax_mpi_save_CXX"
4357	+
4358	+
4359	+
4360	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4361	+	if test x = x"$MPILIBS"; then
4362	+	USE_MPI="no"
4363	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4364	+	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4365	+	:
4366	+	else
4367	+	USE_MPI="yes"
4368	+	:
4369	+	fi
4370	+
4371	+
4372	+	if test $USE_MPI != no; then :
4373	+
4374	+	ac_ext=c
4375	+	ac_cpp='$CPP $CPPFLAGS'
4376	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4377	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4378	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4379	+
4380	+
4381	+
4382	+
4383	+
4384	+
4385	+	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4386	+	do
4387	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4388	+	set dummy $ac_prog; ac_word=$2
4389	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4390	+	$as_echo_n "checking for $ac_word... " >&6; }
4391	+	if test "${ac_cv_prog_MPICC+set}" = set; then :
4392	+	$as_echo_n "(cached) " >&6
4393	+	else
4394	+	if test -n "$MPICC"; then
4395	+	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4396	+	else
4397	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4398	+	for as_dir in $PATH
4399	+	do
4400	+	IFS=$as_save_IFS
4401	+	test -z "$as_dir" && as_dir=.
4402	+	for ac_exec_ext in '' $ac_executable_extensions; do
4403	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4404	+	ac_cv_prog_MPICC="$ac_prog"
4405	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4406	+	break 2
4407		fi
4408	+	done
4409	+	done
4410	+	IFS=$as_save_IFS
4411	+
4412		fi
4413	+	fi
4414	+	MPICC=$ac_cv_prog_MPICC
4415	+	if test -n "$MPICC"; then
4416	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4417	+	$as_echo "$MPICC" >&6; }
4418	+	else
4419	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4420	+	$as_echo "no" >&6; }
4421	+	fi
4422
4423	+
4424	+	test -n "$MPICC" && break
4425	+	done
4426	+	test -n "$MPICC" || MPICC="$CC"
4427	+
4428	+	ax_mpi_save_CC="$CC"
4429	+	CC="$MPICC"
4430	+
4431	+
4432	+
4433	+	if test x = x"$MPILIBS"; then
4434	+	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4435	+	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4436	+	MPILIBS=" "
4437	+	fi
4438	+
4439	+	fi
4440	+
4441	+	if test x = x"$MPILIBS"; then
4442	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4443	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4444	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4445	+	$as_echo_n "(cached) " >&6
4446	+	else
4447	+	ac_check_lib_save_LIBS=$LIBS
4448	+	LIBS="-lmpi  $LIBS"
4449	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4450	+	/* end confdefs.h.  */
4451	+
4452	+	/* Override any GCC internal prototype to avoid an error.
4453	+	Use char because int might match the return type of a GCC
4454	+	builtin and then its argument prototype would still apply.  */
4455	+	#ifdef __cplusplus
4456	+	extern "C"
4457	+	#endif
4458	+	char MPI_Init ();
4459	+	int
4460	+	main ()
4461	+	{
4462	+	return MPI_Init ();
4463	+	;
4464	+	return 0;
4465	+	}
4466	+	_ACEOF
4467	+	if ac_fn_c_try_link "$LINENO"; then :
4468	+	ac_cv_lib_mpi_MPI_Init=yes
4469	+	else
4470	+	ac_cv_lib_mpi_MPI_Init=no
4471	+	fi
4472	+	rm -f core conftest.err conftest.$ac_objext \
4473	+	conftest$ac_exeext conftest.$ac_ext
4474	+	LIBS=$ac_check_lib_save_LIBS
4475	+	fi
4476	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4477	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4478	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4479	+	MPILIBS="-lmpi"
4480	+	fi
4481	+
4482	+	fi
4483	+	if test x = x"$MPILIBS"; then
4484	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4485	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4486	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4487	+	$as_echo_n "(cached) " >&6
4488	+	else
4489	+	ac_check_lib_save_LIBS=$LIBS
4490	+	LIBS="-lmpich  $LIBS"
4491	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4492	+	/* end confdefs.h.  */
4493	+
4494	+	/* Override any GCC internal prototype to avoid an error.
4495	+	Use char because int might match the return type of a GCC
4496	+	builtin and then its argument prototype would still apply.  */
4497	+	#ifdef __cplusplus
4498	+	extern "C"
4499	+	#endif
4500	+	char MPI_Init ();
4501	+	int
4502	+	main ()
4503	+	{
4504	+	return MPI_Init ();
4505	+	;
4506	+	return 0;
4507	+	}
4508	+	_ACEOF
4509	+	if ac_fn_c_try_link "$LINENO"; then :
4510	+	ac_cv_lib_mpich_MPI_Init=yes
4511	+	else
4512	+	ac_cv_lib_mpich_MPI_Init=no
4513	+	fi
4514	+	rm -f core conftest.err conftest.$ac_objext \
4515	+	conftest$ac_exeext conftest.$ac_ext
4516	+	LIBS=$ac_check_lib_save_LIBS
4517	+	fi
4518	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4519	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4520	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4521	+	MPILIBS="-lmpich"
4522	+	fi
4523	+
4524	+	fi
4525	+
4526	+	if test x != x"$MPILIBS"; then
4527	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4528	+	$as_echo_n "checking for mpi.h... " >&6; }
4529	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4530	+	/* end confdefs.h.  */
4531	+	#include <mpi.h>
4532	+	int
4533	+	main ()
4534	+	{
4535	+
4536	+	;
4537	+	return 0;
4538	+	}
4539	+	_ACEOF
4540	+	if ac_fn_c_try_compile "$LINENO"; then :
4541	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4542	+	$as_echo "yes" >&6; }
4543	+	else
4544	+	MPILIBS=""
4545	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4546	+	$as_echo "no" >&6; }
4547	+	fi
4548	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4549	+	fi
4550	+
4551	+	CC="$ax_mpi_save_CC"
4552	+
4553	+
4554	+
4555	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4556	+	if test x = x"$MPILIBS"; then
4557	+	USE_MPI="no"
4558	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4559	+	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4560	+	:
4561	+	else
4562	+	USE_MPI="yes"
4563	+	:
4564	+	fi
4565	+
4566	+
4567	+	fi
4568	+
4569	+	if test $USE_MPI != no; then :
4570	+
4571		ac_ext=${ac_fc_srcext-f}
4572		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4573		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4574		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4575
4576	+
4577	+
4578	+
4579	+
4580	+
4581	+	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
4582	+	do
4583	+	# Extract the first word of "$ac_prog", so it can be a program name with args.
4584	+	set dummy $ac_prog; ac_word=$2
4585	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4586	+	$as_echo_n "checking for $ac_word... " >&6; }
4587	+	if test "${ac_cv_prog_MPIFC+set}" = set; then :
4588	+	$as_echo_n "(cached) " >&6
4589	+	else
4590	+	if test -n "$MPIFC"; then
4591	+	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
4592	+	else
4593	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4594	+	for as_dir in $PATH
4595	+	do
4596	+	IFS=$as_save_IFS
4597	+	test -z "$as_dir" && as_dir=.
4598	+	for ac_exec_ext in '' $ac_executable_extensions; do
4599	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4600	+	ac_cv_prog_MPIFC="$ac_prog"
4601	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4602	+	break 2
4603	+	fi
4604	+	done
4605	+	done
4606	+	IFS=$as_save_IFS
4607	+
4608	+	fi
4609	+	fi
4610	+	MPIFC=$ac_cv_prog_MPIFC
4611	+	if test -n "$MPIFC"; then
4612	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
4613	+	$as_echo "$MPIFC" >&6; }
4614	+	else
4615	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4616	+	$as_echo "no" >&6; }
4617	+	fi
4618	+
4619	+
4620	+	test -n "$MPIFC" && break
4621	+	done
4622	+	test -n "$MPIFC" || MPIFC="$FC"
4623	+
4624	+	ax_mpi_save_FC="$FC"
4625	+	FC="$MPIFC"
4626	+
4627	+
4628	+
4629	+	if test x = x"$MPILIBS"; then
4630	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
4631	+	$as_echo_n "checking for MPI_Init... " >&6; }
4632	+	cat > conftest.$ac_ext <<_ACEOF
4633	+	program main
4634	+	call MPI_Init
4635	+	end
4636	+	_ACEOF
4637	+	if ac_fn_fc_try_link "$LINENO"; then :
4638	+	MPILIBS=" "
4639	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4640	+	$as_echo "yes" >&6; }
4641	+	else
4642	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4643	+	$as_echo "no" >&6; }
4644	+	fi
4645	+	rm -f core conftest.err conftest.$ac_objext \
4646	+	conftest$ac_exeext conftest.$ac_ext
4647	+	fi
4648	+
4649	+	if test x = x"$MPILIBS"; then
4650	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
4651	+	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
4652	+	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
4653	+	$as_echo_n "(cached) " >&6
4654	+	else
4655	+	ac_check_lib_save_LIBS=$LIBS
4656	+	LIBS="-lfmpi  $LIBS"
4657	+	cat > conftest.$ac_ext <<_ACEOF
4658	+	program main
4659	+	call MPI_Init
4660	+	end
4661	+	_ACEOF
4662	+	if ac_fn_fc_try_link "$LINENO"; then :
4663	+	ac_cv_lib_fmpi_MPI_Init=yes
4664	+	else
4665	+	ac_cv_lib_fmpi_MPI_Init=no
4666	+	fi
4667	+	rm -f core conftest.err conftest.$ac_objext \
4668	+	conftest$ac_exeext conftest.$ac_ext
4669	+	LIBS=$ac_check_lib_save_LIBS
4670	+	fi
4671	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
4672	+	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
4673	+	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
4674	+	MPILIBS="-lfmpi"
4675	+	fi
4676	+
4677	+	fi
4678	+	if test x = x"$MPILIBS"; then
4679	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
4680	+	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
4681	+	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
4682	+	$as_echo_n "(cached) " >&6
4683	+	else
4684	+	ac_check_lib_save_LIBS=$LIBS
4685	+	LIBS="-lmpichf90  $LIBS"
4686	+	cat > conftest.$ac_ext <<_ACEOF
4687	+	program main
4688	+	call MPI_Init
4689	+	end
4690	+	_ACEOF
4691	+	if ac_fn_fc_try_link "$LINENO"; then :
4692	+	ac_cv_lib_mpichf90_MPI_Init=yes
4693	+	else
4694	+	ac_cv_lib_mpichf90_MPI_Init=no
4695	+	fi
4696	+	rm -f core conftest.err conftest.$ac_objext \
4697	+	conftest$ac_exeext conftest.$ac_ext
4698	+	LIBS=$ac_check_lib_save_LIBS
4699	+	fi
4700	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
4701	+	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
4702	+	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
4703	+	MPILIBS="-lmpichf90"
4704	+	fi
4705	+
4706	+	fi
4707	+
4708	+	if test x = x"$MPILIBS"; then
4709	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4710	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4711	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4712	+	$as_echo_n "(cached) " >&6
4713	+	else
4714	+	ac_check_lib_save_LIBS=$LIBS
4715	+	LIBS="-lmpi  $LIBS"
4716	+	cat > conftest.$ac_ext <<_ACEOF
4717	+	program main
4718	+	call MPI_Init
4719	+	end
4720	+	_ACEOF
4721	+	if ac_fn_fc_try_link "$LINENO"; then :
4722	+	ac_cv_lib_mpi_MPI_Init=yes
4723	+	else
4724	+	ac_cv_lib_mpi_MPI_Init=no
4725	+	fi
4726	+	rm -f core conftest.err conftest.$ac_objext \
4727	+	conftest$ac_exeext conftest.$ac_ext
4728	+	LIBS=$ac_check_lib_save_LIBS
4729	+	fi
4730	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4731	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4732	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4733	+	MPILIBS="-lmpi"
4734	+	fi
4735	+
4736	+	fi
4737	+	if test x = x"$MPILIBS"; then
4738	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4739	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4740	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4741	+	$as_echo_n "(cached) " >&6
4742	+	else
4743	+	ac_check_lib_save_LIBS=$LIBS
4744	+	LIBS="-lmpich  $LIBS"
4745	+	cat > conftest.$ac_ext <<_ACEOF
4746	+	program main
4747	+	call MPI_Init
4748	+	end
4749	+	_ACEOF
4750	+	if ac_fn_fc_try_link "$LINENO"; then :
4751	+	ac_cv_lib_mpich_MPI_Init=yes
4752	+	else
4753	+	ac_cv_lib_mpich_MPI_Init=no
4754	+	fi
4755	+	rm -f core conftest.err conftest.$ac_objext \
4756	+	conftest$ac_exeext conftest.$ac_ext
4757	+	LIBS=$ac_check_lib_save_LIBS
4758	+	fi
4759	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4760	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4761	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4762	+	MPILIBS="-lmpich"
4763	+	fi
4764	+
4765	+	fi
4766	+
4767	+	if test x != x"$MPILIBS"; then
4768	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
4769	+	$as_echo_n "checking for mpif.h... " >&6; }
4770	+	cat > conftest.$ac_ext <<_ACEOF
4771	+	program main
4772	+	include 'mpif.h'
4773	+	end
4774	+	_ACEOF
4775	+	if ac_fn_fc_try_compile "$LINENO"; then :
4776	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4777	+	$as_echo "yes" >&6; }
4778	+	else
4779	+	MPILIBS=""
4780	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4781	+	$as_echo "no" >&6; }
4782	+	fi
4783	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4784	+	fi
4785	+
4786	+	FC="$ax_mpi_save_FC"
4787	+
4788	+
4789	+
4790	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4791	+	if test x = x"$MPILIBS"; then
4792	+	USE_MPI="no"
4793	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
4794	+	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
4795	+	:
4796	+	else
4797	+	USE_MPI="yes"
4798	+	:
4799	+	fi
4800	+
4801	+
4802	+	fi
4803	+	if test $USE_MPI != no; then :
4804	+
4805	+	CXX=$MPICXX
4806	+	CC=$MPICC
4807	+	FC=$MPIFC
4808	+	LIBS="$MPILIBS $LIBS"
4809	+
4810	+	else
4811	+
4812	+	CXX=$save_CXX
4813	+	CC=$save_CC
4814	+	FC=$save_FC
4815	+	LIBS=$save_LIBS
4816	+
4817	+
4818	+	fi
4819	+
4820	+
4821	+	# Checks for programs.
4822		ac_ext=c
4823		ac_cpp='$CPP $CPPFLAGS'
4824		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 6656 | Line 5436 | esac
5436		x/*) ;;
5437		*) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
5438		esac
5439	<	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
5439	>	MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
5440		# Extract the first word of "ar", so it can be a program name with args.
5441		set dummy ar; ac_word=$2
5442		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
#	Line 8981 | Line 7761 | $as_echo "failed" >&6; }
7761
7762		fi
7763		fi
7764	+	fi
7765	+
7766	+	ac_ext=cpp
7767	+	ac_cpp='$CXXCPP $CPPFLAGS'
7768	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7769	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7770	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7771	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
7772	+	$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
7773	+	if test -z "$CXXCPP"; then
7774	+	if test "${ac_cv_prog_CXXCPP+set}" = set; then :
7775	+	$as_echo_n "(cached) " >&6
7776	+	else
7777	+	# Double quotes because CXXCPP needs to be expanded
7778	+	for CXXCPP in "$CXX -E" "/lib/cpp"
7779	+	do
7780	+	ac_preproc_ok=false
7781	+	for ac_cxx_preproc_warn_flag in '' yes
7782	+	do
7783	+	# Use a header file that comes with gcc, so configuring glibc
7784	+	# with a fresh cross-compiler works.
7785	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7786	+	# <limits.h> exists even on freestanding compilers.
7787	+	# On the NeXT, cc -E runs the code through the compiler's parser,
7788	+	# not just through cpp. "Syntax error" is here to catch this case.
7789	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7790	+	/* end confdefs.h.  */
7791	+	#ifdef __STDC__
7792	+	# include <limits.h>
7793	+	#else
7794	+	# include <assert.h>
7795	+	#endif
7796	+	Syntax error
7797	+	_ACEOF
7798	+	if ac_fn_cxx_try_cpp "$LINENO"; then :
7799	+
7800	+	else
7801	+	# Broken: fails on valid input.
7802	+	continue
7803		fi
7804	+	rm -f conftest.err conftest.$ac_ext
7805
7806	+	# OK, works on sane cases.  Now check whether nonexistent headers
7807	+	# can be detected and how.
7808	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7809	+	/* end confdefs.h.  */
7810	+	#include <ac_nonexistent.h>
7811	+	_ACEOF
7812	+	if ac_fn_cxx_try_cpp "$LINENO"; then :
7813	+	# Broken: success on invalid input.
7814	+	continue
7815	+	else
7816	+	# Passes both tests.
7817	+	ac_preproc_ok=:
7818	+	break
7819	+	fi
7820	+	rm -f conftest.err conftest.$ac_ext
7821	+
7822	+	done
7823	+	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
7824	+	rm -f conftest.err conftest.$ac_ext
7825	+	if $ac_preproc_ok; then :
7826	+	break
7827	+	fi
7828	+
7829	+	done
7830	+	ac_cv_prog_CXXCPP=$CXXCPP
7831	+
7832	+	fi
7833	+	CXXCPP=$ac_cv_prog_CXXCPP
7834	+	else
7835	+	ac_cv_prog_CXXCPP=$CXXCPP
7836	+	fi
7837	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
7838	+	$as_echo "$CXXCPP" >&6; }
7839	+	ac_preproc_ok=false
7840	+	for ac_cxx_preproc_warn_flag in '' yes
7841	+	do
7842	+	# Use a header file that comes with gcc, so configuring glibc
7843	+	# with a fresh cross-compiler works.
7844	+	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7845	+	# <limits.h> exists even on freestanding compilers.
7846	+	# On the NeXT, cc -E runs the code through the compiler's parser,
7847	+	# not just through cpp. "Syntax error" is here to catch this case.
7848	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7849	+	/* end confdefs.h.  */
7850	+	#ifdef __STDC__
7851	+	# include <limits.h>
7852	+	#else
7853	+	# include <assert.h>
7854	+	#endif
7855	+	Syntax error
7856	+	_ACEOF
7857	+	if ac_fn_cxx_try_cpp "$LINENO"; then :
7858	+
7859	+	else
7860	+	# Broken: fails on valid input.
7861	+	continue
7862	+	fi
7863	+	rm -f conftest.err conftest.$ac_ext
7864	+
7865	+	# OK, works on sane cases.  Now check whether nonexistent headers
7866	+	# can be detected and how.
7867	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7868	+	/* end confdefs.h.  */
7869	+	#include <ac_nonexistent.h>
7870	+	_ACEOF
7871	+	if ac_fn_cxx_try_cpp "$LINENO"; then :
7872	+	# Broken: success on invalid input.
7873	+	continue
7874	+	else
7875	+	# Passes both tests.
7876	+	ac_preproc_ok=:
7877	+	break
7878	+	fi
7879	+	rm -f conftest.err conftest.$ac_ext
7880	+
7881	+	done
7882	+	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
7883	+	rm -f conftest.err conftest.$ac_ext
7884	+	if $ac_preproc_ok; then :
7885	+
7886	+	else
7887	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7888	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7889	+	as_fn_error "C++ preprocessor \"$CXXCPP\" fails sanity check
7890	+	See \`config.log' for more details." "$LINENO" 5; }
7891	+	fi
7892	+
7893	+	ac_ext=cpp
7894	+	ac_cpp='$CXXCPP $CPPFLAGS'
7895	+	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7896	+	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7897	+	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7898	+
7899	+
7900		#
7901		# Handle user hints
7902		#
#	Line 9019 | Line 7933 | $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}"
7933		{ $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
7934		$as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
7935
7936	<	ac_ext=c
7937	<	ac_cpp='$CPP $CPPFLAGS'
7938	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7939	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7940	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
7936	>	ac_ext=cpp
7937	>	ac_cpp='$CXXCPP $CPPFLAGS'
7938	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7939	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7940	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7941
7942		QHULL_OLD_LDFLAGS=$LDFLAGS
7943	<	QHULL_OLD_CFLAGS=$CFLAGS
7943	>	QHULL_OLD_CXXFLAGS=$CXXFLAGS
7944		QHULL_OLD_CPPFLAGS=$CPPFLAGS
7945		LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
7946	<	CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
7946	>	CXXFLAGS="$CXXFLAGS -I${QHULL_HOME}/include"
7947		CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
7948	<	ac_fn_c_check_header_mongrel "$LINENO" "qhull/qhull.h" "ac_cv_header_qhull_qhull_h" "$ac_includes_default"
7948	>	ac_fn_cxx_check_header_mongrel "$LINENO" "qhull/qhull.h" "ac_cv_header_qhull_qhull_h" "$ac_includes_default"
7949		if test "x$ac_cv_header_qhull_qhull_h" = x""yes; then :
7950		qhull_cv_qhull_h=yes
7951		else
#	Line 9072 | Line 7986 | _ACEOF
7986		return 0;
7987		}
7988		_ACEOF
7989	<	if ac_fn_c_try_link "$LINENO"; then :
7989	>	if ac_fn_cxx_try_link "$LINENO"; then :
7990		ac_cv_lib_qhull_qh_qhull=yes
7991		else
7992		ac_cv_lib_qhull_qh_qhull=no
#	Line 9090 | Line 8004 | fi
8004		fi
8005
8006		LDFLAGS="$QHULL_OLD_LDFLAGS"
8007	<	CFLAGS="$QHULL_OLD_CFLAGS"
8007	>	CXXFLAGS="$QHULL_OLD_CXXFLAGS"
8008		CPPFLAGS="$QHULL_OLD_CPPFLAGS"
8009		ac_ext=c
8010		ac_cpp='$CPP $CPPFLAGS'
#	Line 9137 | Line 8051 | fi
8051
8052
8053
9140	–	ac_ext=cpp
9141	–	ac_cpp='$CXXCPP $CPPFLAGS'
9142	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9143	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9144	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9145	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
9146	–	$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
9147	–	if test -z "$CXXCPP"; then
9148	–	if test "${ac_cv_prog_CXXCPP+set}" = set; then :
9149	–	$as_echo_n "(cached) " >&6
9150	–	else
9151	–	# Double quotes because CXXCPP needs to be expanded
9152	–	for CXXCPP in "$CXX -E" "/lib/cpp"
9153	–	do
9154	–	ac_preproc_ok=false
9155	–	for ac_cxx_preproc_warn_flag in '' yes
9156	–	do
9157	–	# Use a header file that comes with gcc, so configuring glibc
9158	–	# with a fresh cross-compiler works.
9159	–	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9160	–	# <limits.h> exists even on freestanding compilers.
9161	–	# On the NeXT, cc -E runs the code through the compiler's parser,
9162	–	# not just through cpp. "Syntax error" is here to catch this case.
9163	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9164	–	/* end confdefs.h.  */
9165	–	#ifdef __STDC__
9166	–	# include <limits.h>
9167	–	#else
9168	–	# include <assert.h>
9169	–	#endif
9170	–	Syntax error
9171	–	_ACEOF
9172	–	if ac_fn_cxx_try_cpp "$LINENO"; then :
9173	–
9174	–	else
9175	–	# Broken: fails on valid input.
9176	–	continue
9177	–	fi
9178	–	rm -f conftest.err conftest.$ac_ext
9179	–
9180	–	# OK, works on sane cases.  Now check whether nonexistent headers
9181	–	# can be detected and how.
9182	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9183	–	/* end confdefs.h.  */
9184	–	#include <ac_nonexistent.h>
9185	–	_ACEOF
9186	–	if ac_fn_cxx_try_cpp "$LINENO"; then :
9187	–	# Broken: success on invalid input.
9188	–	continue
9189	–	else
9190	–	# Passes both tests.
9191	–	ac_preproc_ok=:
9192	–	break
9193	–	fi
9194	–	rm -f conftest.err conftest.$ac_ext
9195	–
9196	–	done
9197	–	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9198	–	rm -f conftest.err conftest.$ac_ext
9199	–	if $ac_preproc_ok; then :
9200	–	break
9201	–	fi
9202	–
9203	–	done
9204	–	ac_cv_prog_CXXCPP=$CXXCPP
9205	–
9206	–	fi
9207	–	CXXCPP=$ac_cv_prog_CXXCPP
9208	–	else
9209	–	ac_cv_prog_CXXCPP=$CXXCPP
9210	–	fi
9211	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
9212	–	$as_echo "$CXXCPP" >&6; }
9213	–	ac_preproc_ok=false
9214	–	for ac_cxx_preproc_warn_flag in '' yes
9215	–	do
9216	–	# Use a header file that comes with gcc, so configuring glibc
9217	–	# with a fresh cross-compiler works.
9218	–	# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9219	–	# <limits.h> exists even on freestanding compilers.
9220	–	# On the NeXT, cc -E runs the code through the compiler's parser,
9221	–	# not just through cpp. "Syntax error" is here to catch this case.
9222	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9223	–	/* end confdefs.h.  */
9224	–	#ifdef __STDC__
9225	–	# include <limits.h>
9226	–	#else
9227	–	# include <assert.h>
9228	–	#endif
9229	–	Syntax error
9230	–	_ACEOF
9231	–	if ac_fn_cxx_try_cpp "$LINENO"; then :
9232	–
9233	–	else
9234	–	# Broken: fails on valid input.
9235	–	continue
9236	–	fi
9237	–	rm -f conftest.err conftest.$ac_ext
9238	–
9239	–	# OK, works on sane cases.  Now check whether nonexistent headers
9240	–	# can be detected and how.
9241	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9242	–	/* end confdefs.h.  */
9243	–	#include <ac_nonexistent.h>
9244	–	_ACEOF
9245	–	if ac_fn_cxx_try_cpp "$LINENO"; then :
9246	–	# Broken: success on invalid input.
9247	–	continue
9248	–	else
9249	–	# Passes both tests.
9250	–	ac_preproc_ok=:
9251	–	break
9252	–	fi
9253	–	rm -f conftest.err conftest.$ac_ext
9254	–
9255	–	done
9256	–	# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9257	–	rm -f conftest.err conftest.$ac_ext
9258	–	if $ac_preproc_ok; then :
9259	–
9260	–	else
9261	–	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
9262	–	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
9263	–	as_fn_error "C++ preprocessor \"$CXXCPP\" fails sanity check
9264	–	See \`config.log' for more details." "$LINENO" 5; }
9265	–	fi
9266	–
9267	–	ac_ext=cpp
9268	–	ac_cpp='$CXXCPP $CPPFLAGS'
9269	–	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9270	–	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9271	–	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9272	–
9273	–
8054		#
8055		# Handle user hints
8056		#

Diff Legend

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