ViewVC Help

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

root/OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 1225 by gezelter, Fri Feb 8 21:33:46 2008 UTC vs.
Revision 1299 by skuang, Fri Sep 26 18:54:53 2008 UTC

#	Line 699 | Line 699 | RANLIB
699		LN_S
700		SET_MAKE
701		RANLIB
702	–	YACC
703	–	YFLAGS
704	–	LEX
705	–	LEX_OUTPUT_ROOT
706	–	LEXLIB
702		PERLINTERP
703		PERL_SHEBANG
704		INSTALL_PROGRAM
#	Line 739 | Line 734 | POW_LIB
734		USE_OPENBABEL
735		LIBOBJS
736		POW_LIB
742	–	__func__
737		CGAL_MAKEFILE
738		CGAL_CXXFLAGS
739		CGAL_CPPFLAGS
#	Line 773 | Line 767 | CPP
767		FC
768		FCFLAGS
769		CPP
776	–	YACC
777	–	YFLAGS
770		CXXCPP'
771
772
#	Line 1392 | Line 1384 | Some influential environment variables:
1384		FC          Fortran compiler command
1385		FCFLAGS     Fortran compiler flags
1386		CPP         C preprocessor
1395	–	YACC        The `Yet Another C Compiler' implementation to use. Defaults to
1396	–	the first program found out of: `bison -y', `byacc', `yacc'.
1397	–	YFLAGS      The list of arguments that will be passed by default to $YACC.
1398	–	This script will default YFLAGS to the empty string to avoid a
1399	–	default value of `-d' given by some make applications.
1387		CXXCPP      C++ preprocessor
1388
1389		Use these variables to override the choices made by `configure' or to help
#	Line 5132 | Line 5119 | else
5119		fi
5120		else
5121		RANLIB="$ac_cv_prog_RANLIB"
5135	–	fi
5136	–
5137	–	for ac_prog in 'bison -y' byacc
5138	–	do
5139	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
5140	–	set dummy $ac_prog; ac_word=$2
5141	–	{ echo "$as_me:$LINENO: checking for $ac_word" >&5
5142	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
5143	–	if test "${ac_cv_prog_YACC+set}" = set; then
5144	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5145	–	else
5146	–	if test -n "$YACC"; then
5147	–	ac_cv_prog_YACC="$YACC" # Let the user override the test.
5148	–	else
5149	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5150	–	for as_dir in $PATH
5151	–	do
5152	–	IFS=$as_save_IFS
5153	–	test -z "$as_dir" && as_dir=.
5154	–	for ac_exec_ext in '' $ac_executable_extensions; do
5155	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5156	–	ac_cv_prog_YACC="$ac_prog"
5157	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5158	–	break 2
5159	–	fi
5160	–	done
5161	–	done
5162	–	IFS=$as_save_IFS
5163	–
5164	–	fi
5165	–	fi
5166	–	YACC=$ac_cv_prog_YACC
5167	–	if test -n "$YACC"; then
5168	–	{ echo "$as_me:$LINENO: result: $YACC" >&5
5169	–	echo "${ECHO_T}$YACC" >&6; }
5170	–	else
5171	–	{ echo "$as_me:$LINENO: result: no" >&5
5172	–	echo "${ECHO_T}no" >&6; }
5173	–	fi
5174	–
5175	–
5176	–	test -n "$YACC" && break
5177	–	done
5178	–	test -n "$YACC" || YACC="yacc"
5179	–
5180	–
5181	–	for ac_prog in flex lex
5182	–	do
5183	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
5184	–	set dummy $ac_prog; ac_word=$2
5185	–	{ echo "$as_me:$LINENO: checking for $ac_word" >&5
5186	–	echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
5187	–	if test "${ac_cv_prog_LEX+set}" = set; then
5188	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5189	–	else
5190	–	if test -n "$LEX"; then
5191	–	ac_cv_prog_LEX="$LEX" # Let the user override the test.
5192	–	else
5193	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5194	–	for as_dir in $PATH
5195	–	do
5196	–	IFS=$as_save_IFS
5197	–	test -z "$as_dir" && as_dir=.
5198	–	for ac_exec_ext in '' $ac_executable_extensions; do
5199	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5200	–	ac_cv_prog_LEX="$ac_prog"
5201	–	echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5202	–	break 2
5203	–	fi
5204	–	done
5205	–	done
5206	–	IFS=$as_save_IFS
5207	–
5208	–	fi
5209	–	fi
5210	–	LEX=$ac_cv_prog_LEX
5211	–	if test -n "$LEX"; then
5212	–	{ echo "$as_me:$LINENO: result: $LEX" >&5
5213	–	echo "${ECHO_T}$LEX" >&6; }
5214	–	else
5215	–	{ echo "$as_me:$LINENO: result: no" >&5
5216	–	echo "${ECHO_T}no" >&6; }
5217	–	fi
5218	–
5219	–
5220	–	test -n "$LEX" && break
5221	–	done
5222	–	test -n "$LEX" || LEX=":"
5223	–
5224	–	if test "x$LEX" != "x:"; then
5225	–	cat >conftest.l <<_ACEOF
5226	–	%%
5227	–	a { ECHO; }
5228	–	b { REJECT; }
5229	–	c { yymore (); }
5230	–	d { yyless (1); }
5231	–	e { yyless (input () != 0); }
5232	–	f { unput (yytext[0]); }
5233	–	. { BEGIN INITIAL; }
5234	–	%%
5235	–	#ifdef YYTEXT_POINTER
5236	–	extern char *yytext;
5237	–	#endif
5238	–	int
5239	–	main (void)
5240	–	{
5241	–	return ! yylex () + ! yywrap ();
5242	–	}
5243	–	_ACEOF
5244	–	{ (ac_try="$LEX conftest.l"
5245	–	case "(($ac_try" in
5246	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5247	–	*) ac_try_echo=$ac_try;;
5248	–	esac
5249	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5250	–	(eval "$LEX conftest.l") 2>&5
5251	–	ac_status=$?
5252	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5253	–	(exit $ac_status); }
5254	–	{ echo "$as_me:$LINENO: checking lex output file root" >&5
5255	–	echo $ECHO_N "checking lex output file root... $ECHO_C" >&6; }
5256	–	if test "${ac_cv_prog_lex_root+set}" = set; then
5257	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5258	–	else
5259	–
5260	–	if test -f lex.yy.c; then
5261	–	ac_cv_prog_lex_root=lex.yy
5262	–	elif test -f lexyy.c; then
5263	–	ac_cv_prog_lex_root=lexyy
5264	–	else
5265	–	{ { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
5266	–	echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
5267	–	{ (exit 1); exit 1; }; }
5268	–	fi
5269	–	fi
5270	–	{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
5271	–	echo "${ECHO_T}$ac_cv_prog_lex_root" >&6; }
5272	–	LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
5273	–
5274	–	if test -z "${LEXLIB+set}"; then
5275	–	{ echo "$as_me:$LINENO: checking lex library" >&5
5276	–	echo $ECHO_N "checking lex library... $ECHO_C" >&6; }
5277	–	if test "${ac_cv_lib_lex+set}" = set; then
5278	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5279	–	else
5280	–
5281	–	ac_save_LIBS=$LIBS
5282	–	ac_cv_lib_lex='none needed'
5283	–	for ac_lib in '' -lfl -ll; do
5284	–	LIBS="$ac_lib $ac_save_LIBS"
5285	–	cat >conftest.$ac_ext <<_ACEOF
5286	–	`cat $LEX_OUTPUT_ROOT.c`
5287	–	_ACEOF
5288	–	rm -f conftest.$ac_objext conftest$ac_exeext
5289	–	if { (ac_try="$ac_link"
5290	–	case "(($ac_try" in
5291	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5292	–	*) ac_try_echo=$ac_try;;
5293	–	esac
5294	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5295	–	(eval "$ac_link") 2>conftest.er1
5296	–	ac_status=$?
5297	–	grep -v '^ *+' conftest.er1 >conftest.err
5298	–	rm -f conftest.er1
5299	–	cat conftest.err >&5
5300	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5301	–	(exit $ac_status); } && {
5302	–	test -z "$ac_c_werror_flag" ||
5303	–	test ! -s conftest.err
5304	–	} && test -s conftest$ac_exeext &&
5305	–	$as_test_x conftest$ac_exeext; then
5306	–	ac_cv_lib_lex=$ac_lib
5307	–	else
5308	–	echo "$as_me: failed program was:" >&5
5309	–	sed 's/^/| /' conftest.$ac_ext >&5
5310	–
5311	–
5312	–	fi
5313	–
5314	–	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5315	–	conftest$ac_exeext conftest.$ac_ext
5316	–	test "$ac_cv_lib_lex" != 'none needed' && break
5317	–	done
5318	–	LIBS=$ac_save_LIBS
5319	–
5320	–	fi
5321	–	{ echo "$as_me:$LINENO: result: $ac_cv_lib_lex" >&5
5322	–	echo "${ECHO_T}$ac_cv_lib_lex" >&6; }
5323	–	test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
5324	–	fi
5325	–
5326	–
5327	–	{ echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
5328	–	echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6; }
5329	–	if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
5330	–	echo $ECHO_N "(cached) $ECHO_C" >&6
5331	–	else
5332	–	# POSIX says lex can declare yytext either as a pointer or an array; the
5333	–	# default is implementation-dependent.  Figure out which it is, since
5334	–	# not all implementations provide the %pointer and %array declarations.
5335	–	ac_cv_prog_lex_yytext_pointer=no
5336	–	ac_save_LIBS=$LIBS
5337	–	LIBS="$LEXLIB $ac_save_LIBS"
5338	–	cat >conftest.$ac_ext <<_ACEOF
5339	–	#define YYTEXT_POINTER 1
5340	–	`cat $LEX_OUTPUT_ROOT.c`
5341	–	_ACEOF
5342	–	rm -f conftest.$ac_objext conftest$ac_exeext
5343	–	if { (ac_try="$ac_link"
5344	–	case "(($ac_try" in
5345	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5346	–	*) ac_try_echo=$ac_try;;
5347	–	esac
5348	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5349	–	(eval "$ac_link") 2>conftest.er1
5350	–	ac_status=$?
5351	–	grep -v '^ *+' conftest.er1 >conftest.err
5352	–	rm -f conftest.er1
5353	–	cat conftest.err >&5
5354	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
5355	–	(exit $ac_status); } && {
5356	–	test -z "$ac_c_werror_flag" ||
5357	–	test ! -s conftest.err
5358	–	} && test -s conftest$ac_exeext &&
5359	–	$as_test_x conftest$ac_exeext; then
5360	–	ac_cv_prog_lex_yytext_pointer=yes
5361	–	else
5362	–	echo "$as_me: failed program was:" >&5
5363	–	sed 's/^/| /' conftest.$ac_ext >&5
5364	–
5365	–
5366	–	fi
5367	–
5368	–	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5369	–	conftest$ac_exeext conftest.$ac_ext
5370	–	LIBS=$ac_save_LIBS
5371	–
5372	–	fi
5373	–	{ echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
5374	–	echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6; }
5375	–	if test $ac_cv_prog_lex_yytext_pointer = yes; then
5376	–
5377	–	cat >>confdefs.h <<\_ACEOF
5378	–	#define YYTEXT_POINTER 1
5379	–	_ACEOF
5380	–
5122		fi
5382	–	rm -f conftest.l $LEX_OUTPUT_ROOT.c
5123
5384	–	fi
5124
5125		# Extract the first word of "perl", so it can be a program name with args.
5126		set dummy perl; ac_word=$2
#	Line 6408 | Line 6147 | ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6147		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6148		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6149		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6150	+
6151
6152		ac_ext=${ac_fc_srcext-f}
6153		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
#	Line 9011 | Line 8751 | then
8751		#
8752		if test -n "${QHULL_HOME}"
8753		then
9014	–	QHULL_OLD_LDFLAGS=$LDFLAGS
9015	–	QHULL_OLD_CFLAGS=$CFLAGS
9016	–	LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
9017	–	CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
8754
8755		ac_ext=c
8756		ac_cpp='$CPP $CPPFLAGS'
8757		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8758		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8759		ac_compiler_gnu=$ac_cv_c_compiler_gnu
9024	–
9025	–	{ echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
9026	–	echo $ECHO_N "checking for qh_qhull in -lqhull... $ECHO_C" >&6; }
9027	–	if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
9028	–	echo $ECHO_N "(cached) $ECHO_C" >&6
9029	–	else
9030	–	ac_check_lib_save_LIBS=$LIBS
9031	–	LIBS="-lqhull  $LIBS"
9032	–	cat >conftest.$ac_ext <<_ACEOF
9033	–	/* confdefs.h.  */
9034	–	_ACEOF
9035	–	cat confdefs.h >>conftest.$ac_ext
9036	–	cat >>conftest.$ac_ext <<_ACEOF
9037	–	/* end confdefs.h.  */
8760
8761	<	/* Override any GCC internal prototype to avoid an error.
8762	<	Use char because int might match the return type of a GCC
8763	<	builtin and then its argument prototype would still apply.  */
8764	<	#ifdef __cplusplus
8765	<	extern "C"
8766	<	#endif
9045	<	char qh_qhull ();
9046	<	#ifdef FC_DUMMY_MAIN
9047	<	#ifndef FC_DUMMY_MAIN_EQ_F77
9048	<	#  ifdef __cplusplus
9049	<	extern "C"
9050	<	#  endif
9051	<	int FC_DUMMY_MAIN() { return 1; }
9052	<	#endif
9053	<	#endif
9054	<	int
9055	<	main ()
9056	<	{
9057	<	return qh_qhull ();
9058	<	;
9059	<	return 0;
9060	<	}
9061	<	_ACEOF
9062	<	rm -f conftest.$ac_objext conftest$ac_exeext
9063	<	if { (ac_try="$ac_link"
9064	<	case "(($ac_try" in
9065	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9066	<	*) ac_try_echo=$ac_try;;
9067	<	esac
9068	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9069	<	(eval "$ac_link") 2>conftest.er1
9070	<	ac_status=$?
9071	<	grep -v '^ *+' conftest.er1 >conftest.err
9072	<	rm -f conftest.er1
9073	<	cat conftest.err >&5
9074	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
9075	<	(exit $ac_status); } && {
9076	<	test -z "$ac_c_werror_flag" ||
9077	<	test ! -s conftest.err
9078	<	} && test -s conftest$ac_exeext &&
9079	<	$as_test_x conftest$ac_exeext; then
9080	<	ac_cv_lib_qhull_qh_qhull=yes
9081	<	else
9082	<	echo "$as_me: failed program was:" >&5
9083	<	sed 's/^/| /' conftest.$ac_ext >&5
9084	<
9085	<	ac_cv_lib_qhull_qh_qhull=no
9086	<	fi
9087	<
9088	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9089	<	conftest$ac_exeext conftest.$ac_ext
9090	<	LIBS=$ac_check_lib_save_LIBS
9091	<	fi
9092	<	{ echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
9093	<	echo "${ECHO_T}$ac_cv_lib_qhull_qh_qhull" >&6; }
9094	<	if test $ac_cv_lib_qhull_qh_qhull = yes; then
9095	<	qhull_cv_libqhull=yes
9096	<	else
9097	<	qhull_cv_libqhull=no
9098	<	fi
9099	<
8761	>	QHULL_OLD_LDFLAGS=$LDFLAGS
8762	>	QHULL_OLD_CFLAGS=$CFLAGS
8763	>	QHULL_OLD_CPPFLAGS=$CPPFLAGS
8764	>	LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
8765	>	CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
8766	>	CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
8767		if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8768		{ echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8769		echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6; }
#	Line 9231 | Line 8898 | else
8898		qhull_cv_qhull_h=yes
8899		else
8900		qhull_cv_qhull_h=no
8901	+	fi
8902	+
8903	+
8904	+	{ echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
8905	+	echo $ECHO_N "checking for qh_qhull in -lqhull... $ECHO_C" >&6; }
8906	+	if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
8907	+	echo $ECHO_N "(cached) $ECHO_C" >&6
8908	+	else
8909	+	ac_check_lib_save_LIBS=$LIBS
8910	+	LIBS="-lqhull  $LIBS"
8911	+	cat >conftest.$ac_ext <<_ACEOF
8912	+	/* confdefs.h.  */
8913	+	_ACEOF
8914	+	cat confdefs.h >>conftest.$ac_ext
8915	+	cat >>conftest.$ac_ext <<_ACEOF
8916	+	/* end confdefs.h.  */
8917	+
8918	+	/* Override any GCC internal prototype to avoid an error.
8919	+	Use char because int might match the return type of a GCC
8920	+	builtin and then its argument prototype would still apply.  */
8921	+	#ifdef __cplusplus
8922	+	extern "C"
8923	+	#endif
8924	+	char qh_qhull ();
8925	+	#ifdef FC_DUMMY_MAIN
8926	+	#ifndef FC_DUMMY_MAIN_EQ_F77
8927	+	#  ifdef __cplusplus
8928	+	extern "C"
8929	+	#  endif
8930	+	int FC_DUMMY_MAIN() { return 1; }
8931	+	#endif
8932	+	#endif
8933	+	int
8934	+	main ()
8935	+	{
8936	+	return qh_qhull ();
8937	+	;
8938	+	return 0;
8939	+	}
8940	+	_ACEOF
8941	+	rm -f conftest.$ac_objext conftest$ac_exeext
8942	+	if { (ac_try="$ac_link"
8943	+	case "(($ac_try" in
8944	+	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8945	+	*) ac_try_echo=$ac_try;;
8946	+	esac
8947	+	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8948	+	(eval "$ac_link") 2>conftest.er1
8949	+	ac_status=$?
8950	+	grep -v '^ *+' conftest.er1 >conftest.err
8951	+	rm -f conftest.er1
8952	+	cat conftest.err >&5
8953	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
8954	+	(exit $ac_status); } && {
8955	+	test -z "$ac_c_werror_flag" ||
8956	+	test ! -s conftest.err
8957	+	} && test -s conftest$ac_exeext &&
8958	+	$as_test_x conftest$ac_exeext; then
8959	+	ac_cv_lib_qhull_qh_qhull=yes
8960	+	else
8961	+	echo "$as_me: failed program was:" >&5
8962	+	sed 's/^/| /' conftest.$ac_ext >&5
8963	+
8964	+	ac_cv_lib_qhull_qh_qhull=no
8965		fi
8966
8967	+	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8968	+	conftest$ac_exeext conftest.$ac_ext
8969	+	LIBS=$ac_check_lib_save_LIBS
8970	+	fi
8971	+	{ echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
8972	+	echo "${ECHO_T}$ac_cv_lib_qhull_qh_qhull" >&6; }
8973	+	if test $ac_cv_lib_qhull_qh_qhull = yes; then
8974	+	qhull_cv_libqhull=yes
8975	+	else
8976	+	qhull_cv_libqhull=no
8977	+	fi
8978
8979	+	LDFLAGS="$QHULL_OLD_LDFLAGS"
8980	+	CFLAGS="$QHULL_OLD_CFLAGS"
8981	+	CPPFLAGS="$QHULL_OLD_CPPFLAGS"
8982		ac_ext=c
8983		ac_cpp='$CPP $CPPFLAGS'
8984		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 9263 | Line 9008 | echo $ECHO_N "checking qhull in ${QHULL_HOME}... $ECHO
9008		QHULL_LIB_DIR=
9009		QHULL=
9010		USE_QHULL=no
9266	–	LDFLAGS="$QHULL_OLD_LDFLAGS"
9267	–	CFLAGS="$QHULL_OLD_CFLAGS"
9011		{ echo "$as_me:$LINENO: result: failed" >&5
9012		echo "${ECHO_T}failed" >&6; }
9013		echo ""
#	Line 10139 | Line 9882 | fi
9882
9883
9884
9885	<
10143	<
10144	<
10145	<
10146	<
10147	<
10148	<
10149	<
10150	<
10151	<
10152	<	for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
9885	>	for ac_header in libintl.h limits.h machine/hal_sysinfo.h stdlib.h string.h strings.h sys/param.h sys/pstat.h sys/sysctl.h sys/sysinfo.h sys/sysmp.h sys/systemcfg.h sys/table.h sys/time.h unistd.h
9886		do
9887		as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9888		if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
#	Line 10680 | Line 10413 | esac
10413		;;
10414		esac
10415
10683	–	{ echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
10684	–	echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6; }
10685	–	if test "${ac_cv_c_restrict+set}" = set; then
10686	–	echo $ECHO_N "(cached) $ECHO_C" >&6
10687	–	else
10688	–	ac_cv_c_restrict=no
10689	–	# Try the official restrict keyword, then gcc's __restrict, and
10690	–	# the less common variants.
10691	–	for ac_kw in restrict __restrict __restrict__ _Restrict; do
10692	–	cat >conftest.$ac_ext <<_ACEOF
10693	–	/* confdefs.h.  */
10694	–	_ACEOF
10695	–	cat confdefs.h >>conftest.$ac_ext
10696	–	cat >>conftest.$ac_ext <<_ACEOF
10697	–	/* end confdefs.h.  */
10698	–	typedef int * int_ptr;
10699	–	int foo (int_ptr $ac_kw ip) {
10700	–	return ip[0];
10701	–	}
10702	–	#ifdef FC_DUMMY_MAIN
10703	–	#ifndef FC_DUMMY_MAIN_EQ_F77
10704	–	#  ifdef __cplusplus
10705	–	extern "C"
10706	–	#  endif
10707	–	int FC_DUMMY_MAIN() { return 1; }
10708	–	#endif
10709	–	#endif
10710	–	int
10711	–	main ()
10712	–	{
10713	–	int s[1];
10714	–	int * $ac_kw t = s;
10715	–	t[0] = 0;
10716	–	return foo(t)
10717	–	;
10718	–	return 0;
10719	–	}
10720	–	_ACEOF
10721	–	rm -f conftest.$ac_objext
10722	–	if { (ac_try="$ac_compile"
10723	–	case "(($ac_try" in
10724	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10725	–	*) ac_try_echo=$ac_try;;
10726	–	esac
10727	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10728	–	(eval "$ac_compile") 2>conftest.er1
10729	–	ac_status=$?
10730	–	grep -v '^ *+' conftest.er1 >conftest.err
10731	–	rm -f conftest.er1
10732	–	cat conftest.err >&5
10733	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10734	–	(exit $ac_status); } && {
10735	–	test -z "$ac_c_werror_flag" ||
10736	–	test ! -s conftest.err
10737	–	} && test -s conftest.$ac_objext; then
10738	–	ac_cv_c_restrict=$ac_kw
10739	–	else
10740	–	echo "$as_me: failed program was:" >&5
10741	–	sed 's/^/| /' conftest.$ac_ext >&5
10742	–
10743	–
10744	–	fi
10745	–
10746	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10747	–	test "$ac_cv_c_restrict" != no && break
10748	–	done
10749	–
10750	–	fi
10751	–	{ echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
10752	–	echo "${ECHO_T}$ac_cv_c_restrict" >&6; }
10753	–	case $ac_cv_c_restrict in
10754	–	restrict) ;;
10755	–	no)
10756	–	cat >>confdefs.h <<\_ACEOF
10757	–	#define restrict
10758	–	_ACEOF
10759	–	;;
10760	–	*)  cat >>confdefs.h <<_ACEOF
10761	–	#define restrict $ac_cv_c_restrict
10762	–	_ACEOF
10763	–	;;
10764	–	esac
10765	–
10416		{ echo "$as_me:$LINENO: checking for size_t" >&5
10417		echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
10418		if test "${ac_cv_type_size_t+set}" = set; then
#	Line 10902 | Line 10552 | fi
10552		_ACEOF
10553
10554		fi
10905	–
10906	–	{ echo "$as_me:$LINENO: checking for clock_t" >&5
10907	–	echo $ECHO_N "checking for clock_t... $ECHO_C" >&6; }
10908	–	if test "${ac_cv_type_clock_t+set}" = set; then
10909	–	echo $ECHO_N "(cached) $ECHO_C" >&6
10910	–	else
10911	–	cat >conftest.$ac_ext <<_ACEOF
10912	–	/* confdefs.h.  */
10913	–	_ACEOF
10914	–	cat confdefs.h >>conftest.$ac_ext
10915	–	cat >>conftest.$ac_ext <<_ACEOF
10916	–	/* end confdefs.h.  */
10917	–	$ac_includes_default
10918	–	typedef clock_t ac__type_new_;
10919	–	#ifdef FC_DUMMY_MAIN
10920	–	#ifndef FC_DUMMY_MAIN_EQ_F77
10921	–	#  ifdef __cplusplus
10922	–	extern "C"
10923	–	#  endif
10924	–	int FC_DUMMY_MAIN() { return 1; }
10925	–	#endif
10926	–	#endif
10927	–	int
10928	–	main ()
10929	–	{
10930	–	if ((ac__type_new_ *) 0)
10931	–	return 0;
10932	–	if (sizeof (ac__type_new_))
10933	–	return 0;
10934	–	;
10935	–	return 0;
10936	–	}
10937	–	_ACEOF
10938	–	rm -f conftest.$ac_objext
10939	–	if { (ac_try="$ac_compile"
10940	–	case "(($ac_try" in
10941	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10942	–	*) ac_try_echo=$ac_try;;
10943	–	esac
10944	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10945	–	(eval "$ac_compile") 2>conftest.er1
10946	–	ac_status=$?
10947	–	grep -v '^ *+' conftest.er1 >conftest.err
10948	–	rm -f conftest.er1
10949	–	cat conftest.err >&5
10950	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
10951	–	(exit $ac_status); } && {
10952	–	test -z "$ac_c_werror_flag" ||
10953	–	test ! -s conftest.err
10954	–	} && test -s conftest.$ac_objext; then
10955	–	ac_cv_type_clock_t=yes
10956	–	else
10957	–	echo "$as_me: failed program was:" >&5
10958	–	sed 's/^/| /' conftest.$ac_ext >&5
10959	–
10960	–	ac_cv_type_clock_t=no
10961	–	fi
10962	–
10963	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10964	–	fi
10965	–	{ echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
10966	–	echo "${ECHO_T}$ac_cv_type_clock_t" >&6; }
10967	–	if test $ac_cv_type_clock_t = yes; then
10968	–
10969	–	cat >>confdefs.h <<_ACEOF
10970	–	#define HAVE_CLOCK_T 1
10971	–	_ACEOF
10972	–
10973	–
10974	–	fi
10975	–
10976	–	{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
10977	–	echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
10978	–	if test "${ac_cv_c_const+set}" = set; then
10979	–	echo $ECHO_N "(cached) $ECHO_C" >&6
10980	–	else
10981	–	cat >conftest.$ac_ext <<_ACEOF
10982	–	/* confdefs.h.  */
10983	–	_ACEOF
10984	–	cat confdefs.h >>conftest.$ac_ext
10985	–	cat >>conftest.$ac_ext <<_ACEOF
10986	–	/* end confdefs.h.  */
10987	–
10988	–	#ifdef FC_DUMMY_MAIN
10989	–	#ifndef FC_DUMMY_MAIN_EQ_F77
10990	–	#  ifdef __cplusplus
10991	–	extern "C"
10992	–	#  endif
10993	–	int FC_DUMMY_MAIN() { return 1; }
10994	–	#endif
10995	–	#endif
10996	–	int
10997	–	main ()
10998	–	{
10999	–	/* FIXME: Include the comments suggested by Paul. */
11000	–	#ifndef __cplusplus
11001	–	/* Ultrix mips cc rejects this.  */
11002	–	typedef int charset[2];
11003	–	const charset cs;
11004	–	/* SunOS 4.1.1 cc rejects this.  */
11005	–	char const *const *pcpcc;
11006	–	char **ppc;
11007	–	/* NEC SVR4.0.2 mips cc rejects this.  */
11008	–	struct point {int x, y;};
11009	–	static struct point const zero = {0,0};
11010	–	/* AIX XL C 1.02.0.0 rejects this.
11011	–	It does not let you subtract one const X* pointer from another in
11012	–	an arm of an if-expression whose if-part is not a constant
11013	–	expression */
11014	–	const char *g = "string";
11015	–	pcpcc = &g + (g ? g-g : 0);
11016	–	/* HPUX 7.0 cc rejects these. */
11017	–	++pcpcc;
11018	–	ppc = (char**) pcpcc;
11019	–	pcpcc = (char const *const *) ppc;
11020	–	{ /* SCO 3.2v4 cc rejects this.  */
11021	–	char *t;
11022	–	char const *s = 0 ? (char *) 0 : (char const *) 0;
11023	–
11024	–	*t++ = 0;
11025	–	if (s) return 0;
11026	–	}
11027	–	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
11028	–	int x[] = {25, 17};
11029	–	const int *foo = &x[0];
11030	–	++foo;
11031	–	}
11032	–	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
11033	–	typedef const int *iptr;
11034	–	iptr p = 0;
11035	–	++p;
11036	–	}
11037	–	{ /* AIX XL C 1.02.0.0 rejects this saying
11038	–	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
11039	–	struct s { int j; const int *ap[3]; };
11040	–	struct s *b; b->j = 5;
11041	–	}
11042	–	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
11043	–	const int foo = 10;
11044	–	if (!foo) return 0;
11045	–	}
11046	–	return !cs[0] && !zero.x;
11047	–	#endif
11048	–
11049	–	;
11050	–	return 0;
11051	–	}
11052	–	_ACEOF
11053	–	rm -f conftest.$ac_objext
11054	–	if { (ac_try="$ac_compile"
11055	–	case "(($ac_try" in
11056	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11057	–	*) ac_try_echo=$ac_try;;
11058	–	esac
11059	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11060	–	(eval "$ac_compile") 2>conftest.er1
11061	–	ac_status=$?
11062	–	grep -v '^ *+' conftest.er1 >conftest.err
11063	–	rm -f conftest.er1
11064	–	cat conftest.err >&5
11065	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11066	–	(exit $ac_status); } && {
11067	–	test -z "$ac_c_werror_flag" ||
11068	–	test ! -s conftest.err
11069	–	} && test -s conftest.$ac_objext; then
11070	–	ac_cv_c_const=yes
11071	–	else
11072	–	echo "$as_me: failed program was:" >&5
11073	–	sed 's/^/| /' conftest.$ac_ext >&5
11074	–
11075	–	ac_cv_c_const=no
11076	–	fi
11077	–
11078	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11079	–	fi
11080	–	{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
11081	–	echo "${ECHO_T}$ac_cv_c_const" >&6; }
11082	–	if test $ac_cv_c_const = no; then
11083	–
11084	–	cat >>confdefs.h <<\_ACEOF
11085	–	#define const
11086	–	_ACEOF
11087	–
11088	–	fi
11089	–
11090	–	{ echo "$as_me:$LINENO: checking for inline" >&5
11091	–	echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
11092	–	if test "${ac_cv_c_inline+set}" = set; then
11093	–	echo $ECHO_N "(cached) $ECHO_C" >&6
11094	–	else
11095	–	ac_cv_c_inline=no
11096	–	for ac_kw in inline __inline__ __inline; do
11097	–	cat >conftest.$ac_ext <<_ACEOF
11098	–	/* confdefs.h.  */
11099	–	_ACEOF
11100	–	cat confdefs.h >>conftest.$ac_ext
11101	–	cat >>conftest.$ac_ext <<_ACEOF
11102	–	/* end confdefs.h.  */
11103	–	#ifndef __cplusplus
11104	–	typedef int foo_t;
11105	–	static $ac_kw foo_t static_foo () {return 0; }
11106	–	$ac_kw foo_t foo () {return 0; }
11107	–	#endif
11108	–
11109	–	_ACEOF
11110	–	rm -f conftest.$ac_objext
11111	–	if { (ac_try="$ac_compile"
11112	–	case "(($ac_try" in
11113	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11114	–	*) ac_try_echo=$ac_try;;
11115	–	esac
11116	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11117	–	(eval "$ac_compile") 2>conftest.er1
11118	–	ac_status=$?
11119	–	grep -v '^ *+' conftest.er1 >conftest.err
11120	–	rm -f conftest.er1
11121	–	cat conftest.err >&5
11122	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11123	–	(exit $ac_status); } && {
11124	–	test -z "$ac_c_werror_flag" ||
11125	–	test ! -s conftest.err
11126	–	} && test -s conftest.$ac_objext; then
11127	–	ac_cv_c_inline=$ac_kw
11128	–	else
11129	–	echo "$as_me: failed program was:" >&5
11130	–	sed 's/^/| /' conftest.$ac_ext >&5
11131	–
11132	–
11133	–	fi
11134	–
11135	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11136	–	test "$ac_cv_c_inline" != no && break
11137	–	done
11138	–
11139	–	fi
11140	–	{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
11141	–	echo "${ECHO_T}$ac_cv_c_inline" >&6; }
11142	–
11143	–
11144	–	case $ac_cv_c_inline in
11145	–	inline | yes) ;;
11146	–	*)
11147	–	case $ac_cv_c_inline in
11148	–	no) ac_val=;;
11149	–	*) ac_val=$ac_cv_c_inline;;
11150	–	esac
11151	–	cat >>confdefs.h <<_ACEOF
11152	–	#ifndef __cplusplus
11153	–	#define inline $ac_val
11154	–	#endif
11155	–	_ACEOF
11156	–	;;
11157	–	esac
10555
10556
10557		# Checks for library functions.
#	Line 11395 | Line 10792 | cat >>confdefs.h <<\_ACEOF
10792
10793		cat >>confdefs.h <<\_ACEOF
10794		#define malloc rpl_malloc
11398	–	_ACEOF
11399	–
11400	–	fi
11401	–
11402	–
11403	–
11404	–	{ echo "$as_me:$LINENO: checking for working memcmp" >&5
11405	–	echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6; }
11406	–	if test "${ac_cv_func_memcmp_working+set}" = set; then
11407	–	echo $ECHO_N "(cached) $ECHO_C" >&6
11408	–	else
11409	–	if test "$cross_compiling" = yes; then
11410	–	ac_cv_func_memcmp_working=no
11411	–	else
11412	–	cat >conftest.$ac_ext <<_ACEOF
11413	–	/* confdefs.h.  */
10795		_ACEOF
11415	–	cat confdefs.h >>conftest.$ac_ext
11416	–	cat >>conftest.$ac_ext <<_ACEOF
11417	–	/* end confdefs.h.  */
11418	–	$ac_includes_default
11419	–	#ifdef FC_DUMMY_MAIN
11420	–	#ifndef FC_DUMMY_MAIN_EQ_F77
11421	–	#  ifdef __cplusplus
11422	–	extern "C"
11423	–	#  endif
11424	–	int FC_DUMMY_MAIN() { return 1; }
11425	–	#endif
11426	–	#endif
11427	–	int
11428	–	main ()
11429	–	{
11430	–
11431	–	/* Some versions of memcmp are not 8-bit clean.  */
11432	–	char c0 = '\100', c1 = '\200', c2 = '\201';
11433	–	if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
11434	–	return 1;
11435	–
11436	–	/* The Next x86 OpenStep bug shows up only when comparing 16 bytes
11437	–	or more and with at least one buffer not starting on a 4-byte boundary.
11438	–	William Lewis provided this test program.   */
11439	–	{
11440	–	char foo[21];
11441	–	char bar[21];
11442	–	int i;
11443	–	for (i = 0; i < 4; i++)
11444	–	{
11445	–	char *a = foo + i;
11446	–	char *b = bar + i;
11447	–	strcpy (a, "--------01111111");
11448	–	strcpy (b, "--------10000000");
11449	–	if (memcmp (a, b, 16) >= 0)
11450	–	return 1;
11451	–	}
11452	–	return 0;
11453	–	}
11454	–
11455	–	;
11456	–	return 0;
11457	–	}
11458	–	_ACEOF
11459	–	rm -f conftest$ac_exeext
11460	–	if { (ac_try="$ac_link"
11461	–	case "(($ac_try" in
11462	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11463	–	*) ac_try_echo=$ac_try;;
11464	–	esac
11465	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11466	–	(eval "$ac_link") 2>&5
11467	–	ac_status=$?
11468	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469	–	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11470	–	{ (case "(($ac_try" in
11471	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11472	–	*) ac_try_echo=$ac_try;;
11473	–	esac
11474	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11475	–	(eval "$ac_try") 2>&5
11476	–	ac_status=$?
11477	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11478	–	(exit $ac_status); }; }; then
11479	–	ac_cv_func_memcmp_working=yes
11480	–	else
11481	–	echo "$as_me: program exited with status $ac_status" >&5
11482	–	echo "$as_me: failed program was:" >&5
11483	–	sed 's/^/| /' conftest.$ac_ext >&5
10796
11485	–	( exit $ac_status )
11486	–	ac_cv_func_memcmp_working=no
10797		fi
11488	–	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11489	–	fi
10798
11491	–
11492	–	fi
11493	–	{ echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
11494	–	echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6; }
11495	–	test $ac_cv_func_memcmp_working = no && case " $LIBOBJS " in
11496	–	*" memcmp.$ac_objext "* ) ;;
11497	–	*) LIBOBJS="$LIBOBJS memcmp.$ac_objext"
11498	–	;;
11499	–	esac
10799
10800
10801
#	Line 11983 | Line 11282 | rm -f conftest*
11282		_ACEOF
11283
11284		rm -f conftest*
11986	–
11285
11286	<	for ac_func in strftime
11287	<	do
11288	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11991	<	{ echo "$as_me:$LINENO: checking for $ac_func" >&5
11992	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
11993	<	if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11286	>	{ echo "$as_me:$LINENO: checking for working strtod" >&5
11287	>	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6; }
11288	>	if test "${ac_cv_func_strtod+set}" = set; then
11289		echo $ECHO_N "(cached) $ECHO_C" >&6
11290		else
11291	+	if test "$cross_compiling" = yes; then
11292	+	ac_cv_func_strtod=no
11293	+	else
11294		cat >conftest.$ac_ext <<_ACEOF
11295		/* confdefs.h.  */
11296		_ACEOF
11297		cat confdefs.h >>conftest.$ac_ext
11298		cat >>conftest.$ac_ext <<_ACEOF
11299		/* end confdefs.h.  */
11300	<	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11300	>
11301	>	$ac_includes_default
11302	>	#ifndef strtod
11303	>	double strtod ();
11304	>	#endif
11305	>	int
11306	>	main()
11307	>	{
11308	>	{
11309	>	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
11310	>	char *string = " +69";
11311	>	char *term;
11312	>	double value;
11313	>	value = strtod (string, &term);
11314	>	if (value != 69 || term != (string + 4))
11315	>	return 1;
11316	>	}
11317	>
11318	>	{
11319	>	/* Under Solaris 2.4, strtod returns the wrong value for the
11320	>	terminating character under some conditions.  */
11321	>	char *string = "NaN";
11322	>	char *term;
11323	>	strtod (string, &term);
11324	>	if (term != string && *(term - 1) == 0)
11325	>	return 1;
11326	>	}
11327	>	return 0;
11328	>	}
11329	>
11330	>	_ACEOF
11331	>	rm -f conftest$ac_exeext
11332	>	if { (ac_try="$ac_link"
11333	>	case "(($ac_try" in
11334	>	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11335	>	*) ac_try_echo=$ac_try;;
11336	>	esac
11337	>	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11338	>	(eval "$ac_link") 2>&5
11339	>	ac_status=$?
11340	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11341	>	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11342	>	{ (case "(($ac_try" in
11343	>	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11344	>	*) ac_try_echo=$ac_try;;
11345	>	esac
11346	>	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11347	>	(eval "$ac_try") 2>&5
11348	>	ac_status=$?
11349	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
11350	>	(exit $ac_status); }; }; then
11351	>	ac_cv_func_strtod=yes
11352	>	else
11353	>	echo "$as_me: program exited with status $ac_status" >&5
11354	>	echo "$as_me: failed program was:" >&5
11355	>	sed 's/^/| /' conftest.$ac_ext >&5
11356	>
11357	>	( exit $ac_status )
11358	>	ac_cv_func_strtod=no
11359	>	fi
11360	>	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11361	>	fi
11362	>
11363	>
11364	>	fi
11365	>	{ echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
11366	>	echo "${ECHO_T}$ac_cv_func_strtod" >&6; }
11367	>	if test $ac_cv_func_strtod = no; then
11368	>	case " $LIBOBJS " in
11369	>	*" strtod.$ac_objext "* ) ;;
11370	>	*) LIBOBJS="$LIBOBJS strtod.$ac_objext"
11371	>	;;
11372	>	esac
11373	>
11374	>	{ echo "$as_me:$LINENO: checking for pow" >&5
11375	>	echo $ECHO_N "checking for pow... $ECHO_C" >&6; }
11376	>	if test "${ac_cv_func_pow+set}" = set; then
11377	>	echo $ECHO_N "(cached) $ECHO_C" >&6
11378	>	else
11379	>	cat >conftest.$ac_ext <<_ACEOF
11380	>	/* confdefs.h.  */
11381	>	_ACEOF
11382	>	cat confdefs.h >>conftest.$ac_ext
11383	>	cat >>conftest.$ac_ext <<_ACEOF
11384	>	/* end confdefs.h.  */
11385	>	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
11386		For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11387	<	#define $ac_func innocuous_$ac_func
11387	>	#define pow innocuous_pow
11388
11389		/* System header to define __stub macros and hopefully few prototypes,
11390	<	which can conflict with char $ac_func (); below.
11390	>	which can conflict with char pow (); below.
11391		Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11392		<limits.h> exists even on freestanding compilers.  */
11393
#	Line 12014 | Line 11397 | cat >>conftest.$ac_ext <<_ACEOF
11397		# include <assert.h>
11398		#endif
11399
11400	<	#undef $ac_func
11400	>	#undef pow
11401
11402		/* Override any GCC internal prototype to avoid an error.
11403		Use char because int might match the return type of a GCC
#	Line 12022 | Line 11405 | extern "C"
11405		#ifdef __cplusplus
11406		extern "C"
11407		#endif
11408	<	char $ac_func ();
11408	>	char pow ();
11409		/* The GNU C library defines this for functions which it implements
11410		to always fail with ENOSYS.  Some functions are actually named
11411		something starting with __ and the normal name is an alias.  */
11412	<	#if defined __stub_$ac_func || defined __stub___$ac_func
11412	>	#if defined __stub_pow || defined __stub___pow
11413		choke me
11414		#endif
11415
#	Line 12041 | Line 11424 | main ()
11424		int
11425		main ()
11426		{
11427	<	return $ac_func ();
11427	>	return pow ();
11428		;
11429		return 0;
11430		}
#	Line 12064 | Line 11447 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11447		test ! -s conftest.err
11448		} && test -s conftest$ac_exeext &&
11449		$as_test_x conftest$ac_exeext; then
11450	<	eval "$as_ac_var=yes"
11450	>	ac_cv_func_pow=yes
11451		else
11452		echo "$as_me: failed program was:" >&5
11453		sed 's/^/| /' conftest.$ac_ext >&5
11454
11455	<	eval "$as_ac_var=no"
11455	>	ac_cv_func_pow=no
11456		fi
11457
11458		rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11459		conftest$ac_exeext conftest.$ac_ext
11460		fi
11461	<	ac_res=`eval echo '${'$as_ac_var'}'`
11462	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
12080	<	echo "${ECHO_T}$ac_res" >&6; }
12081	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
12082	<	cat >>confdefs.h <<_ACEOF
12083	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
12084	<	_ACEOF
11461	>	{ echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11462	>	echo "${ECHO_T}$ac_cv_func_pow" >&6; }
11463
11464	<	else
11465	<	# strftime is in -lintl on SCO UNIX.
11466	<	{ echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
11467	<	echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6; }
12090	<	if test "${ac_cv_lib_intl_strftime+set}" = set; then
11464	>	if test $ac_cv_func_pow = no; then
11465	>	{ echo "$as_me:$LINENO: checking for pow in -lm" >&5
11466	>	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6; }
11467	>	if test "${ac_cv_lib_m_pow+set}" = set; then
11468		echo $ECHO_N "(cached) $ECHO_C" >&6
11469		else
11470		ac_check_lib_save_LIBS=$LIBS
11471	<	LIBS="-lintl  $LIBS"
11471	>	LIBS="-lm  $LIBS"
11472		cat >conftest.$ac_ext <<_ACEOF
11473		/* confdefs.h.  */
11474		_ACEOF
#	Line 12105 | Line 11482 | extern "C"
11482		#ifdef __cplusplus
11483		extern "C"
11484		#endif
11485	<	char strftime ();
11485	>	char pow ();
11486		#ifdef FC_DUMMY_MAIN
11487		#ifndef FC_DUMMY_MAIN_EQ_F77
11488		#  ifdef __cplusplus
#	Line 12117 | Line 11494 | main ()
11494		int
11495		main ()
11496		{
11497	<	return strftime ();
11497	>	return pow ();
11498		;
11499		return 0;
11500		}
#	Line 12140 | Line 11517 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11517		test ! -s conftest.err
11518		} && test -s conftest$ac_exeext &&
11519		$as_test_x conftest$ac_exeext; then
11520	<	ac_cv_lib_intl_strftime=yes
11520	>	ac_cv_lib_m_pow=yes
11521		else
11522		echo "$as_me: failed program was:" >&5
11523		sed 's/^/| /' conftest.$ac_ext >&5
11524
11525	<	ac_cv_lib_intl_strftime=no
11525	>	ac_cv_lib_m_pow=no
11526		fi
11527
11528		rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11529		conftest$ac_exeext conftest.$ac_ext
11530		LIBS=$ac_check_lib_save_LIBS
11531		fi
11532	<	{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
11533	<	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6; }
11534	<	if test $ac_cv_lib_intl_strftime = yes; then
11535	<	cat >>confdefs.h <<\_ACEOF
11536	<	#define HAVE_STRFTIME 1
11537	<	_ACEOF
11538	<
11539	<	LIBS="-lintl $LIBS"
11540	<	fi
11541	<
11542	<	fi
11543	<	done
11544	<
11545	<	{ echo "$as_me:$LINENO: checking for working strtod" >&5
11546	<	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6; }
11547	<	if test "${ac_cv_func_strtod+set}" = set; then
11548	<	echo $ECHO_N "(cached) $ECHO_C" >&6
11549	<	else
11550	<	if test "$cross_compiling" = yes; then
11551	<	ac_cv_func_strtod=no
11552	<	else
12176	<	cat >conftest.$ac_ext <<_ACEOF
12177	<	/* confdefs.h.  */
12178	<	_ACEOF
12179	<	cat confdefs.h >>conftest.$ac_ext
12180	<	cat >>conftest.$ac_ext <<_ACEOF
12181	<	/* end confdefs.h.  */
12182	<
12183	<	$ac_includes_default
12184	<	#ifndef strtod
12185	<	double strtod ();
12186	<	#endif
12187	<	int
12188	<	main()
12189	<	{
12190	<	{
12191	<	/* Some versions of Linux strtod mis-parse strings with leading '+'.  */
12192	<	char *string = " +69";
12193	<	char *term;
12194	<	double value;
12195	<	value = strtod (string, &term);
12196	<	if (value != 69 || term != (string + 4))
12197	<	return 1;
12198	<	}
12199	<
12200	<	{
12201	<	/* Under Solaris 2.4, strtod returns the wrong value for the
12202	<	terminating character under some conditions.  */
12203	<	char *string = "NaN";
12204	<	char *term;
12205	<	strtod (string, &term);
12206	<	if (term != string && *(term - 1) == 0)
12207	<	return 1;
12208	<	}
12209	<	return 0;
12210	<	}
12211	<
12212	<	_ACEOF
12213	<	rm -f conftest$ac_exeext
12214	<	if { (ac_try="$ac_link"
12215	<	case "(($ac_try" in
12216	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12217	<	*) ac_try_echo=$ac_try;;
12218	<	esac
12219	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12220	<	(eval "$ac_link") 2>&5
12221	<	ac_status=$?
12222	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12223	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
12224	<	{ (case "(($ac_try" in
12225	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12226	<	*) ac_try_echo=$ac_try;;
12227	<	esac
12228	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12229	<	(eval "$ac_try") 2>&5
12230	<	ac_status=$?
12231	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12232	<	(exit $ac_status); }; }; then
12233	<	ac_cv_func_strtod=yes
12234	<	else
12235	<	echo "$as_me: program exited with status $ac_status" >&5
12236	<	echo "$as_me: failed program was:" >&5
12237	<	sed 's/^/| /' conftest.$ac_ext >&5
12238	<
12239	<	( exit $ac_status )
12240	<	ac_cv_func_strtod=no
12241	<	fi
12242	<	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
12243	<	fi
12244	<
12245	<
12246	<	fi
12247	<	{ echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
12248	<	echo "${ECHO_T}$ac_cv_func_strtod" >&6; }
12249	<	if test $ac_cv_func_strtod = no; then
12250	<	case " $LIBOBJS " in
12251	<	*" strtod.$ac_objext "* ) ;;
12252	<	*) LIBOBJS="$LIBOBJS strtod.$ac_objext"
12253	<	;;
12254	<	esac
12255	<
12256	<	{ echo "$as_me:$LINENO: checking for pow" >&5
12257	<	echo $ECHO_N "checking for pow... $ECHO_C" >&6; }
12258	<	if test "${ac_cv_func_pow+set}" = set; then
12259	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12260	<	else
12261	<	cat >conftest.$ac_ext <<_ACEOF
12262	<	/* confdefs.h.  */
12263	<	_ACEOF
12264	<	cat confdefs.h >>conftest.$ac_ext
12265	<	cat >>conftest.$ac_ext <<_ACEOF
12266	<	/* end confdefs.h.  */
12267	<	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
12268	<	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
12269	<	#define pow innocuous_pow
12270	<
12271	<	/* System header to define __stub macros and hopefully few prototypes,
12272	<	which can conflict with char pow (); below.
12273	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12274	<	<limits.h> exists even on freestanding compilers.  */
12275	<
12276	<	#ifdef __STDC__
12277	<	# include <limits.h>
12278	<	#else
12279	<	# include <assert.h>
12280	<	#endif
12281	<
12282	<	#undef pow
12283	<
12284	<	/* Override any GCC internal prototype to avoid an error.
12285	<	Use char because int might match the return type of a GCC
12286	<	builtin and then its argument prototype would still apply.  */
12287	<	#ifdef __cplusplus
12288	<	extern "C"
12289	<	#endif
12290	<	char pow ();
12291	<	/* The GNU C library defines this for functions which it implements
12292	<	to always fail with ENOSYS.  Some functions are actually named
12293	<	something starting with __ and the normal name is an alias.  */
12294	<	#if defined __stub_pow || defined __stub___pow
12295	<	choke me
12296	<	#endif
12297	<
12298	<	#ifdef FC_DUMMY_MAIN
12299	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12300	<	#  ifdef __cplusplus
12301	<	extern "C"
12302	<	#  endif
12303	<	int FC_DUMMY_MAIN() { return 1; }
12304	<	#endif
12305	<	#endif
12306	<	int
12307	<	main ()
12308	<	{
12309	<	return pow ();
12310	<	;
12311	<	return 0;
12312	<	}
12313	<	_ACEOF
12314	<	rm -f conftest.$ac_objext conftest$ac_exeext
12315	<	if { (ac_try="$ac_link"
12316	<	case "(($ac_try" in
12317	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12318	<	*) ac_try_echo=$ac_try;;
12319	<	esac
12320	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12321	<	(eval "$ac_link") 2>conftest.er1
12322	<	ac_status=$?
12323	<	grep -v '^ *+' conftest.er1 >conftest.err
12324	<	rm -f conftest.er1
12325	<	cat conftest.err >&5
12326	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12327	<	(exit $ac_status); } && {
12328	<	test -z "$ac_c_werror_flag" ||
12329	<	test ! -s conftest.err
12330	<	} && test -s conftest$ac_exeext &&
12331	<	$as_test_x conftest$ac_exeext; then
12332	<	ac_cv_func_pow=yes
12333	<	else
12334	<	echo "$as_me: failed program was:" >&5
12335	<	sed 's/^/| /' conftest.$ac_ext >&5
12336	<
12337	<	ac_cv_func_pow=no
12338	<	fi
12339	<
12340	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12341	<	conftest$ac_exeext conftest.$ac_ext
12342	<	fi
12343	<	{ echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
12344	<	echo "${ECHO_T}$ac_cv_func_pow" >&6; }
12345	<
12346	<	if test $ac_cv_func_pow = no; then
12347	<	{ echo "$as_me:$LINENO: checking for pow in -lm" >&5
12348	<	echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6; }
12349	<	if test "${ac_cv_lib_m_pow+set}" = set; then
12350	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12351	<	else
12352	<	ac_check_lib_save_LIBS=$LIBS
12353	<	LIBS="-lm  $LIBS"
12354	<	cat >conftest.$ac_ext <<_ACEOF
12355	<	/* confdefs.h.  */
12356	<	_ACEOF
12357	<	cat confdefs.h >>conftest.$ac_ext
12358	<	cat >>conftest.$ac_ext <<_ACEOF
12359	<	/* end confdefs.h.  */
12360	<
12361	<	/* Override any GCC internal prototype to avoid an error.
12362	<	Use char because int might match the return type of a GCC
12363	<	builtin and then its argument prototype would still apply.  */
12364	<	#ifdef __cplusplus
12365	<	extern "C"
12366	<	#endif
12367	<	char pow ();
12368	<	#ifdef FC_DUMMY_MAIN
12369	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12370	<	#  ifdef __cplusplus
12371	<	extern "C"
12372	<	#  endif
12373	<	int FC_DUMMY_MAIN() { return 1; }
12374	<	#endif
12375	<	#endif
12376	<	int
12377	<	main ()
12378	<	{
12379	<	return pow ();
12380	<	;
12381	<	return 0;
12382	<	}
12383	<	_ACEOF
12384	<	rm -f conftest.$ac_objext conftest$ac_exeext
12385	<	if { (ac_try="$ac_link"
12386	<	case "(($ac_try" in
12387	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12388	<	*) ac_try_echo=$ac_try;;
12389	<	esac
12390	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12391	<	(eval "$ac_link") 2>conftest.er1
12392	<	ac_status=$?
12393	<	grep -v '^ *+' conftest.er1 >conftest.err
12394	<	rm -f conftest.er1
12395	<	cat conftest.err >&5
12396	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12397	<	(exit $ac_status); } && {
12398	<	test -z "$ac_c_werror_flag" ||
12399	<	test ! -s conftest.err
12400	<	} && test -s conftest$ac_exeext &&
12401	<	$as_test_x conftest$ac_exeext; then
12402	<	ac_cv_lib_m_pow=yes
12403	<	else
12404	<	echo "$as_me: failed program was:" >&5
12405	<	sed 's/^/| /' conftest.$ac_ext >&5
12406	<
12407	<	ac_cv_lib_m_pow=no
12408	<	fi
12409	<
12410	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12411	<	conftest$ac_exeext conftest.$ac_ext
12412	<	LIBS=$ac_check_lib_save_LIBS
12413	<	fi
12414	<	{ echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
12415	<	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6; }
12416	<	if test $ac_cv_lib_m_pow = yes; then
12417	<	POW_LIB=-lm
12418	<	else
12419	<	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
12420	<	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
12421	<	fi
12422	<
12423	<	fi
12424	<
12425	<	fi
12426	<
12427	<
12428	<
12429	<
12430	<
12431	<
12432	<
12433	<
12434	<
12435	<
12436	<
12437	<
12438	<
12439	<
12440	<
12441	<
12442	<
12443	<
12444	<
12445	<
12446	<
12447	<
12448	<
12449	<
12450	<
12451	<
12452	<
12453	<
12454	<	for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
12455	<	do
12456	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12457	<	{ echo "$as_me:$LINENO: checking for $ac_func" >&5
12458	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
12459	<	if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
12460	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12461	<	else
12462	<	cat >conftest.$ac_ext <<_ACEOF
12463	<	/* confdefs.h.  */
12464	<	_ACEOF
12465	<	cat confdefs.h >>conftest.$ac_ext
12466	<	cat >>conftest.$ac_ext <<_ACEOF
12467	<	/* end confdefs.h.  */
12468	<	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
12469	<	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
12470	<	#define $ac_func innocuous_$ac_func
12471	<
12472	<	/* System header to define __stub macros and hopefully few prototypes,
12473	<	which can conflict with char $ac_func (); below.
12474	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12475	<	<limits.h> exists even on freestanding compilers.  */
12476	<
12477	<	#ifdef __STDC__
12478	<	# include <limits.h>
12479	<	#else
12480	<	# include <assert.h>
12481	<	#endif
12482	<
12483	<	#undef $ac_func
12484	<
12485	<	/* Override any GCC internal prototype to avoid an error.
12486	<	Use char because int might match the return type of a GCC
12487	<	builtin and then its argument prototype would still apply.  */
12488	<	#ifdef __cplusplus
12489	<	extern "C"
12490	<	#endif
12491	<	char $ac_func ();
12492	<	/* The GNU C library defines this for functions which it implements
12493	<	to always fail with ENOSYS.  Some functions are actually named
12494	<	something starting with __ and the normal name is an alias.  */
12495	<	#if defined __stub_$ac_func || defined __stub___$ac_func
12496	<	choke me
12497	<	#endif
12498	<
12499	<	#ifdef FC_DUMMY_MAIN
12500	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12501	<	#  ifdef __cplusplus
12502	<	extern "C"
12503	<	#  endif
12504	<	int FC_DUMMY_MAIN() { return 1; }
12505	<	#endif
12506	<	#endif
12507	<	int
12508	<	main ()
12509	<	{
12510	<	return $ac_func ();
12511	<	;
12512	<	return 0;
12513	<	}
12514	<	_ACEOF
12515	<	rm -f conftest.$ac_objext conftest$ac_exeext
12516	<	if { (ac_try="$ac_link"
12517	<	case "(($ac_try" in
12518	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12519	<	*) ac_try_echo=$ac_try;;
12520	<	esac
12521	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12522	<	(eval "$ac_link") 2>conftest.er1
12523	<	ac_status=$?
12524	<	grep -v '^ *+' conftest.er1 >conftest.err
12525	<	rm -f conftest.er1
12526	<	cat conftest.err >&5
12527	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12528	<	(exit $ac_status); } && {
12529	<	test -z "$ac_c_werror_flag" ||
12530	<	test ! -s conftest.err
12531	<	} && test -s conftest$ac_exeext &&
12532	<	$as_test_x conftest$ac_exeext; then
12533	<	eval "$as_ac_var=yes"
12534	<	else
12535	<	echo "$as_me: failed program was:" >&5
12536	<	sed 's/^/| /' conftest.$ac_ext >&5
12537	<
12538	<	eval "$as_ac_var=no"
12539	<	fi
12540	<
12541	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12542	<	conftest$ac_exeext conftest.$ac_ext
12543	<	fi
12544	<	ac_res=`eval echo '${'$as_ac_var'}'`
12545	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
12546	<	echo "${ECHO_T}$ac_res" >&6; }
12547	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
12548	<	cat >>confdefs.h <<_ACEOF
12549	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
12550	<	_ACEOF
12551	<
12552	<	fi
12553	<	done
12554	<
12555	<
12556	<	# special check for _system_configuration because AIX <4.3.2 do not
12557	<	# contain the `physmem' member.
12558	<	{ echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
12559	<	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6; }
12560	<	cat >conftest.$ac_ext <<_ACEOF
12561	<	/* confdefs.h.  */
12562	<	_ACEOF
12563	<	cat confdefs.h >>conftest.$ac_ext
12564	<	cat >>conftest.$ac_ext <<_ACEOF
12565	<	/* end confdefs.h.  */
12566	<	#include <sys/systemcfg.h>
12567	<	#ifdef FC_DUMMY_MAIN
12568	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12569	<	#  ifdef __cplusplus
12570	<	extern "C"
12571	<	#  endif
12572	<	int FC_DUMMY_MAIN() { return 1; }
12573	<	#endif
12574	<	#endif
12575	<	int
12576	<	main ()
12577	<	{
12578	<	double x = _system_configuration.physmem;
12579	<	;
12580	<	return 0;
12581	<	}
12582	<	_ACEOF
12583	<	rm -f conftest.$ac_objext
12584	<	if { (ac_try="$ac_compile"
12585	<	case "(($ac_try" in
12586	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12587	<	*) ac_try_echo=$ac_try;;
12588	<	esac
12589	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12590	<	(eval "$ac_compile") 2>conftest.er1
12591	<	ac_status=$?
12592	<	grep -v '^ *+' conftest.er1 >conftest.err
12593	<	rm -f conftest.er1
12594	<	cat conftest.err >&5
12595	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12596	<	(exit $ac_status); } && {
12597	<	test -z "$ac_c_werror_flag" ||
12598	<	test ! -s conftest.err
12599	<	} && test -s conftest.$ac_objext; then
12600	<	{ echo "$as_me:$LINENO: result: yes" >&5
12601	<	echo "${ECHO_T}yes" >&6; }
12602	<
12603	<	cat >>confdefs.h <<\_ACEOF
12604	<	#define HAVE__SYSTEM_CONFIGURATION 1
12605	<	_ACEOF
12606	<
12607	<	else
12608	<	echo "$as_me: failed program was:" >&5
12609	<	sed 's/^/| /' conftest.$ac_ext >&5
12610	<
12611	<	{ echo "$as_me:$LINENO: result: no" >&5
12612	<	echo "${ECHO_T}no" >&6; }
12613	<	fi
12614	<
12615	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12616	<
12617	<	# clean out junk possibly left behind by a previous configuration
12618	<	rm -f src/getopt.h
12619	<	# Check for getopt_long support
12620	<
12621	<	for ac_header in getopt.h
12622	<	do
12623	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
12624	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12625	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
12626	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
12627	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12628	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12629	<	fi
12630	<	ac_res=`eval echo '${'$as_ac_Header'}'`
12631	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
12632	<	echo "${ECHO_T}$ac_res" >&6; }
12633	<	else
12634	<	# Is the header compilable?
12635	<	{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
12636	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
12637	<	cat >conftest.$ac_ext <<_ACEOF
12638	<	/* confdefs.h.  */
12639	<	_ACEOF
12640	<	cat confdefs.h >>conftest.$ac_ext
12641	<	cat >>conftest.$ac_ext <<_ACEOF
12642	<	/* end confdefs.h.  */
12643	<	$ac_includes_default
12644	<	#include <$ac_header>
12645	<	_ACEOF
12646	<	rm -f conftest.$ac_objext
12647	<	if { (ac_try="$ac_compile"
12648	<	case "(($ac_try" in
12649	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12650	<	*) ac_try_echo=$ac_try;;
12651	<	esac
12652	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12653	<	(eval "$ac_compile") 2>conftest.er1
12654	<	ac_status=$?
12655	<	grep -v '^ *+' conftest.er1 >conftest.err
12656	<	rm -f conftest.er1
12657	<	cat conftest.err >&5
12658	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12659	<	(exit $ac_status); } && {
12660	<	test -z "$ac_c_werror_flag" ||
12661	<	test ! -s conftest.err
12662	<	} && test -s conftest.$ac_objext; then
12663	<	ac_header_compiler=yes
12664	<	else
12665	<	echo "$as_me: failed program was:" >&5
12666	<	sed 's/^/| /' conftest.$ac_ext >&5
12667	<
12668	<	ac_header_compiler=no
12669	<	fi
12670	<
12671	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12672	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12673	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
12674	<
12675	<	# Is the header present?
12676	<	{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
12677	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
12678	<	cat >conftest.$ac_ext <<_ACEOF
12679	<	/* confdefs.h.  */
12680	<	_ACEOF
12681	<	cat confdefs.h >>conftest.$ac_ext
12682	<	cat >>conftest.$ac_ext <<_ACEOF
12683	<	/* end confdefs.h.  */
12684	<	#include <$ac_header>
12685	<	_ACEOF
12686	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
12687	<	case "(($ac_try" in
12688	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12689	<	*) ac_try_echo=$ac_try;;
12690	<	esac
12691	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12692	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12693	<	ac_status=$?
12694	<	grep -v '^ *+' conftest.er1 >conftest.err
12695	<	rm -f conftest.er1
12696	<	cat conftest.err >&5
12697	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12698	<	(exit $ac_status); } >/dev/null && {
12699	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12700	<	test ! -s conftest.err
12701	<	}; then
12702	<	ac_header_preproc=yes
12703	<	else
12704	<	echo "$as_me: failed program was:" >&5
12705	<	sed 's/^/| /' conftest.$ac_ext >&5
12706	<
12707	<	ac_header_preproc=no
12708	<	fi
12709	<
12710	<	rm -f conftest.err conftest.$ac_ext
12711	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12712	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
12713	<
12714	<	# So?  What about this header?
12715	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12716	<	yes:no: )
12717	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12718	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
12719	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
12720	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
12721	<	ac_header_preproc=yes
12722	<	;;
12723	<	no:yes:* )
12724	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
12725	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
12726	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
12727	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
12728	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
12729	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
12730	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
12731	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
12732	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12733	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12734	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
12735	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
12736	<	( cat <<\_ASBOX
12737	<	## ------------------------------ ##
12738	<	## Report this to gezelter@nd.edu ##
12739	<	## ------------------------------ ##
12740	<	_ASBOX
12741	<	) | sed "s/^/$as_me: WARNING:     /" >&2
12742	<	;;
12743	<	esac
12744	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
12745	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
12746	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12747	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12748	<	else
12749	<	eval "$as_ac_Header=\$ac_header_preproc"
12750	<	fi
12751	<	ac_res=`eval echo '${'$as_ac_Header'}'`
12752	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
12753	<	echo "${ECHO_T}$ac_res" >&6; }
12754	<
12755	<	fi
12756	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
12757	<	cat >>confdefs.h <<_ACEOF
12758	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
12759	<	_ACEOF
12760	<
12761	<	fi
12762	<
12763	<	done
12764	<
12765	<
12766	<	for ac_func in getopt_long
12767	<	do
12768	<	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12769	<	{ echo "$as_me:$LINENO: checking for $ac_func" >&5
12770	<	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
12771	<	if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
12772	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12773	<	else
12774	<	cat >conftest.$ac_ext <<_ACEOF
12775	<	/* confdefs.h.  */
12776	<	_ACEOF
12777	<	cat confdefs.h >>conftest.$ac_ext
12778	<	cat >>conftest.$ac_ext <<_ACEOF
12779	<	/* end confdefs.h.  */
12780	<	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
12781	<	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
12782	<	#define $ac_func innocuous_$ac_func
12783	<
12784	<	/* System header to define __stub macros and hopefully few prototypes,
12785	<	which can conflict with char $ac_func (); below.
12786	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12787	<	<limits.h> exists even on freestanding compilers.  */
12788	<
12789	<	#ifdef __STDC__
12790	<	# include <limits.h>
12791	<	#else
12792	<	# include <assert.h>
12793	<	#endif
12794	<
12795	<	#undef $ac_func
12796	<
12797	<	/* Override any GCC internal prototype to avoid an error.
12798	<	Use char because int might match the return type of a GCC
12799	<	builtin and then its argument prototype would still apply.  */
12800	<	#ifdef __cplusplus
12801	<	extern "C"
12802	<	#endif
12803	<	char $ac_func ();
12804	<	/* The GNU C library defines this for functions which it implements
12805	<	to always fail with ENOSYS.  Some functions are actually named
12806	<	something starting with __ and the normal name is an alias.  */
12807	<	#if defined __stub_$ac_func || defined __stub___$ac_func
12808	<	choke me
12809	<	#endif
12810	<
12811	<	#ifdef FC_DUMMY_MAIN
12812	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12813	<	#  ifdef __cplusplus
12814	<	extern "C"
12815	<	#  endif
12816	<	int FC_DUMMY_MAIN() { return 1; }
12817	<	#endif
12818	<	#endif
12819	<	int
12820	<	main ()
12821	<	{
12822	<	return $ac_func ();
12823	<	;
12824	<	return 0;
12825	<	}
12826	<	_ACEOF
12827	<	rm -f conftest.$ac_objext conftest$ac_exeext
12828	<	if { (ac_try="$ac_link"
12829	<	case "(($ac_try" in
12830	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12831	<	*) ac_try_echo=$ac_try;;
12832	<	esac
12833	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12834	<	(eval "$ac_link") 2>conftest.er1
12835	<	ac_status=$?
12836	<	grep -v '^ *+' conftest.er1 >conftest.err
12837	<	rm -f conftest.er1
12838	<	cat conftest.err >&5
12839	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12840	<	(exit $ac_status); } && {
12841	<	test -z "$ac_c_werror_flag" ||
12842	<	test ! -s conftest.err
12843	<	} && test -s conftest$ac_exeext &&
12844	<	$as_test_x conftest$ac_exeext; then
12845	<	eval "$as_ac_var=yes"
12846	<	else
12847	<	echo "$as_me: failed program was:" >&5
12848	<	sed 's/^/| /' conftest.$ac_ext >&5
12849	<
12850	<	eval "$as_ac_var=no"
12851	<	fi
12852	<
12853	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12854	<	conftest$ac_exeext conftest.$ac_ext
12855	<	fi
12856	<	ac_res=`eval echo '${'$as_ac_var'}'`
12857	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
12858	<	echo "${ECHO_T}$ac_res" >&6; }
12859	<	if test `eval echo '${'$as_ac_var'}'` = yes; then
12860	<	cat >>confdefs.h <<_ACEOF
12861	<	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
12862	<	_ACEOF
12863	<
12864	<	else
12865	<	# FreeBSD has a gnugetopt library for this
12866	<	{ echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
12867	<	echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6; }
12868	<	if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
12869	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12870	<	else
12871	<	ac_check_lib_save_LIBS=$LIBS
12872	<	LIBS="-lgnugetopt  $LIBS"
12873	<	cat >conftest.$ac_ext <<_ACEOF
12874	<	/* confdefs.h.  */
12875	<	_ACEOF
12876	<	cat confdefs.h >>conftest.$ac_ext
12877	<	cat >>conftest.$ac_ext <<_ACEOF
12878	<	/* end confdefs.h.  */
12879	<
12880	<	/* Override any GCC internal prototype to avoid an error.
12881	<	Use char because int might match the return type of a GCC
12882	<	builtin and then its argument prototype would still apply.  */
12883	<	#ifdef __cplusplus
12884	<	extern "C"
12885	<	#endif
12886	<	char getopt_long ();
12887	<	#ifdef FC_DUMMY_MAIN
12888	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12889	<	#  ifdef __cplusplus
12890	<	extern "C"
12891	<	#  endif
12892	<	int FC_DUMMY_MAIN() { return 1; }
12893	<	#endif
12894	<	#endif
12895	<	int
12896	<	main ()
12897	<	{
12898	<	return getopt_long ();
12899	<	;
12900	<	return 0;
12901	<	}
12902	<	_ACEOF
12903	<	rm -f conftest.$ac_objext conftest$ac_exeext
12904	<	if { (ac_try="$ac_link"
12905	<	case "(($ac_try" in
12906	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12907	<	*) ac_try_echo=$ac_try;;
12908	<	esac
12909	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12910	<	(eval "$ac_link") 2>conftest.er1
12911	<	ac_status=$?
12912	<	grep -v '^ *+' conftest.er1 >conftest.err
12913	<	rm -f conftest.er1
12914	<	cat conftest.err >&5
12915	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
12916	<	(exit $ac_status); } && {
12917	<	test -z "$ac_c_werror_flag" ||
12918	<	test ! -s conftest.err
12919	<	} && test -s conftest$ac_exeext &&
12920	<	$as_test_x conftest$ac_exeext; then
12921	<	ac_cv_lib_gnugetopt_getopt_long=yes
12922	<	else
12923	<	echo "$as_me: failed program was:" >&5
12924	<	sed 's/^/| /' conftest.$ac_ext >&5
12925	<
12926	<	ac_cv_lib_gnugetopt_getopt_long=no
12927	<	fi
12928	<
12929	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12930	<	conftest$ac_exeext conftest.$ac_ext
12931	<	LIBS=$ac_check_lib_save_LIBS
12932	<	fi
12933	<	{ echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12934	<	echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6; }
12935	<	if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12936	<	cat >>confdefs.h <<\_ACEOF
12937	<	#define HAVE_GETOPT_LONG 1
12938	<	_ACEOF
12939	<
12940	<	else
12941	<	# use the GNU replacement
12942	<	case " $LIBOBJS " in
12943	<	*" getopt.$ac_objext "* ) ;;
12944	<	*) LIBOBJS="$LIBOBJS getopt.$ac_objext"
12945	<	;;
12946	<	esac
12947	<
12948	<	case " $LIBOBJS " in
12949	<	*" getopt1.$ac_objext "* ) ;;
12950	<	*) LIBOBJS="$LIBOBJS getopt1.$ac_objext"
12951	<	;;
12952	<	esac
12953	<
12954	<	ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
12955	<
12956	<	fi
12957	<
12958	<	fi
12959	<	done
12960	<
12961	<
12962	<	ac_ext=cpp
12963	<	ac_cpp='$CXXCPP $CPPFLAGS'
12964	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12965	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12966	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12967	<
12968	<	{ echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
12969	<	echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6; }
12970	<	if test "${ac_cv_cxx_namespaces+set}" = set; then
12971	<	echo $ECHO_N "(cached) $ECHO_C" >&6
12972	<	else
12973	<
12974	<	ac_ext=cpp
12975	<	ac_cpp='$CXXCPP $CPPFLAGS'
12976	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12977	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12978	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12979	<
12980	<	cat >conftest.$ac_ext <<_ACEOF
12981	<	/* confdefs.h.  */
12982	<	_ACEOF
12983	<	cat confdefs.h >>conftest.$ac_ext
12984	<	cat >>conftest.$ac_ext <<_ACEOF
12985	<	/* end confdefs.h.  */
12986	<	namespace Outer { namespace Inner { int i = 0; }}
12987	<	#ifdef FC_DUMMY_MAIN
12988	<	#ifndef FC_DUMMY_MAIN_EQ_F77
12989	<	#  ifdef __cplusplus
12990	<	extern "C"
12991	<	#  endif
12992	<	int FC_DUMMY_MAIN() { return 1; }
12993	<	#endif
12994	<	#endif
12995	<	int
12996	<	main ()
12997	<	{
12998	<	using namespace Outer::Inner; return i;
12999	<	;
13000	<	return 0;
13001	<	}
13002	<	_ACEOF
13003	<	rm -f conftest.$ac_objext
13004	<	if { (ac_try="$ac_compile"
13005	<	case "(($ac_try" in
13006	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13007	<	*) ac_try_echo=$ac_try;;
13008	<	esac
13009	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13010	<	(eval "$ac_compile") 2>conftest.er1
13011	<	ac_status=$?
13012	<	grep -v '^ *+' conftest.er1 >conftest.err
13013	<	rm -f conftest.er1
13014	<	cat conftest.err >&5
13015	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13016	<	(exit $ac_status); } && {
13017	<	test -z "$ac_cxx_werror_flag" ||
13018	<	test ! -s conftest.err
13019	<	} && test -s conftest.$ac_objext; then
13020	<	ac_cv_cxx_namespaces=yes
13021	<	else
13022	<	echo "$as_me: failed program was:" >&5
13023	<	sed 's/^/| /' conftest.$ac_ext >&5
13024	<
13025	<	ac_cv_cxx_namespaces=no
13026	<	fi
13027	<
13028	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13029	<	ac_ext=cpp
13030	<	ac_cpp='$CXXCPP $CPPFLAGS'
13031	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13032	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13033	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13034	<
13035	<
13036	<	fi
13037	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
13038	<	echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6; }
13039	<	if test "$ac_cv_cxx_namespaces" = yes; then
13040	<
13041	<	cat >>confdefs.h <<\_ACEOF
13042	<	#define HAVE_NAMESPACES
13043	<	_ACEOF
13044	<
13045	<	fi
13046	<
13047	<	{ echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
13048	<	echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6; }
13049	<	if test "${ac_cv_cxx_have_stl+set}" = set; then
13050	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13051	<	else
13052	<
13053	<
13054	<	ac_ext=cpp
13055	<	ac_cpp='$CXXCPP $CPPFLAGS'
13056	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13057	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13058	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13059	<
13060	<	cat >conftest.$ac_ext <<_ACEOF
13061	<	/* confdefs.h.  */
13062	<	_ACEOF
13063	<	cat confdefs.h >>conftest.$ac_ext
13064	<	cat >>conftest.$ac_ext <<_ACEOF
13065	<	/* end confdefs.h.  */
13066	<	#include <list>
13067	<	#include <deque>
13068	<	#ifdef HAVE_NAMESPACES
13069	<	using namespace std;
13070	<	#endif
13071	<	#ifdef FC_DUMMY_MAIN
13072	<	#ifndef FC_DUMMY_MAIN_EQ_F77
13073	<	#  ifdef __cplusplus
13074	<	extern "C"
13075	<	#  endif
13076	<	int FC_DUMMY_MAIN() { return 1; }
13077	<	#endif
13078	<	#endif
13079	<	int
13080	<	main ()
13081	<	{
13082	<	list<int> x; x.push_back(5);
13083	<	list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
13084	<	;
13085	<	return 0;
13086	<	}
13087	<	_ACEOF
13088	<	rm -f conftest.$ac_objext
13089	<	if { (ac_try="$ac_compile"
13090	<	case "(($ac_try" in
13091	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13092	<	*) ac_try_echo=$ac_try;;
13093	<	esac
13094	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13095	<	(eval "$ac_compile") 2>conftest.er1
13096	<	ac_status=$?
13097	<	grep -v '^ *+' conftest.er1 >conftest.err
13098	<	rm -f conftest.er1
13099	<	cat conftest.err >&5
13100	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13101	<	(exit $ac_status); } && {
13102	<	test -z "$ac_cxx_werror_flag" ||
13103	<	test ! -s conftest.err
13104	<	} && test -s conftest.$ac_objext; then
13105	<	ac_cv_cxx_have_stl=yes
13106	<	else
13107	<	echo "$as_me: failed program was:" >&5
13108	<	sed 's/^/| /' conftest.$ac_ext >&5
13109	<
13110	<	ac_cv_cxx_have_stl=no
13111	<	fi
13112	<
13113	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13114	<	ac_ext=cpp
13115	<	ac_cpp='$CXXCPP $CPPFLAGS'
13116	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13117	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13118	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13119	<
13120	<
13121	<	fi
13122	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
13123	<	echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6; }
13124	<	if test "$ac_cv_cxx_have_stl" = yes; then
13125	<
13126	<	cat >>confdefs.h <<\_ACEOF
13127	<	#define HAVE_STL
13128	<	_ACEOF
13129	<
13130	<	fi
13131	<
13132	<
13133	<
13134	<	if test "${ac_cv_header_iostream+set}" = set; then
13135	<	{ echo "$as_me:$LINENO: checking for iostream" >&5
13136	<	echo $ECHO_N "checking for iostream... $ECHO_C" >&6; }
13137	<	if test "${ac_cv_header_iostream+set}" = set; then
13138	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13139	<	fi
13140	<	{ echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
13141	<	echo "${ECHO_T}$ac_cv_header_iostream" >&6; }
13142	<	else
13143	<	# Is the header compilable?
13144	<	{ echo "$as_me:$LINENO: checking iostream usability" >&5
13145	<	echo $ECHO_N "checking iostream usability... $ECHO_C" >&6; }
13146	<	cat >conftest.$ac_ext <<_ACEOF
13147	<	/* confdefs.h.  */
13148	<	_ACEOF
13149	<	cat confdefs.h >>conftest.$ac_ext
13150	<	cat >>conftest.$ac_ext <<_ACEOF
13151	<	/* end confdefs.h.  */
13152	<	$ac_includes_default
13153	<	#include <iostream>
13154	<	_ACEOF
13155	<	rm -f conftest.$ac_objext
13156	<	if { (ac_try="$ac_compile"
13157	<	case "(($ac_try" in
13158	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13159	<	*) ac_try_echo=$ac_try;;
13160	<	esac
13161	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13162	<	(eval "$ac_compile") 2>conftest.er1
13163	<	ac_status=$?
13164	<	grep -v '^ *+' conftest.er1 >conftest.err
13165	<	rm -f conftest.er1
13166	<	cat conftest.err >&5
13167	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13168	<	(exit $ac_status); } && {
13169	<	test -z "$ac_cxx_werror_flag" ||
13170	<	test ! -s conftest.err
13171	<	} && test -s conftest.$ac_objext; then
13172	<	ac_header_compiler=yes
13173	<	else
13174	<	echo "$as_me: failed program was:" >&5
13175	<	sed 's/^/| /' conftest.$ac_ext >&5
13176	<
13177	<	ac_header_compiler=no
13178	<	fi
13179	<
13180	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13181	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13182	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
13183	<
13184	<	# Is the header present?
13185	<	{ echo "$as_me:$LINENO: checking iostream presence" >&5
13186	<	echo $ECHO_N "checking iostream presence... $ECHO_C" >&6; }
13187	<	cat >conftest.$ac_ext <<_ACEOF
13188	<	/* confdefs.h.  */
13189	<	_ACEOF
13190	<	cat confdefs.h >>conftest.$ac_ext
13191	<	cat >>conftest.$ac_ext <<_ACEOF
13192	<	/* end confdefs.h.  */
13193	<	#include <iostream>
13194	<	_ACEOF
13195	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
13196	<	case "(($ac_try" in
13197	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13198	<	*) ac_try_echo=$ac_try;;
13199	<	esac
13200	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13201	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
13202	<	ac_status=$?
13203	<	grep -v '^ *+' conftest.er1 >conftest.err
13204	<	rm -f conftest.er1
13205	<	cat conftest.err >&5
13206	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13207	<	(exit $ac_status); } >/dev/null && {
13208	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
13209	<	test ! -s conftest.err
13210	<	}; then
13211	<	ac_header_preproc=yes
13212	<	else
13213	<	echo "$as_me: failed program was:" >&5
13214	<	sed 's/^/| /' conftest.$ac_ext >&5
13215	<
13216	<	ac_header_preproc=no
13217	<	fi
13218	<
13219	<	rm -f conftest.err conftest.$ac_ext
13220	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13221	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
13222	<
13223	<	# So?  What about this header?
13224	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13225	<	yes:no: )
13226	<	{ echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
13227	<	echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
13228	<	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
13229	<	echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
13230	<	ac_header_preproc=yes
13231	<	;;
13232	<	no:yes:* )
13233	<	{ echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
13234	<	echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
13235	<	{ echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
13236	<	echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
13237	<	{ echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
13238	<	echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
13239	<	{ echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
13240	<	echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
13241	<	{ echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
13242	<	echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
13243	<	{ echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
13244	<	echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
13245	<	( cat <<\_ASBOX
13246	<	## ------------------------------ ##
13247	<	## Report this to gezelter@nd.edu ##
13248	<	## ------------------------------ ##
13249	<	_ASBOX
13250	<	) | sed "s/^/$as_me: WARNING:     /" >&2
13251	<	;;
13252	<	esac
13253	<	{ echo "$as_me:$LINENO: checking for iostream" >&5
13254	<	echo $ECHO_N "checking for iostream... $ECHO_C" >&6; }
13255	<	if test "${ac_cv_header_iostream+set}" = set; then
13256	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13257	<	else
13258	<	ac_cv_header_iostream=$ac_header_preproc
13259	<	fi
13260	<	{ echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
13261	<	echo "${ECHO_T}$ac_cv_header_iostream" >&6; }
13262	<
13263	<	fi
13264	<	if test $ac_cv_header_iostream = yes; then
13265	<
13266	<
13267	<	cat >>confdefs.h <<\_ACEOF
13268	<	#define HAVE_IOSTREAM 1
13269	<	_ACEOF
13270	<
13271	<
13272	<	else
13273	<
13274	<
13275	<	for ac_header in iostream.h
13276	<	do
13277	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
13278	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13279	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13280	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13281	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13282	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13283	<	fi
13284	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13285	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13286	<	echo "${ECHO_T}$ac_res" >&6; }
13287	<	else
13288	<	# Is the header compilable?
13289	<	{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
13290	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
13291	<	cat >conftest.$ac_ext <<_ACEOF
13292	<	/* confdefs.h.  */
13293	<	_ACEOF
13294	<	cat confdefs.h >>conftest.$ac_ext
13295	<	cat >>conftest.$ac_ext <<_ACEOF
13296	<	/* end confdefs.h.  */
13297	<	$ac_includes_default
13298	<	#include <$ac_header>
13299	<	_ACEOF
13300	<	rm -f conftest.$ac_objext
13301	<	if { (ac_try="$ac_compile"
13302	<	case "(($ac_try" in
13303	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13304	<	*) ac_try_echo=$ac_try;;
13305	<	esac
13306	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13307	<	(eval "$ac_compile") 2>conftest.er1
13308	<	ac_status=$?
13309	<	grep -v '^ *+' conftest.er1 >conftest.err
13310	<	rm -f conftest.er1
13311	<	cat conftest.err >&5
13312	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13313	<	(exit $ac_status); } && {
13314	<	test -z "$ac_cxx_werror_flag" ||
13315	<	test ! -s conftest.err
13316	<	} && test -s conftest.$ac_objext; then
13317	<	ac_header_compiler=yes
13318	<	else
13319	<	echo "$as_me: failed program was:" >&5
13320	<	sed 's/^/| /' conftest.$ac_ext >&5
13321	<
13322	<	ac_header_compiler=no
13323	<	fi
13324	<
13325	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13326	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13327	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
13328	<
13329	<	# Is the header present?
13330	<	{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
13331	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
13332	<	cat >conftest.$ac_ext <<_ACEOF
13333	<	/* confdefs.h.  */
13334	<	_ACEOF
13335	<	cat confdefs.h >>conftest.$ac_ext
13336	<	cat >>conftest.$ac_ext <<_ACEOF
13337	<	/* end confdefs.h.  */
13338	<	#include <$ac_header>
13339	<	_ACEOF
13340	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
13341	<	case "(($ac_try" in
13342	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13343	<	*) ac_try_echo=$ac_try;;
13344	<	esac
13345	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13346	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
13347	<	ac_status=$?
13348	<	grep -v '^ *+' conftest.er1 >conftest.err
13349	<	rm -f conftest.er1
13350	<	cat conftest.err >&5
13351	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13352	<	(exit $ac_status); } >/dev/null && {
13353	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
13354	<	test ! -s conftest.err
13355	<	}; then
13356	<	ac_header_preproc=yes
13357	<	else
13358	<	echo "$as_me: failed program was:" >&5
13359	<	sed 's/^/| /' conftest.$ac_ext >&5
13360	<
13361	<	ac_header_preproc=no
13362	<	fi
13363	<
13364	<	rm -f conftest.err conftest.$ac_ext
13365	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13366	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
13367	<
13368	<	# So?  What about this header?
13369	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13370	<	yes:no: )
13371	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
13372	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
13373	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
13374	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
13375	<	ac_header_preproc=yes
13376	<	;;
13377	<	no:yes:* )
13378	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
13379	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
13380	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
13381	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
13382	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
13383	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
13384	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
13385	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
13386	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
13387	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
13388	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
13389	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
13390	<	( cat <<\_ASBOX
13391	<	## ------------------------------ ##
13392	<	## Report this to gezelter@nd.edu ##
13393	<	## ------------------------------ ##
13394	<	_ASBOX
13395	<	) | sed "s/^/$as_me: WARNING:     /" >&2
13396	<	;;
13397	<	esac
13398	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13399	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13400	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13401	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13402	<	else
13403	<	eval "$as_ac_Header=\$ac_header_preproc"
13404	<	fi
13405	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13406	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13407	<	echo "${ECHO_T}$ac_res" >&6; }
13408	<
13409	<	fi
13410	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
13411	<	cat >>confdefs.h <<_ACEOF
13412	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
13413	<	_ACEOF
13414	<
13415	<	fi
13416	<
13417	<	done
13418	<
13419	<
13420	<	fi
13421	<
13422	<
13423	<
13424	<
13425	<	if test "${ac_cv_header_iomanip+set}" = set; then
13426	<	{ echo "$as_me:$LINENO: checking for iomanip" >&5
13427	<	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6; }
13428	<	if test "${ac_cv_header_iomanip+set}" = set; then
13429	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13430	<	fi
13431	<	{ echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
13432	<	echo "${ECHO_T}$ac_cv_header_iomanip" >&6; }
13433	<	else
13434	<	# Is the header compilable?
13435	<	{ echo "$as_me:$LINENO: checking iomanip usability" >&5
13436	<	echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6; }
13437	<	cat >conftest.$ac_ext <<_ACEOF
13438	<	/* confdefs.h.  */
13439	<	_ACEOF
13440	<	cat confdefs.h >>conftest.$ac_ext
13441	<	cat >>conftest.$ac_ext <<_ACEOF
13442	<	/* end confdefs.h.  */
13443	<	$ac_includes_default
13444	<	#include <iomanip>
13445	<	_ACEOF
13446	<	rm -f conftest.$ac_objext
13447	<	if { (ac_try="$ac_compile"
13448	<	case "(($ac_try" in
13449	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13450	<	*) ac_try_echo=$ac_try;;
13451	<	esac
13452	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13453	<	(eval "$ac_compile") 2>conftest.er1
13454	<	ac_status=$?
13455	<	grep -v '^ *+' conftest.er1 >conftest.err
13456	<	rm -f conftest.er1
13457	<	cat conftest.err >&5
13458	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13459	<	(exit $ac_status); } && {
13460	<	test -z "$ac_cxx_werror_flag" ||
13461	<	test ! -s conftest.err
13462	<	} && test -s conftest.$ac_objext; then
13463	<	ac_header_compiler=yes
13464	<	else
13465	<	echo "$as_me: failed program was:" >&5
13466	<	sed 's/^/| /' conftest.$ac_ext >&5
13467	<
13468	<	ac_header_compiler=no
13469	<	fi
13470	<
13471	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13472	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13473	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
13474	<
13475	<	# Is the header present?
13476	<	{ echo "$as_me:$LINENO: checking iomanip presence" >&5
13477	<	echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6; }
13478	<	cat >conftest.$ac_ext <<_ACEOF
13479	<	/* confdefs.h.  */
13480	<	_ACEOF
13481	<	cat confdefs.h >>conftest.$ac_ext
13482	<	cat >>conftest.$ac_ext <<_ACEOF
13483	<	/* end confdefs.h.  */
13484	<	#include <iomanip>
13485	<	_ACEOF
13486	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
13487	<	case "(($ac_try" in
13488	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13489	<	*) ac_try_echo=$ac_try;;
13490	<	esac
13491	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13492	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
13493	<	ac_status=$?
13494	<	grep -v '^ *+' conftest.er1 >conftest.err
13495	<	rm -f conftest.er1
13496	<	cat conftest.err >&5
13497	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13498	<	(exit $ac_status); } >/dev/null && {
13499	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
13500	<	test ! -s conftest.err
13501	<	}; then
13502	<	ac_header_preproc=yes
13503	<	else
13504	<	echo "$as_me: failed program was:" >&5
13505	<	sed 's/^/| /' conftest.$ac_ext >&5
13506	<
13507	<	ac_header_preproc=no
13508	<	fi
13509	<
13510	<	rm -f conftest.err conftest.$ac_ext
13511	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13512	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
13513	<
13514	<	# So?  What about this header?
13515	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13516	<	yes:no: )
13517	<	{ echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
13518	<	echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
13519	<	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
13520	<	echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
13521	<	ac_header_preproc=yes
13522	<	;;
13523	<	no:yes:* )
13524	<	{ echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
13525	<	echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
13526	<	{ echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
13527	<	echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
13528	<	{ echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
13529	<	echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
13530	<	{ echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
13531	<	echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
13532	<	{ echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
13533	<	echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
13534	<	{ echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
13535	<	echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
13536	<	( cat <<\_ASBOX
13537	<	## ------------------------------ ##
13538	<	## Report this to gezelter@nd.edu ##
13539	<	## ------------------------------ ##
13540	<	_ASBOX
13541	<	) | sed "s/^/$as_me: WARNING:     /" >&2
13542	<	;;
13543	<	esac
13544	<	{ echo "$as_me:$LINENO: checking for iomanip" >&5
13545	<	echo $ECHO_N "checking for iomanip... $ECHO_C" >&6; }
13546	<	if test "${ac_cv_header_iomanip+set}" = set; then
13547	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13548	<	else
13549	<	ac_cv_header_iomanip=$ac_header_preproc
13550	<	fi
13551	<	{ echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
13552	<	echo "${ECHO_T}$ac_cv_header_iomanip" >&6; }
13553	<
13554	<	fi
13555	<	if test $ac_cv_header_iomanip = yes; then
13556	<
13557	<
13558	<	cat >>confdefs.h <<\_ACEOF
13559	<	#define HAVE_IOMANIP 1
13560	<	_ACEOF
13561	<
13562	<
13563	<	else
13564	<
13565	<
13566	<	for ac_header in iomanip.h
13567	<	do
13568	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
13569	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13570	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13571	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13572	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13573	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13574	<	fi
13575	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13576	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13577	<	echo "${ECHO_T}$ac_res" >&6; }
13578	<	else
13579	<	# Is the header compilable?
13580	<	{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
13581	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
13582	<	cat >conftest.$ac_ext <<_ACEOF
13583	<	/* confdefs.h.  */
13584	<	_ACEOF
13585	<	cat confdefs.h >>conftest.$ac_ext
13586	<	cat >>conftest.$ac_ext <<_ACEOF
13587	<	/* end confdefs.h.  */
13588	<	$ac_includes_default
13589	<	#include <$ac_header>
13590	<	_ACEOF
13591	<	rm -f conftest.$ac_objext
13592	<	if { (ac_try="$ac_compile"
13593	<	case "(($ac_try" in
13594	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13595	<	*) ac_try_echo=$ac_try;;
13596	<	esac
13597	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13598	<	(eval "$ac_compile") 2>conftest.er1
13599	<	ac_status=$?
13600	<	grep -v '^ *+' conftest.er1 >conftest.err
13601	<	rm -f conftest.er1
13602	<	cat conftest.err >&5
13603	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13604	<	(exit $ac_status); } && {
13605	<	test -z "$ac_cxx_werror_flag" ||
13606	<	test ! -s conftest.err
13607	<	} && test -s conftest.$ac_objext; then
13608	<	ac_header_compiler=yes
13609	<	else
13610	<	echo "$as_me: failed program was:" >&5
13611	<	sed 's/^/| /' conftest.$ac_ext >&5
13612	<
13613	<	ac_header_compiler=no
13614	<	fi
13615	<
13616	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13617	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13618	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
13619	<
13620	<	# Is the header present?
13621	<	{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
13622	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
13623	<	cat >conftest.$ac_ext <<_ACEOF
13624	<	/* confdefs.h.  */
13625	<	_ACEOF
13626	<	cat confdefs.h >>conftest.$ac_ext
13627	<	cat >>conftest.$ac_ext <<_ACEOF
13628	<	/* end confdefs.h.  */
13629	<	#include <$ac_header>
13630	<	_ACEOF
13631	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
13632	<	case "(($ac_try" in
13633	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13634	<	*) ac_try_echo=$ac_try;;
13635	<	esac
13636	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13637	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
13638	<	ac_status=$?
13639	<	grep -v '^ *+' conftest.er1 >conftest.err
13640	<	rm -f conftest.er1
13641	<	cat conftest.err >&5
13642	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13643	<	(exit $ac_status); } >/dev/null && {
13644	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
13645	<	test ! -s conftest.err
13646	<	}; then
13647	<	ac_header_preproc=yes
13648	<	else
13649	<	echo "$as_me: failed program was:" >&5
13650	<	sed 's/^/| /' conftest.$ac_ext >&5
13651	<
13652	<	ac_header_preproc=no
13653	<	fi
13654	<
13655	<	rm -f conftest.err conftest.$ac_ext
13656	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13657	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
13658	<
13659	<	# So?  What about this header?
13660	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13661	<	yes:no: )
13662	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
13663	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
13664	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
13665	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
13666	<	ac_header_preproc=yes
13667	<	;;
13668	<	no:yes:* )
13669	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
13670	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
13671	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
13672	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
13673	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
13674	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
13675	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
13676	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
13677	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
13678	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
13679	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
13680	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
13681	<	( cat <<\_ASBOX
13682	<	## ------------------------------ ##
13683	<	## Report this to gezelter@nd.edu ##
13684	<	## ------------------------------ ##
13685	<	_ASBOX
13686	<	) | sed "s/^/$as_me: WARNING:     /" >&2
13687	<	;;
13688	<	esac
13689	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13690	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13691	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13692	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13693	<	else
13694	<	eval "$as_ac_Header=\$ac_header_preproc"
13695	<	fi
13696	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13697	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13698	<	echo "${ECHO_T}$ac_res" >&6; }
13699	<
13700	<	fi
13701	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
13702	<	cat >>confdefs.h <<_ACEOF
13703	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
13704	<	_ACEOF
13705	<
13706	<	fi
13707	<
13708	<	done
13709	<
13710	<
13711	<	fi
13712	<
13713	<
13714	<
13715	<
13716	<	for ac_header in cmath
13717	<	do
13718	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
13719	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13720	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13721	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13722	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13723	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13724	<	fi
13725	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13726	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13727	<	echo "${ECHO_T}$ac_res" >&6; }
13728	<	else
13729	<	# Is the header compilable?
13730	<	{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
13731	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
13732	<	cat >conftest.$ac_ext <<_ACEOF
13733	<	/* confdefs.h.  */
13734	<	_ACEOF
13735	<	cat confdefs.h >>conftest.$ac_ext
13736	<	cat >>conftest.$ac_ext <<_ACEOF
13737	<	/* end confdefs.h.  */
13738	<	$ac_includes_default
13739	<	#include <$ac_header>
13740	<	_ACEOF
13741	<	rm -f conftest.$ac_objext
13742	<	if { (ac_try="$ac_compile"
13743	<	case "(($ac_try" in
13744	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13745	<	*) ac_try_echo=$ac_try;;
13746	<	esac
13747	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13748	<	(eval "$ac_compile") 2>conftest.er1
13749	<	ac_status=$?
13750	<	grep -v '^ *+' conftest.er1 >conftest.err
13751	<	rm -f conftest.er1
13752	<	cat conftest.err >&5
13753	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13754	<	(exit $ac_status); } && {
13755	<	test -z "$ac_cxx_werror_flag" ||
13756	<	test ! -s conftest.err
13757	<	} && test -s conftest.$ac_objext; then
13758	<	ac_header_compiler=yes
13759	<	else
13760	<	echo "$as_me: failed program was:" >&5
13761	<	sed 's/^/| /' conftest.$ac_ext >&5
13762	<
13763	<	ac_header_compiler=no
13764	<	fi
13765	<
13766	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13767	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13768	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
13769	<
13770	<	# Is the header present?
13771	<	{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
13772	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
13773	<	cat >conftest.$ac_ext <<_ACEOF
13774	<	/* confdefs.h.  */
13775	<	_ACEOF
13776	<	cat confdefs.h >>conftest.$ac_ext
13777	<	cat >>conftest.$ac_ext <<_ACEOF
13778	<	/* end confdefs.h.  */
13779	<	#include <$ac_header>
13780	<	_ACEOF
13781	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
13782	<	case "(($ac_try" in
13783	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13784	<	*) ac_try_echo=$ac_try;;
13785	<	esac
13786	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13787	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
13788	<	ac_status=$?
13789	<	grep -v '^ *+' conftest.er1 >conftest.err
13790	<	rm -f conftest.er1
13791	<	cat conftest.err >&5
13792	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13793	<	(exit $ac_status); } >/dev/null && {
13794	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
13795	<	test ! -s conftest.err
13796	<	}; then
13797	<	ac_header_preproc=yes
13798	<	else
13799	<	echo "$as_me: failed program was:" >&5
13800	<	sed 's/^/| /' conftest.$ac_ext >&5
13801	<
13802	<	ac_header_preproc=no
13803	<	fi
13804	<
13805	<	rm -f conftest.err conftest.$ac_ext
13806	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13807	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
13808	<
13809	<	# So?  What about this header?
13810	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13811	<	yes:no: )
13812	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
13813	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
13814	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
13815	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
13816	<	ac_header_preproc=yes
13817	<	;;
13818	<	no:yes:* )
13819	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
13820	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
13821	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
13822	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
13823	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
13824	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
13825	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
13826	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
13827	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
13828	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
13829	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
13830	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
13831	<	( cat <<\_ASBOX
13832	<	## ------------------------------ ##
13833	<	## Report this to gezelter@nd.edu ##
13834	<	## ------------------------------ ##
13835	<	_ASBOX
13836	<	) | sed "s/^/$as_me: WARNING:     /" >&2
13837	<	;;
13838	<	esac
13839	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
13840	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
13841	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
13842	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13843	<	else
13844	<	eval "$as_ac_Header=\$ac_header_preproc"
13845	<	fi
13846	<	ac_res=`eval echo '${'$as_ac_Header'}'`
13847	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
13848	<	echo "${ECHO_T}$ac_res" >&6; }
13849	<
13850	<	fi
13851	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
13852	<	cat >>confdefs.h <<_ACEOF
13853	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
13854	<	_ACEOF
13855	<
13856	<	fi
13857	<
13858	<	done
13859	<
13860	<
13861	<
13862	<
13863	<	{ echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
13864	<	echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6; }
13865	<	if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
13866	<	echo $ECHO_N "(cached) $ECHO_C" >&6
13867	<	else
13868	<
13869	<	ac_cv_cxx_have_std_iostream=no
13870	<	ac_cv_cxx_need_use_std_iostream=no
13871	<	if test "x$ac_cv_cxx_namespaces" = xyes; then
13872	<
13873	<	ac_ext=cpp
13874	<	ac_cpp='$CXXCPP $CPPFLAGS'
13875	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13876	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13877	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13878	<
13879	<	cat >conftest.$ac_ext <<_ACEOF
13880	<	/* confdefs.h.  */
13881	<	_ACEOF
13882	<	cat confdefs.h >>conftest.$ac_ext
13883	<	cat >>conftest.$ac_ext <<_ACEOF
13884	<	/* end confdefs.h.  */
13885	<
13886	<	#ifdef HAVE_IOSTREAM
13887	<	#include <iostream>
13888	<	#else
13889	<	#include <iostream.h>
13890	<	#endif
13891	<
13892	<	#ifdef FC_DUMMY_MAIN
13893	<	#ifndef FC_DUMMY_MAIN_EQ_F77
13894	<	#  ifdef __cplusplus
13895	<	extern "C"
13896	<	#  endif
13897	<	int FC_DUMMY_MAIN() { return 1; }
13898	<	#endif
13899	<	#endif
13900	<	int
13901	<	main ()
13902	<	{
13903	<	std::cout<<"Hello World"<<std::endl;return 0;
13904	<	;
13905	<	return 0;
13906	<	}
13907	<	_ACEOF
13908	<	rm -f conftest.$ac_objext
13909	<	if { (ac_try="$ac_compile"
13910	<	case "(($ac_try" in
13911	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13912	<	*) ac_try_echo=$ac_try;;
13913	<	esac
13914	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13915	<	(eval "$ac_compile") 2>conftest.er1
13916	<	ac_status=$?
13917	<	grep -v '^ *+' conftest.er1 >conftest.err
13918	<	rm -f conftest.er1
13919	<	cat conftest.err >&5
13920	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13921	<	(exit $ac_status); } && {
13922	<	test -z "$ac_cxx_werror_flag" ||
13923	<	test ! -s conftest.err
13924	<	} && test -s conftest.$ac_objext; then
13925	<	ac_cv_cxx_have_std_iostream=yes
13926	<	else
13927	<	echo "$as_me: failed program was:" >&5
13928	<	sed 's/^/| /' conftest.$ac_ext >&5
13929	<
13930	<
13931	<	fi
13932	<
13933	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13934	<	cat >conftest.$ac_ext <<_ACEOF
13935	<	/* confdefs.h.  */
13936	<	_ACEOF
13937	<	cat confdefs.h >>conftest.$ac_ext
13938	<	cat >>conftest.$ac_ext <<_ACEOF
13939	<	/* end confdefs.h.  */
13940	<
13941	<	#define __USE_STD_IOSTREAM 1
13942	<	#ifdef HAVE_IOSTREAM
13943	<	#include <iostream>
13944	<	#else
13945	<	#include <iostream.h>
13946	<	#endif
13947	<
13948	<	#ifdef FC_DUMMY_MAIN
13949	<	#ifndef FC_DUMMY_MAIN_EQ_F77
13950	<	#  ifdef __cplusplus
13951	<	extern "C"
13952	<	#  endif
13953	<	int FC_DUMMY_MAIN() { return 1; }
13954	<	#endif
13955	<	#endif
13956	<	int
13957	<	main ()
13958	<	{
13959	<	std::cout<<"Hello World"<<std::endl;return 0;
13960	<	;
13961	<	return 0;
13962	<	}
13963	<	_ACEOF
13964	<	rm -f conftest.$ac_objext
13965	<	if { (ac_try="$ac_compile"
13966	<	case "(($ac_try" in
13967	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13968	<	*) ac_try_echo=$ac_try;;
13969	<	esac
13970	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13971	<	(eval "$ac_compile") 2>conftest.er1
13972	<	ac_status=$?
13973	<	grep -v '^ *+' conftest.er1 >conftest.err
13974	<	rm -f conftest.er1
13975	<	cat conftest.err >&5
13976	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
13977	<	(exit $ac_status); } && {
13978	<	test -z "$ac_cxx_werror_flag" ||
13979	<	test ! -s conftest.err
13980	<	} && test -s conftest.$ac_objext; then
13981	<	ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
13982	<	else
13983	<	echo "$as_me: failed program was:" >&5
13984	<	sed 's/^/| /' conftest.$ac_ext >&5
13985	<
13986	<
13987	<	fi
13988	<
13989	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13990	<	ac_ext=cpp
13991	<	ac_cpp='$CXXCPP $CPPFLAGS'
13992	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13993	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13994	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13995	<
13996	<	fi
13997	<
13998	<	fi
13999	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
14000	<	echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6; }
14001	<	if test "$ac_cv_cxx_have_std_iostream" = yes; then
14002	<
14003	<	cat >>confdefs.h <<\_ACEOF
14004	<	#define HAVE_STD_IOSTREAM 1
14005	<	_ACEOF
14006	<
14007	<	fi
14008	<	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
14009	<
14010	<	cat >>confdefs.h <<\_ACEOF
14011	<	#define __USE_STD_IOSTREAM 1
14012	<	_ACEOF
14013	<
14014	<	fi
14015	<
14016	<
14017	<
14018	<
14019	<	{ echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
14020	<	echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6; }
14021	<	if test "${ac_cv_cxx_have_std_stl+set}" = set; then
14022	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14023	<	else
14024	<
14025	<	ac_cv_cxx_have_std_stl=no
14026	<	if test "x$ac_cv_cxx_namespaces" = xyes; then
14027	<
14028	<	ac_ext=cpp
14029	<	ac_cpp='$CXXCPP $CPPFLAGS'
14030	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14031	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14032	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14033	<
14034	<	cat >conftest.$ac_ext <<_ACEOF
14035	<	/* confdefs.h.  */
14036	<	_ACEOF
14037	<	cat confdefs.h >>conftest.$ac_ext
14038	<	cat >>conftest.$ac_ext <<_ACEOF
14039	<	/* end confdefs.h.  */
14040	<	#include <list>
14041	<
14042	<	#ifdef FC_DUMMY_MAIN
14043	<	#ifndef FC_DUMMY_MAIN_EQ_F77
14044	<	#  ifdef __cplusplus
14045	<	extern "C"
14046	<	#  endif
14047	<	int FC_DUMMY_MAIN() { return 1; }
14048	<	#endif
14049	<	#endif
14050	<	int
14051	<	main ()
14052	<	{
14053	<	std::list<int> foo;return 0;
14054	<	;
14055	<	return 0;
14056	<	}
14057	<	_ACEOF
14058	<	rm -f conftest.$ac_objext
14059	<	if { (ac_try="$ac_compile"
14060	<	case "(($ac_try" in
14061	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14062	<	*) ac_try_echo=$ac_try;;
14063	<	esac
14064	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14065	<	(eval "$ac_compile") 2>conftest.er1
14066	<	ac_status=$?
14067	<	grep -v '^ *+' conftest.er1 >conftest.err
14068	<	rm -f conftest.er1
14069	<	cat conftest.err >&5
14070	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14071	<	(exit $ac_status); } && {
14072	<	test -z "$ac_cxx_werror_flag" ||
14073	<	test ! -s conftest.err
14074	<	} && test -s conftest.$ac_objext; then
14075	<	ac_cv_cxx_have_std_stl=yes
14076	<	else
14077	<	echo "$as_me: failed program was:" >&5
14078	<	sed 's/^/| /' conftest.$ac_ext >&5
14079	<
14080	<
14081	<	fi
14082	<
14083	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14084	<	ac_ext=cpp
14085	<	ac_cpp='$CXXCPP $CPPFLAGS'
14086	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14087	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14088	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14089	<
14090	<	fi
14091	<
14092	<	fi
14093	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
14094	<	echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6; }
14095	<	if test "$ac_cv_cxx_have_std_stl" = yes; then
14096	<
14097	<	cat >>confdefs.h <<\_ACEOF
14098	<	#define HAVE_STD_STL 1
14099	<	_ACEOF
14100	<
14101	<	fi
14102	<
14103	<
14104	<
14105	<	{ echo "$as_me:$LINENO: checking for fstream::attach()" >&5
14106	<	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6; }
14107	<	if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
14108	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14109	<	else
14110	<
14111	<	ac_cv_cxx_have_fstream_attach=no
14112	<
14113	<	ac_ext=cpp
14114	<	ac_cpp='$CXXCPP $CPPFLAGS'
14115	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14116	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14117	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14118	<
14119	<	cat >conftest.$ac_ext <<_ACEOF
14120	<	/* confdefs.h.  */
14121	<	_ACEOF
14122	<	cat confdefs.h >>conftest.$ac_ext
14123	<	cat >>conftest.$ac_ext <<_ACEOF
14124	<	/* end confdefs.h.  */
14125	<
14126	<	#ifdef HAVE_IOSTREAM
14127	<	#include <fstream>
14128	<	#else
14129	<	#include <fstream.h>
14130	<	#endif
14131	<	#ifdef HAVE_STD_IOSTREAM
14132	<	using namespace std;
14133	<	#endif
14134	<
14135	<	#ifdef FC_DUMMY_MAIN
14136	<	#ifndef FC_DUMMY_MAIN_EQ_F77
14137	<	#  ifdef __cplusplus
14138	<	extern "C"
14139	<	#  endif
14140	<	int FC_DUMMY_MAIN() { return 1; }
14141	<	#endif
14142	<	#endif
14143	<	int
14144	<	main ()
14145	<	{
14146	<	int fd=0;ofstream s;s.attach(fd);
14147	<	;
14148	<	return 0;
14149	<	}
14150	<	_ACEOF
14151	<	rm -f conftest.$ac_objext
14152	<	if { (ac_try="$ac_compile"
14153	<	case "(($ac_try" in
14154	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14155	<	*) ac_try_echo=$ac_try;;
14156	<	esac
14157	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14158	<	(eval "$ac_compile") 2>conftest.er1
14159	<	ac_status=$?
14160	<	grep -v '^ *+' conftest.er1 >conftest.err
14161	<	rm -f conftest.er1
14162	<	cat conftest.err >&5
14163	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14164	<	(exit $ac_status); } && {
14165	<	test -z "$ac_cxx_werror_flag" ||
14166	<	test ! -s conftest.err
14167	<	} && test -s conftest.$ac_objext; then
14168	<	ac_cv_cxx_have_fstream_attach=yes
14169	<	else
14170	<	echo "$as_me: failed program was:" >&5
14171	<	sed 's/^/| /' conftest.$ac_ext >&5
14172	<
14173	<
14174	<	fi
14175	<
14176	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14177	<	ac_ext=cpp
14178	<	ac_cpp='$CXXCPP $CPPFLAGS'
14179	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14180	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14181	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14182	<
14183	<
14184	<	fi
14185	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
14186	<	echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6; }
14187	<	if test "$ac_cv_cxx_have_fstream_attach" = yes; then
14188	<
14189	<	cat >>confdefs.h <<\_ACEOF
14190	<	#define HAVE_FSTREAM_ATTACH 1
14191	<	_ACEOF
14192	<
14193	<	fi
14194	<
14195	<
14196	<
14197	<	{ echo "$as_me:$LINENO: checking for fstream::open()" >&5
14198	<	echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6; }
14199	<	if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
14200	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14201	<	else
14202	<
14203	<	ac_cv_cxx_have_fstream_open=no
14204	<	ac_cv_cxx_fstream_open_prot=no
14205	<
14206	<	ac_ext=cpp
14207	<	ac_cpp='$CXXCPP $CPPFLAGS'
14208	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14209	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14210	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14211	<
14212	<	# Try with 2 parameters
14213	<	cat >conftest.$ac_ext <<_ACEOF
14214	<	/* confdefs.h.  */
14215	<	_ACEOF
14216	<	cat confdefs.h >>conftest.$ac_ext
14217	<	cat >>conftest.$ac_ext <<_ACEOF
14218	<	/* end confdefs.h.  */
14219	<
14220	<	#ifdef HAVE_IOSTREAM
14221	<	#include <fstream>
14222	<	#else
14223	<	#include <fstream.h>
14224	<	#endif
14225	<	#ifdef HAVE_STD_IOSTREAM
14226	<	using namespace std;
14227	<	#endif
14228	<
14229	<	#ifdef FC_DUMMY_MAIN
14230	<	#ifndef FC_DUMMY_MAIN_EQ_F77
14231	<	#  ifdef __cplusplus
14232	<	extern "C"
14233	<	#  endif
14234	<	int FC_DUMMY_MAIN() { return 1; }
14235	<	#endif
14236	<	#endif
14237	<	int
14238	<	main ()
14239	<	{
14240	<	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
14241	<	;
14242	<	return 0;
14243	<	}
14244	<	_ACEOF
14245	<	rm -f conftest.$ac_objext
14246	<	if { (ac_try="$ac_compile"
14247	<	case "(($ac_try" in
14248	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14249	<	*) ac_try_echo=$ac_try;;
14250	<	esac
14251	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14252	<	(eval "$ac_compile") 2>conftest.er1
14253	<	ac_status=$?
14254	<	grep -v '^ *+' conftest.er1 >conftest.err
14255	<	rm -f conftest.er1
14256	<	cat conftest.err >&5
14257	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14258	<	(exit $ac_status); } && {
14259	<	test -z "$ac_cxx_werror_flag" ||
14260	<	test ! -s conftest.err
14261	<	} && test -s conftest.$ac_objext; then
14262	<	ac_cv_cxx_have_fstream_open=yes
14263	<	else
14264	<	echo "$as_me: failed program was:" >&5
14265	<	sed 's/^/| /' conftest.$ac_ext >&5
14266	<
14267	<
14268	<	fi
14269	<
14270	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14271	<	# Try with mode parameter
14272	<	cat >conftest.$ac_ext <<_ACEOF
14273	<	/* confdefs.h.  */
14274	<	_ACEOF
14275	<	cat confdefs.h >>conftest.$ac_ext
14276	<	cat >>conftest.$ac_ext <<_ACEOF
14277	<	/* end confdefs.h.  */
14278	<
14279	<	#ifdef HAVE_IOSTREAM
14280	<	#include <fstream>
14281	<	#else
14282	<	#include <fstream.h>
14283	<	#endif
14284	<	#ifdef HAVE_STD_IOSTREAM
14285	<	using namespace std;
14286	<	#endif
14287	<
14288	<	#ifdef FC_DUMMY_MAIN
14289	<	#ifndef FC_DUMMY_MAIN_EQ_F77
14290	<	#  ifdef __cplusplus
14291	<	extern "C"
14292	<	#  endif
14293	<	int FC_DUMMY_MAIN() { return 1; }
14294	<	#endif
14295	<	#endif
14296	<	int
14297	<	main ()
14298	<	{
14299	<	ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
14300	<	;
14301	<	return 0;
14302	<	}
14303	<	_ACEOF
14304	<	rm -f conftest.$ac_objext
14305	<	if { (ac_try="$ac_compile"
14306	<	case "(($ac_try" in
14307	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14308	<	*) ac_try_echo=$ac_try;;
14309	<	esac
14310	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14311	<	(eval "$ac_compile") 2>conftest.er1
14312	<	ac_status=$?
14313	<	grep -v '^ *+' conftest.er1 >conftest.err
14314	<	rm -f conftest.er1
14315	<	cat conftest.err >&5
14316	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14317	<	(exit $ac_status); } && {
14318	<	test -z "$ac_cxx_werror_flag" ||
14319	<	test ! -s conftest.err
14320	<	} && test -s conftest.$ac_objext; then
14321	<	ac_cv_cxx_fstream_open_prot=yes
14322	<	else
14323	<	echo "$as_me: failed program was:" >&5
14324	<	sed 's/^/| /' conftest.$ac_ext >&5
14325	<
14326	<
14327	<	fi
14328	<
14329	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14330	<	ac_ext=cpp
14331	<	ac_cpp='$CXXCPP $CPPFLAGS'
14332	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14333	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14334	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
14335	<
14336	<
14337	<	fi
14338	<	{ echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
14339	<	echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6; }
14340	<	if test "$ac_cv_cxx_have_fstream_open" = yes; then
14341	<
14342	<	cat >>confdefs.h <<\_ACEOF
14343	<	#define HAVE_FSTREAM_OPEN 1
14344	<	_ACEOF
14345	<
14346	<	fi
14347	<	if test "$ac_cv_cxx_fstream_open_prot" = yes; then
14348	<
14349	<	cat >>confdefs.h <<\_ACEOF
14350	<	#define FSTREAM_OPEN_PROT 1
14351	<	_ACEOF
14352	<
14353	<	fi
14354	<
14355	<
14356	<
14357	<
14358	<
14359	<
14360	<
14361	<	for ac_header in ctype.h iostream fstream sstream strstream
14362	<	do
14363	<	as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
14364	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
14365	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
14366	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
14367	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
14368	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14369	<	fi
14370	<	ac_res=`eval echo '${'$as_ac_Header'}'`
14371	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
14372	<	echo "${ECHO_T}$ac_res" >&6; }
14373	<	else
14374	<	# Is the header compilable?
14375	<	{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
14376	<	echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
14377	<	cat >conftest.$ac_ext <<_ACEOF
14378	<	/* confdefs.h.  */
14379	<	_ACEOF
14380	<	cat confdefs.h >>conftest.$ac_ext
14381	<	cat >>conftest.$ac_ext <<_ACEOF
14382	<	/* end confdefs.h.  */
14383	<	$ac_includes_default
14384	<	#include <$ac_header>
14385	<	_ACEOF
14386	<	rm -f conftest.$ac_objext
14387	<	if { (ac_try="$ac_compile"
14388	<	case "(($ac_try" in
14389	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14390	<	*) ac_try_echo=$ac_try;;
14391	<	esac
14392	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14393	<	(eval "$ac_compile") 2>conftest.er1
14394	<	ac_status=$?
14395	<	grep -v '^ *+' conftest.er1 >conftest.err
14396	<	rm -f conftest.er1
14397	<	cat conftest.err >&5
14398	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14399	<	(exit $ac_status); } && {
14400	<	test -z "$ac_cxx_werror_flag" ||
14401	<	test ! -s conftest.err
14402	<	} && test -s conftest.$ac_objext; then
14403	<	ac_header_compiler=yes
14404	<	else
14405	<	echo "$as_me: failed program was:" >&5
14406	<	sed 's/^/| /' conftest.$ac_ext >&5
14407	<
14408	<	ac_header_compiler=no
14409	<	fi
14410	<
14411	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14412	<	{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
14413	<	echo "${ECHO_T}$ac_header_compiler" >&6; }
14414	<
14415	<	# Is the header present?
14416	<	{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
14417	<	echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
14418	<	cat >conftest.$ac_ext <<_ACEOF
14419	<	/* confdefs.h.  */
14420	<	_ACEOF
14421	<	cat confdefs.h >>conftest.$ac_ext
14422	<	cat >>conftest.$ac_ext <<_ACEOF
14423	<	/* end confdefs.h.  */
14424	<	#include <$ac_header>
14425	<	_ACEOF
14426	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
14427	<	case "(($ac_try" in
14428	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14429	<	*) ac_try_echo=$ac_try;;
14430	<	esac
14431	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14432	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
14433	<	ac_status=$?
14434	<	grep -v '^ *+' conftest.er1 >conftest.err
14435	<	rm -f conftest.er1
14436	<	cat conftest.err >&5
14437	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14438	<	(exit $ac_status); } >/dev/null && {
14439	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
14440	<	test ! -s conftest.err
14441	<	}; then
14442	<	ac_header_preproc=yes
14443	<	else
14444	<	echo "$as_me: failed program was:" >&5
14445	<	sed 's/^/| /' conftest.$ac_ext >&5
14446	<
14447	<	ac_header_preproc=no
14448	<	fi
14449	<
14450	<	rm -f conftest.err conftest.$ac_ext
14451	<	{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
14452	<	echo "${ECHO_T}$ac_header_preproc" >&6; }
14453	<
14454	<	# So?  What about this header?
14455	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
14456	<	yes:no: )
14457	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
14458	<	echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
14459	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
14460	<	echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
14461	<	ac_header_preproc=yes
14462	<	;;
14463	<	no:yes:* )
14464	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
14465	<	echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
14466	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
14467	<	echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
14468	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
14469	<	echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
14470	<	{ echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
14471	<	echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
14472	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
14473	<	echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
14474	<	{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
14475	<	echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
14476	<	( cat <<\_ASBOX
14477	<	## ------------------------------ ##
14478	<	## Report this to gezelter@nd.edu ##
14479	<	## ------------------------------ ##
14480	<	_ASBOX
14481	<	) | sed "s/^/$as_me: WARNING:     /" >&2
14482	<	;;
14483	<	esac
14484	<	{ echo "$as_me:$LINENO: checking for $ac_header" >&5
14485	<	echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
14486	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
14487	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14488	<	else
14489	<	eval "$as_ac_Header=\$ac_header_preproc"
14490	<	fi
14491	<	ac_res=`eval echo '${'$as_ac_Header'}'`
14492	<	{ echo "$as_me:$LINENO: result: $ac_res" >&5
14493	<	echo "${ECHO_T}$ac_res" >&6; }
14494	<
14495	<	fi
14496	<	if test `eval echo '${'$as_ac_Header'}'` = yes; then
14497	<	cat >>confdefs.h <<_ACEOF
14498	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
14499	<	_ACEOF
14500	<
14501	<	fi
14502	<
14503	<	done
14504	<
14505	<	# AC_CPP_FUNC
14506	<	# ------------------ #
14507	<	# Checks to see if ANSI C99 CPP variable __func__ works.
14508	<	# If not, perhaps __FUNCTION__ works instead.
14509	<	# If not, we'll just define __func__ to "".
14510	<	# AC_CPP_FUNC
14511	<
14512	<	case $ac_cv_prog_cc_stdc in
14513	<	no) ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;;
14514	<	*) { echo "$as_me:$LINENO: checking for $CC option to accept ISO C99" >&5
14515	<	echo $ECHO_N "checking for $CC option to accept ISO C99... $ECHO_C" >&6; }
14516	<	if test "${ac_cv_prog_cc_c99+set}" = set; then
14517	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14518	<	else
14519	<	ac_cv_prog_cc_c99=no
14520	<	ac_save_CC=$CC
14521	<	cat >conftest.$ac_ext <<_ACEOF
14522	<	/* confdefs.h.  */
14523	<	_ACEOF
14524	<	cat confdefs.h >>conftest.$ac_ext
14525	<	cat >>conftest.$ac_ext <<_ACEOF
14526	<	/* end confdefs.h.  */
14527	<	#include <stdarg.h>
14528	<	#include <stdbool.h>
14529	<	#include <stdlib.h>
14530	<	#include <wchar.h>
14531	<	#include <stdio.h>
14532	<
14533	<	// Check varargs macros.  These examples are taken from C99 6.10.3.5.
14534	<	#define debug(...) fprintf (stderr, __VA_ARGS__)
14535	<	#define showlist(...) puts (#__VA_ARGS__)
14536	<	#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
14537	<	static void
14538	<	test_varargs_macros (void)
14539	<	{
14540	<	int x = 1234;
14541	<	int y = 5678;
14542	<	debug ("Flag");
14543	<	debug ("X = %d\n", x);
14544	<	showlist (The first, second, and third items.);
14545	<	report (x>y, "x is %d but y is %d", x, y);
14546	<	}
14547	<
14548	<	// Check long long types.
14549	<	#define BIG64 18446744073709551615ull
14550	<	#define BIG32 4294967295ul
14551	<	#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
14552	<	#if !BIG_OK
14553	<	your preprocessor is broken;
14554	<	#endif
14555	<	#if BIG_OK
14556	<	#else
14557	<	your preprocessor is broken;
14558	<	#endif
14559	<	static long long int bignum = -9223372036854775807LL;
14560	<	static unsigned long long int ubignum = BIG64;
14561	<
14562	<	struct incomplete_array
14563	<	{
14564	<	int datasize;
14565	<	double data[];
14566	<	};
14567	<
14568	<	struct named_init {
14569	<	int number;
14570	<	const wchar_t *name;
14571	<	double average;
14572	<	};
14573	<
14574	<	typedef const char *ccp;
14575	<
14576	<	static inline int
14577	<	test_restrict (ccp restrict text)
14578	<	{
14579	<	// See if C++-style comments work.
14580	<	// Iterate through items via the restricted pointer.
14581	<	// Also check for declarations in for loops.
14582	<	for (unsigned int i = 0; *(text+i) != '\0'; ++i)
14583	<	continue;
14584	<	return 0;
14585	<	}
14586	<
14587	<	// Check varargs and va_copy.
14588	<	static void
14589	<	test_varargs (const char *format, ...)
14590	<	{
14591	<	va_list args;
14592	<	va_start (args, format);
14593	<	va_list args_copy;
14594	<	va_copy (args_copy, args);
14595	<
14596	<	const char *str;
14597	<	int number;
14598	<	float fnumber;
14599	<
14600	<	while (*format)
14601	<	{
14602	<	switch (*format++)
14603	<	{
14604	<	case 's': // string
14605	<	str = va_arg (args_copy, const char *);
14606	<	break;
14607	<	case 'd': // int
14608	<	number = va_arg (args_copy, int);
14609	<	break;
14610	<	case 'f': // float
14611	<	fnumber = va_arg (args_copy, double);
14612	<	break;
14613	<	default:
14614	<	break;
14615	<	}
14616	<	}
14617	<	va_end (args_copy);
14618	<	va_end (args);
14619	<	}
14620	<
14621	<	#ifdef FC_DUMMY_MAIN
14622	<	#ifndef FC_DUMMY_MAIN_EQ_F77
14623	<	#  ifdef __cplusplus
14624	<	extern "C"
14625	<	#  endif
14626	<	int FC_DUMMY_MAIN() { return 1; }
14627	<	#endif
14628	<	#endif
14629	<	int
14630	<	main ()
14631	<	{
14632	<
14633	<	// Check bool.
14634	<	_Bool success = false;
14635	<
14636	<	// Check restrict.
14637	<	if (test_restrict ("String literal") == 0)
14638	<	success = true;
14639	<	char *restrict newvar = "Another string";
14640	<
14641	<	// Check varargs.
14642	<	test_varargs ("s, d' f .", "string", 65, 34.234);
14643	<	test_varargs_macros ();
14644	<
14645	<	// Check flexible array members.
14646	<	struct incomplete_array *ia =
14647	<	malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
14648	<	ia->datasize = 10;
14649	<	for (int i = 0; i < ia->datasize; ++i)
14650	<	ia->data[i] = i * 1.234;
14651	<
14652	<	// Check named initializers.
14653	<	struct named_init ni = {
14654	<	.number = 34,
14655	<	.name = L"Test wide string",
14656	<	.average = 543.34343,
14657	<	};
14658	<
14659	<	ni.number = 58;
14660	<
14661	<	int dynamic_array[ni.number];
14662	<	dynamic_array[ni.number - 1] = 543;
14663	<
14664	<	// work around unused variable warnings
14665	<	return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
14666	<	|| dynamic_array[ni.number - 1] != 543);
14667	<
14668	<	;
14669	<	return 0;
14670	<	}
14671	<	_ACEOF
14672	<	for ac_arg in '' -std=gnu99 -c99 -qlanglvl=extc99
14673	<	do
14674	<	CC="$ac_save_CC $ac_arg"
14675	<	rm -f conftest.$ac_objext
14676	<	if { (ac_try="$ac_compile"
14677	<	case "(($ac_try" in
14678	<	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14679	<	*) ac_try_echo=$ac_try;;
14680	<	esac
14681	<	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14682	<	(eval "$ac_compile") 2>conftest.er1
14683	<	ac_status=$?
14684	<	grep -v '^ *+' conftest.er1 >conftest.err
14685	<	rm -f conftest.er1
14686	<	cat conftest.err >&5
14687	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14688	<	(exit $ac_status); } && {
14689	<	test -z "$ac_cxx_werror_flag" ||
14690	<	test ! -s conftest.err
14691	<	} && test -s conftest.$ac_objext; then
14692	<	ac_cv_prog_cc_c99=$ac_arg
14693	<	else
14694	<	echo "$as_me: failed program was:" >&5
14695	<	sed 's/^/| /' conftest.$ac_ext >&5
14696	<
14697	<
14698	<	fi
14699	<
14700	<	rm -f core conftest.err conftest.$ac_objext
14701	<	test "x$ac_cv_prog_cc_c99" != "xno" && break
14702	<	done
14703	<	rm -f conftest.$ac_ext
14704	<	CC=$ac_save_CC
14705	<
14706	<	fi
14707	<	# AC_CACHE_VAL
14708	<	case "x$ac_cv_prog_cc_c99" in
14709	<	x)
14710	<	{ echo "$as_me:$LINENO: result: none needed" >&5
14711	<	echo "${ECHO_T}none needed" >&6; } ;;
14712	<	xno)
14713	<	{ echo "$as_me:$LINENO: result: unsupported" >&5
14714	<	echo "${ECHO_T}unsupported" >&6; } ;;
14715	<	*)
14716	<	CC="$CC $ac_cv_prog_cc_c99"
14717	<	{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c99" >&5
14718	<	echo "${ECHO_T}$ac_cv_prog_cc_c99" >&6; } ;;
14719	<	esac
14720	<	if test "x$ac_cv_prog_cc_c99" != xno; then
14721	<	ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
14722	<	else
14723	<	{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
14724	<	echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
14725	<	if test "${ac_cv_prog_cc_c89+set}" = set; then
14726	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14727	<	else
14728	<	ac_cv_prog_cc_c89=no
14729	<	ac_save_CC=$CC
14730	<	cat >conftest.$ac_ext <<_ACEOF
14731	<	/* confdefs.h.  */
14732	<	_ACEOF
14733	<	cat confdefs.h >>conftest.$ac_ext
14734	<	cat >>conftest.$ac_ext <<_ACEOF
14735	<	/* end confdefs.h.  */
14736	<	#include <stdarg.h>
14737	<	#include <stdio.h>
14738	<	#include <sys/types.h>
14739	<	#include <sys/stat.h>
14740	<	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
14741	<	struct buf { int x; };
14742	<	FILE * (*rcsopen) (struct buf *, struct stat *, int);
14743	<	static char *e (p, i)
14744	<	char **p;
14745	<	int i;
14746	<	{
14747	<	return p[i];
14748	<	}
14749	<	static char *f (char * (*g) (char **, int), char **p, ...)
14750	<	{
14751	<	char *s;
14752	<	va_list v;
14753	<	va_start (v,p);
14754	<	s = g (p, va_arg (v,int));
14755	<	va_end (v);
14756	<	return s;
14757	<	}
11532	>	{ echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
11533	>	echo "${ECHO_T}$ac_cv_lib_m_pow" >&6; }
11534	>	if test $ac_cv_lib_m_pow = yes; then
11535	>	POW_LIB=-lm
11536	>	else
11537	>	{ echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
11538	>	echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
11539	>	fi
11540	>
11541	>	fi
11542	>
11543	>	fi
11544	>
11545	>
11546	>
11547	>
11548	>
11549	>
11550	>
11551	>
11552	>
11553
14759	–	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
14760	–	function prototypes and stuff, but not '\xHH' hex character constants.
14761	–	These don't provoke an error unfortunately, instead are silently treated
14762	–	as 'x'.  The following induces an error, until -std is added to get
14763	–	proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
14764	–	array size at least.  It's necessary to write '\x00'==0 to get something
14765	–	that's true only with -std.  */
14766	–	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
11554
14768	–	/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
14769	–	inside strings and character constants.  */
14770	–	#define FOO(x) 'x'
14771	–	int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
11555
14773	–	int test (int i, double x);
14774	–	struct s1 {int (*f) (int a);};
14775	–	struct s2 {int (*f) (double a);};
14776	–	int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
14777	–	int argc;
14778	–	char **argv;
14779	–	#ifdef FC_DUMMY_MAIN
14780	–	#ifndef FC_DUMMY_MAIN_EQ_F77
14781	–	#  ifdef __cplusplus
14782	–	extern "C"
14783	–	#  endif
14784	–	int FC_DUMMY_MAIN() { return 1; }
14785	–	#endif
14786	–	#endif
14787	–	int
14788	–	main ()
14789	–	{
14790	–	return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
14791	–	;
14792	–	return 0;
14793	–	}
14794	–	_ACEOF
14795	–	for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
14796	–	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
14797	–	do
14798	–	CC="$ac_save_CC $ac_arg"
14799	–	rm -f conftest.$ac_objext
14800	–	if { (ac_try="$ac_compile"
14801	–	case "(($ac_try" in
14802	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14803	–	*) ac_try_echo=$ac_try;;
14804	–	esac
14805	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14806	–	(eval "$ac_compile") 2>conftest.er1
14807	–	ac_status=$?
14808	–	grep -v '^ *+' conftest.er1 >conftest.err
14809	–	rm -f conftest.er1
14810	–	cat conftest.err >&5
14811	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14812	–	(exit $ac_status); } && {
14813	–	test -z "$ac_cxx_werror_flag" ||
14814	–	test ! -s conftest.err
14815	–	} && test -s conftest.$ac_objext; then
14816	–	ac_cv_prog_cc_c89=$ac_arg
14817	–	else
14818	–	echo "$as_me: failed program was:" >&5
14819	–	sed 's/^/| /' conftest.$ac_ext >&5
11556
11557
14822	–	fi
11558
14824	–	rm -f core conftest.err conftest.$ac_objext
14825	–	test "x$ac_cv_prog_cc_c89" != "xno" && break
14826	–	done
14827	–	rm -f conftest.$ac_ext
14828	–	CC=$ac_save_CC
11559
14830	–	fi
14831	–	# AC_CACHE_VAL
14832	–	case "x$ac_cv_prog_cc_c89" in
14833	–	x)
14834	–	{ echo "$as_me:$LINENO: result: none needed" >&5
14835	–	echo "${ECHO_T}none needed" >&6; } ;;
14836	–	xno)
14837	–	{ echo "$as_me:$LINENO: result: unsupported" >&5
14838	–	echo "${ECHO_T}unsupported" >&6; } ;;
14839	–	*)
14840	–	CC="$CC $ac_cv_prog_cc_c89"
14841	–	{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
14842	–	echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
14843	–	esac
14844	–	if test "x$ac_cv_prog_cc_c89" != xno; then
14845	–	ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
14846	–	else
14847	–	ac_cv_prog_cc_stdc=no
14848	–	fi
11560
11561
14851	–	fi
11562
14853	–	;;
14854	–	esac
14855	–	{ echo "$as_me:$LINENO: checking for $CC option to accept ISO Standard C" >&5
14856	–	echo $ECHO_N "checking for $CC option to accept ISO Standard C... $ECHO_C" >&6; }
14857	–	if test "${ac_cv_prog_cc_stdc+set}" = set; then
14858	–	echo $ECHO_N "(cached) $ECHO_C" >&6
14859	–	fi
11563
14861	–	case $ac_cv_prog_cc_stdc in
14862	–	no) { echo "$as_me:$LINENO: result: unsupported" >&5
14863	–	echo "${ECHO_T}unsupported" >&6; } ;;
14864	–	'') { echo "$as_me:$LINENO: result: none needed" >&5
14865	–	echo "${ECHO_T}none needed" >&6; } ;;
14866	–	*) { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
14867	–	echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6; } ;;
14868	–	esac
11564
11565
11566	<	{ echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11567	<	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6; }
11568	<	if test "${ac_cv_cpp_func+set}" = set; then
11566	>	for ac_func in floor getpagesize gettimeofday memset pow pstat_getdynamic pstat_getstatic select sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strstr strtol sysmp getsysinfo sysctl table
11567	>	do
11568	>	as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11569	>	{ echo "$as_me:$LINENO: checking for $ac_func" >&5
11570	>	echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
11571	>	if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11572		echo $ECHO_N "(cached) $ECHO_C" >&6
11573		else
11574		cat >conftest.$ac_ext <<_ACEOF
#	Line 14879 | Line 11577 | cat >>conftest.$ac_ext <<_ACEOF
11577		cat confdefs.h >>conftest.$ac_ext
11578		cat >>conftest.$ac_ext <<_ACEOF
11579		/* end confdefs.h.  */
11580	+	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11581	+	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11582	+	#define $ac_func innocuous_$ac_func
11583
11584	+	/* System header to define __stub macros and hopefully few prototypes,
11585	+	which can conflict with char $ac_func (); below.
11586	+	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11587	+	<limits.h> exists even on freestanding compilers.  */
11588	+
11589	+	#ifdef __STDC__
11590	+	# include <limits.h>
11591	+	#else
11592	+	# include <assert.h>
11593	+	#endif
11594	+
11595	+	#undef $ac_func
11596	+
11597	+	/* Override any GCC internal prototype to avoid an error.
11598	+	Use char because int might match the return type of a GCC
11599	+	builtin and then its argument prototype would still apply.  */
11600	+	#ifdef __cplusplus
11601	+	extern "C"
11602	+	#endif
11603	+	char $ac_func ();
11604	+	/* The GNU C library defines this for functions which it implements
11605	+	to always fail with ENOSYS.  Some functions are actually named
11606	+	something starting with __ and the normal name is an alias.  */
11607	+	#if defined __stub_$ac_func || defined __stub___$ac_func
11608	+	choke me
11609	+	#endif
11610	+
11611		#ifdef FC_DUMMY_MAIN
11612		#ifndef FC_DUMMY_MAIN_EQ_F77
11613		#  ifdef __cplusplus
#	Line 14891 | Line 11619 | main ()
11619		int
11620		main ()
11621		{
11622	<	const char *foo = __func__;
11622	>	return $ac_func ();
11623		;
11624		return 0;
11625		}
11626		_ACEOF
11627	<	rm -f conftest.$ac_objext
11628	<	if { (ac_try="$ac_compile"
11627	>	rm -f conftest.$ac_objext conftest$ac_exeext
11628	>	if { (ac_try="$ac_link"
11629		case "(($ac_try" in
11630		*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11631		*) ac_try_echo=$ac_try;;
11632		esac
11633		eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11634	<	(eval "$ac_compile") 2>conftest.er1
11634	>	(eval "$ac_link") 2>conftest.er1
11635		ac_status=$?
11636		grep -v '^ *+' conftest.er1 >conftest.err
11637		rm -f conftest.er1
11638		cat conftest.err >&5
11639		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11640		(exit $ac_status); } && {
11641	<	test -z "$ac_cxx_werror_flag" ||
11641	>	test -z "$ac_c_werror_flag" ||
11642		test ! -s conftest.err
11643	<	} && test -s conftest.$ac_objext; then
11644	<	ac_cv_cpp_func=yes
11643	>	} && test -s conftest$ac_exeext &&
11644	>	$as_test_x conftest$ac_exeext; then
11645	>	eval "$as_ac_var=yes"
11646		else
11647		echo "$as_me: failed program was:" >&5
11648		sed 's/^/| /' conftest.$ac_ext >&5
11649
11650	<	cat >conftest.$ac_ext <<_ACEOF
11650	>	eval "$as_ac_var=no"
11651	>	fi
11652	>
11653	>	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11654	>	conftest$ac_exeext conftest.$ac_ext
11655	>	fi
11656	>	ac_res=`eval echo '${'$as_ac_var'}'`
11657	>	{ echo "$as_me:$LINENO: result: $ac_res" >&5
11658	>	echo "${ECHO_T}$ac_res" >&6; }
11659	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
11660	>	cat >>confdefs.h <<_ACEOF
11661	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11662	>	_ACEOF
11663	>
11664	>	fi
11665	>	done
11666	>
11667	>
11668	>	# special check for _system_configuration because AIX <4.3.2 do not
11669	>	# contain the `physmem' member.
11670	>	{ echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11671	>	echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6; }
11672	>	cat >conftest.$ac_ext <<_ACEOF
11673		/* confdefs.h.  */
11674		_ACEOF
11675		cat confdefs.h >>conftest.$ac_ext
11676		cat >>conftest.$ac_ext <<_ACEOF
11677		/* end confdefs.h.  */
11678	<
11678	>	#include <sys/systemcfg.h>
11679		#ifdef FC_DUMMY_MAIN
11680		#ifndef FC_DUMMY_MAIN_EQ_F77
11681		#  ifdef __cplusplus
#	Line 14936 | Line 11687 | main ()
11687		int
11688		main ()
11689		{
11690	<	const char *foo = __FUNCTION__;
11690	>	double x = _system_configuration.physmem;
11691		;
11692		return 0;
11693		}
#	Line 14955 | Line 11706 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11706		cat conftest.err >&5
11707		echo "$as_me:$LINENO: \$? = $ac_status" >&5
11708		(exit $ac_status); } && {
11709	<	test -z "$ac_cxx_werror_flag" ||
11709	>	test -z "$ac_c_werror_flag" ||
11710		test ! -s conftest.err
11711		} && test -s conftest.$ac_objext; then
11712	<	ac_cv_cpp_func=__FUNCTION__
11712	>	{ echo "$as_me:$LINENO: result: yes" >&5
11713	>	echo "${ECHO_T}yes" >&6; }
11714	>
11715	>	cat >>confdefs.h <<\_ACEOF
11716	>	#define HAVE__SYSTEM_CONFIGURATION 1
11717	>	_ACEOF
11718	>
11719		else
11720		echo "$as_me: failed program was:" >&5
11721		sed 's/^/| /' conftest.$ac_ext >&5
11722
11723	<	ac_cv_cpp_func=no
11723	>	{ echo "$as_me:$LINENO: result: no" >&5
11724	>	echo "${ECHO_T}no" >&6; }
11725		fi
11726
11727		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14970	–	fi
11728
14972	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14973	–	fi
14974	–	{ echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
14975	–	echo "${ECHO_T}$ac_cv_cpp_func" >&6; }
14976	–	if test $ac_cv_cpp_func = __FUNCTION__; then
11729
14978	–	cat >>confdefs.h <<\_ACEOF
14979	–	#define __func__ __FUNCTION__
14980	–	_ACEOF
14981	–
14982	–	elif test $ac_cv_cpp_func = no; then
14983	–
14984	–	cat >>confdefs.h <<\_ACEOF
14985	–	#define __func__ ""
14986	–	_ACEOF
14987	–
14988	–	fi
14989	–
14990	–
14991	–
14992	–
14993	–
11730		case $debug in
11731		1)
11732		;;
#	Line 14999 | Line 11735 | case $debug in
11735
11736
11737
11738	+
11739		# Try to determine "good" native compiler flags if none specified on command
11740		# line
11741
#	Line 15007 | Line 11744 | if test "$ac_test_FFLAGS" != "set"; then
11744		case "${host_cpu}-${host_os}" in
11745
11746		*linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11747	<	FCFLAGS="-O3 -ip -no-prec-div"
11747	>	FCFLAGS="-O2"
11748		fi;;
11749		rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11750		FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
#	Line 15030 | Line 11767 | if test "$ac_test_FFLAGS" != "set"; then
11767		FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11768		fi
11769		if test "$FC" = ifort; then
11770	<	FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11770	>	FCFLAGS="-O2"
11771	>	fi
11772	>	if test "$FC" = gfortran; then
11773	>	FCFLAGS="-Os"
11774		fi;;
11775		esac
11776
15037	–	if test -n "$CPU_FLAGS"; then
15038	–	FCFLAGS="$FCFLAGS $CPU_FLAGS"
15039	–	fi
15040	–
11777		if test -z "$FCFLAGS"; then
11778		echo ""
11779		echo "*********************************************************"
11780		echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11781		echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11782	<	echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11782	>	echo "* (otherwise, a default of FCFLAGS=-O will be used)     *"
11783		echo "*********************************************************"
11784		echo ""
11785	<	FCFLAGS="-O3"
11785	>	FCFLAGS="-O"
11786		fi
11787
11788
#	Line 15075 | Line 11811 | rm -f conftest*
11811		ac_guessed_f90flags=no
11812		fi
11813		rm -f conftest*
11814	<	ac_ext=cpp
11815	<	ac_cpp='$CXXCPP $CPPFLAGS'
11816	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11817	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11818	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11814	>	ac_ext=c
11815	>	ac_cpp='$CPP $CPPFLAGS'
11816	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11817	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11818	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
11819
11820
11821		fi
#	Line 15156 | Line 11892 | if test "$ac_test_CFLAGS" != "set"; then
11892		case "${host_cpu}-${host_os}" in
11893
11894		*linux*) if test "$CC" = icc; then
11895	<	CFLAGS="-O"
11895	>	CFLAGS="-O2"
11896		fi;;
11897		sparc-solaris2*) if test "$CC" = cc; then
11898		CFLAGS="-O -dalign"
#	Line 15187 | Line 11923 | if test "$ac_test_CFLAGS" != "set"; then
11923		echo "*******************************************************"
11924		fi;;
11925		*darwin*)
11926	<	if test "$CC" = xlc -o "$CC" = cc; then
11926	>	if test "$CC" = xlc; then
11927		CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11928		fi
11929		if test "$CC" = icc; then
11930	<	CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
11930	>	CFLAGS="-O2"
11931	>	fi
11932	>	if test $ac_cv_prog_really_gcc = yes; then
11933	>	CFLAGS="-Os"
11934		fi;;
11935		esac
11936
11937		# use default flags for gcc on all systems
11938	<	if test $ac_cv_prog_really_gcc = yes; then
11939	<	CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align"
15201	<	fi
15202	<
15203	<	# test for gcc-specific flags:
15204	<	if test $ac_cv_prog_really_gcc = yes; then
15205	<	# -malign-double for x86 systems
15206	<
15207	<
15208	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
15209	<	echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6; }
15210	<	if test "${ac_align_double+set}" = set; then
15211	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15212	<	else
15213	<	echo 'void f(){}' > conftest.c
15214	<	if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
15215	<	ac_align_double=yes
15216	<	else
15217	<	ac_align_double=no
15218	<	fi
15219	<	rm -f conftest*
15220	<
15221	<	fi
15222	<	{ echo "$as_me:$LINENO: result: $ac_align_double" >&5
15223	<	echo "${ECHO_T}$ac_align_double" >&6; }
15224	<	if test "$ac_align_double" = yes; then
15225	<	:
15226	<	CFLAGS="$CFLAGS -malign-double"
15227	<	else
15228	<	:
15229	<
15230	<	fi
15231	<
15232	<	# -fstrict-aliasing for gcc-2.95+
15233	<
15234	<
15235	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
15236	<	echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6; }
15237	<	if test "${ac_fstrict_aliasing+set}" = set; then
15238	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15239	<	else
15240	<	echo 'void f(){}' > conftest.c
15241	<	if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
15242	<	ac_fstrict_aliasing=yes
15243	<	else
15244	<	ac_fstrict_aliasing=no
15245	<	fi
15246	<	rm -f conftest*
15247	<
15248	<	fi
15249	<	{ echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
15250	<	echo "${ECHO_T}$ac_fstrict_aliasing" >&6; }
15251	<	if test "$ac_fstrict_aliasing" = yes; then
15252	<	:
15253	<	CFLAGS="$CFLAGS -fstrict-aliasing"
15254	<	else
15255	<	:
15256	<
15257	<	fi
15258	<
15259	<	fi
15260	<
15261	<	CPU_FLAGS=""
15262	<	if test $ac_cv_prog_really_gcc = yes; then
15263	<	case "${host_cpu}" in
15264	<	i586*)
15265	<
15266	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
15267	<	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6; }
15268	<	if test "${ac_cpu_pentium+set}" = set; then
15269	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15270	<	else
15271	<	echo 'void f(){}' > conftest.c
15272	<	if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
15273	<	ac_cpu_pentium=yes
15274	<	else
15275	<	ac_cpu_pentium=no
15276	<	fi
15277	<	rm -f conftest*
15278	<
15279	<	fi
15280	<	{ echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
15281	<	echo "${ECHO_T}$ac_cpu_pentium" >&6; }
15282	<	if test "$ac_cpu_pentium" = yes; then
15283	<	:
15284	<	CPU_FLAGS=-mcpu=pentium
15285	<	else
15286	<	:
15287	<
15288	<
15289	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
15290	<	echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6; }
15291	<	if test "${ac_pentium+set}" = set; then
15292	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15293	<	else
15294	<	echo 'void f(){}' > conftest.c
15295	<	if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
15296	<	ac_pentium=yes
15297	<	else
15298	<	ac_pentium=no
15299	<	fi
15300	<	rm -f conftest*
15301	<
15302	<	fi
15303	<	{ echo "$as_me:$LINENO: result: $ac_pentium" >&5
15304	<	echo "${ECHO_T}$ac_pentium" >&6; }
15305	<	if test "$ac_pentium" = yes; then
15306	<	:
15307	<	CPU_FLAGS=-mpentium
15308	<	else
15309	<	:
15310	<
15311	<	fi
15312	<
15313	<	fi
15314	<
15315	<	;;
15316	<	i686*)
15317	<
15318	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
15319	<	echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6; }
15320	<	if test "${ac_cpu_pentiumpro+set}" = set; then
15321	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15322	<	else
15323	<	echo 'void f(){}' > conftest.c
15324	<	if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
15325	<	ac_cpu_pentiumpro=yes
15326	<	else
15327	<	ac_cpu_pentiumpro=no
15328	<	fi
15329	<	rm -f conftest*
15330	<
15331	<	fi
15332	<	{ echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
15333	<	echo "${ECHO_T}$ac_cpu_pentiumpro" >&6; }
15334	<	if test "$ac_cpu_pentiumpro" = yes; then
15335	<	:
15336	<	CPU_FLAGS=-mcpu=pentiumpro
15337	<	else
15338	<	:
15339	<
15340	<
15341	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
15342	<	echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6; }
15343	<	if test "${ac_pentiumpro+set}" = set; then
15344	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15345	<	else
15346	<	echo 'void f(){}' > conftest.c
15347	<	if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
15348	<	ac_pentiumpro=yes
15349	<	else
15350	<	ac_pentiumpro=no
15351	<	fi
15352	<	rm -f conftest*
15353	<
15354	<	fi
15355	<	{ echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
15356	<	echo "${ECHO_T}$ac_pentiumpro" >&6; }
15357	<	if test "$ac_pentiumpro" = yes; then
15358	<	:
15359	<	CPU_FLAGS=-mpentiumpro
15360	<	else
15361	<	:
15362	<
15363	<	fi
15364	<
15365	<	fi
15366	<
15367	<	;;
15368	<	powerpc*)
15369	<	cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
15370	<	is60x=`echo $cputype | egrep "^600-9e?$"`
15371	<	if test -n "$is60x"; then
15372	<
15373	<
15374	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
15375	<	echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6; }
15376	<	if test "${ac_m_cpu_60x+set}" = set; then
15377	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15378	<	else
15379	<	echo 'void f(){}' > conftest.c
15380	<	if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
15381	<	ac_m_cpu_60x=yes
15382	<	else
15383	<	ac_m_cpu_60x=no
15384	<	fi
15385	<	rm -f conftest*
15386	<
15387	<	fi
15388	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
15389	<	echo "${ECHO_T}$ac_m_cpu_60x" >&6; }
15390	<	if test "$ac_m_cpu_60x" = yes; then
15391	<	:
15392	<	CPU_FLAGS=-mcpu=$cputype
15393	<	else
15394	<	:
15395	<
15396	<	fi
15397	<
15398	<	elif test "$cputype" = 750; then
15399	<
15400	<
15401	<	{ echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
15402	<	echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6; }
15403	<	if test "${ac_cv_prog_gcc_2_95+set}" = set; then
15404	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15405	<	else
15406	<
15407	<	cat > conftest.c <<EOF
15408	<	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
15409	<	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
15410	<	yes;
15411	<	#  endif
15412	<	#endif
15413	<	EOF
15414	<	if { ac_try='${CC-cc} -E conftest.c'
15415	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15416	<	(eval $ac_try) 2>&5
15417	<	ac_status=$?
15418	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
15419	<	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
15420	<	ac_cv_prog_gcc_2_95=yes
15421	<	else
15422	<	ac_cv_prog_gcc_2_95=no
15423	<	fi
15424	<
15425	<	fi
15426	<	{ echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
15427	<	echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6; }
15428	<	if test "$ac_cv_prog_gcc_2_95" = yes; then
15429	<	:
15430	<
15431	<
15432	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
15433	<	echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6; }
15434	<	if test "${ac_m_cpu_750+set}" = set; then
15435	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15436	<	else
15437	<	echo 'void f(){}' > conftest.c
15438	<	if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
15439	<	ac_m_cpu_750=yes
15440	<	else
15441	<	ac_m_cpu_750=no
15442	<	fi
15443	<	rm -f conftest*
15444	<
15445	<	fi
15446	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
15447	<	echo "${ECHO_T}$ac_m_cpu_750" >&6; }
15448	<	if test "$ac_m_cpu_750" = yes; then
15449	<	:
15450	<	CPU_FLAGS=-mcpu=750
15451	<	else
15452	<	:
15453	<
15454	<	fi
15455	<
15456	<	else
15457	<	:
15458	<
15459	<	fi
15460	<
15461	<	fi
15462	<	if test -z "$CPU_FLAGS"; then
15463	<
15464	<
15465	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
15466	<	echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6; }
15467	<	if test "${ac_m_cpu_powerpc+set}" = set; then
15468	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15469	<	else
15470	<	echo 'void f(){}' > conftest.c
15471	<	if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
15472	<	ac_m_cpu_powerpc=yes
15473	<	else
15474	<	ac_m_cpu_powerpc=no
15475	<	fi
15476	<	rm -f conftest*
15477	<
15478	<	fi
15479	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
15480	<	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6; }
15481	<	if test "$ac_m_cpu_powerpc" = yes; then
15482	<	:
15483	<	CPU_FLAGS=-mcpu=powerpc
15484	<	else
15485	<	:
15486	<
15487	<	fi
15488	<
15489	<	fi
15490	<	if test -z "$CPU_FLAGS"; then
15491	<
15492	<
15493	<	{ echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
15494	<	echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6; }
15495	<	if test "${ac_m_powerpc+set}" = set; then
15496	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15497	<	else
15498	<	echo 'void f(){}' > conftest.c
15499	<	if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
15500	<	ac_m_powerpc=yes
15501	<	else
15502	<	ac_m_powerpc=no
15503	<	fi
15504	<	rm -f conftest*
15505	<
15506	<	fi
15507	<	{ echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
15508	<	echo "${ECHO_T}$ac_m_powerpc" >&6; }
15509	<	if test "$ac_m_powerpc" = yes; then
15510	<	:
15511	<	CPU_FLAGS=-mpowerpc
15512	<	else
15513	<	:
15514	<
15515	<	fi
15516	<
15517	<	fi
15518	<	esac
11938	>	if test $ac_cv_prog_really_gcc = yes -a -z "$CFLAGS"; then
11939	>	CFLAGS="-O2"
11940		fi
11941
15521	–	if test -n "$CPU_FLAGS"; then
15522	–	CFLAGS="$CFLAGS $CPU_FLAGS"
15523	–	fi
15524	–
11942		if test -z "$CFLAGS"; then
11943		echo ""
11944		echo "********************************************************"
11945		echo "* WARNING: Don't know the best CFLAGS for this system  *"
11946		echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
11947	<	echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
11947	>	echo "* (otherwise, a default of CFLAGS=-O will be used)     *"
11948		echo "********************************************************"
11949		echo ""
11950	<	CFLAGS="-O3"
11950	>	CFLAGS="-O"
11951		fi
11952
11953
#	Line 15622 | Line 12039 | if test "$ac_test_CXXFLAGS" != "set"; then
12039		case "${host_cpu}-${host_os}" in
12040
12041		*linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12042	<	CXXFLAGS="-O"
12042	>	CXXFLAGS="-O2"
12043		fi;;
12044		sparc-solaris2*) if test "$CXX" = CC; then
12045		CXXFLAGS="-features=extensions -O -dalign"
#	Line 15648 | Line 12065 | if test "$ac_test_CXXFLAGS" != "set"; then
12065		CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12066		fi
12067		if test "$CXX" = icpc; then
12068	<	CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12068	>	CXXFLAGS="-O2"
12069	>	fi
12070	>	if test $ac_cv_prog_really_gxx = yes; then
12071	>	CXXFLAGS="-Os"
12072		fi;;
12073		esac
12074
12075		# use default flags for gcc on all systems
12076	<	if test $ac_cv_prog_really_gxx = yes; then
12077	<	CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align"
15658	<	fi
15659	<
15660	<	# test for gcc-specific flags:
15661	<	if test $ac_cv_prog_really_gxx = yes; then
15662	<	# -malign-double for x86 systems
15663	<
15664	<
15665	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
15666	<	echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6; }
15667	<	if test "${ac_align_double+set}" = set; then
15668	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15669	<	else
15670	<	echo 'void f(){}' > conftest.cpp
15671	<	if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
15672	<	ac_align_double=yes
15673	<	else
15674	<	ac_align_double=no
15675	<	fi
15676	<	rm -f conftest*
15677	<
15678	<	fi
15679	<	{ echo "$as_me:$LINENO: result: $ac_align_double" >&5
15680	<	echo "${ECHO_T}$ac_align_double" >&6; }
15681	<	if test "$ac_align_double" = yes; then
15682	<	:
15683	<	CXXFLAGS="$CXXFLAGS -malign-double"
15684	<	else
15685	<	:
15686	<
15687	<	fi
15688	<
15689	<	# -fstrict-aliasing for gcc-2.95+
15690	<
15691	<
15692	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
15693	<	echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6; }
15694	<	if test "${ac_fstrict_aliasing+set}" = set; then
15695	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15696	<	else
15697	<	echo 'void f(){}' > conftest.cpp
15698	<	if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
15699	<	ac_fstrict_aliasing=yes
15700	<	else
15701	<	ac_fstrict_aliasing=no
15702	<	fi
15703	<	rm -f conftest*
15704	<
15705	<	fi
15706	<	{ echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
15707	<	echo "${ECHO_T}$ac_fstrict_aliasing" >&6; }
15708	<	if test "$ac_fstrict_aliasing" = yes; then
15709	<	:
15710	<	CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
15711	<	else
15712	<	:
15713	<
15714	<	fi
15715	<
15716	<	fi
15717	<
15718	<	CPU_FLAGS=""
15719	<	if test $ac_cv_prog_really_gxx = yes; then
15720	<	case "${host_cpu}" in
15721	<	i586*)
15722	<
15723	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
15724	<	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6; }
15725	<	if test "${ac_cpu_pentium+set}" = set; then
15726	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15727	<	else
15728	<	echo 'void f(){}' > conftest.cpp
15729	<	if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
15730	<	ac_cpu_pentium=yes
15731	<	else
15732	<	ac_cpu_pentium=no
15733	<	fi
15734	<	rm -f conftest*
15735	<
15736	<	fi
15737	<	{ echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
15738	<	echo "${ECHO_T}$ac_cpu_pentium" >&6; }
15739	<	if test "$ac_cpu_pentium" = yes; then
15740	<	:
15741	<	CPU_FLAGS=-mcpu=pentium
15742	<	else
15743	<	:
15744	<
15745	<
15746	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
15747	<	echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6; }
15748	<	if test "${ac_pentium+set}" = set; then
15749	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15750	<	else
15751	<	echo 'void f(){}' > conftest.cpp
15752	<	if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
15753	<	ac_pentium=yes
15754	<	else
15755	<	ac_pentium=no
15756	<	fi
15757	<	rm -f conftest*
15758	<
15759	<	fi
15760	<	{ echo "$as_me:$LINENO: result: $ac_pentium" >&5
15761	<	echo "${ECHO_T}$ac_pentium" >&6; }
15762	<	if test "$ac_pentium" = yes; then
15763	<	:
15764	<	CPU_FLAGS=-mpentium
15765	<	else
15766	<	:
15767	<
15768	<	fi
15769	<
15770	<	fi
15771	<
15772	<	;;
15773	<	i686*)
15774	<
15775	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
15776	<	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6; }
15777	<	if test "${ac_cpu_pentiumpro+set}" = set; then
15778	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15779	<	else
15780	<	echo 'void f(){}' > conftest.cpp
15781	<	if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
15782	<	ac_cpu_pentiumpro=yes
15783	<	else
15784	<	ac_cpu_pentiumpro=no
15785	<	fi
15786	<	rm -f conftest*
15787	<
15788	<	fi
15789	<	{ echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
15790	<	echo "${ECHO_T}$ac_cpu_pentiumpro" >&6; }
15791	<	if test "$ac_cpu_pentiumpro" = yes; then
15792	<	:
15793	<	CPU_FLAGS=-mcpu=pentiumpro
15794	<	else
15795	<	:
15796	<
15797	<
15798	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
15799	<	echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6; }
15800	<	if test "${ac_pentiumpro+set}" = set; then
15801	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15802	<	else
15803	<	echo 'void f(){}' > conftest.cpp
15804	<	if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
15805	<	ac_pentiumpro=yes
15806	<	else
15807	<	ac_pentiumpro=no
15808	<	fi
15809	<	rm -f conftest*
15810	<
15811	<	fi
15812	<	{ echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
15813	<	echo "${ECHO_T}$ac_pentiumpro" >&6; }
15814	<	if test "$ac_pentiumpro" = yes; then
15815	<	:
15816	<	CPU_FLAGS=-mpentiumpro
15817	<	else
15818	<	:
15819	<
15820	<	fi
15821	<
15822	<	fi
15823	<
15824	<	;;
15825	<	powerpc*)
15826	<	cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
15827	<	is60x=`echo $cputype | egrep "^600-9e?$"`
15828	<	if test -n "$is60x"; then
15829	<
15830	<
15831	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
15832	<	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6; }
15833	<	if test "${ac_m_cpu_60x+set}" = set; then
15834	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15835	<	else
15836	<	echo 'void f(){}' > conftest.cpp
15837	<	if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
15838	<	ac_m_cpu_60x=yes
15839	<	else
15840	<	ac_m_cpu_60x=no
15841	<	fi
15842	<	rm -f conftest*
15843	<
15844	<	fi
15845	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
15846	<	echo "${ECHO_T}$ac_m_cpu_60x" >&6; }
15847	<	if test "$ac_m_cpu_60x" = yes; then
15848	<	:
15849	<	CPU_FLAGS=-mcpu=$cputype
15850	<	else
15851	<	:
15852	<
15853	<	fi
15854	<
15855	<	elif test "$cputype" = 750; then
15856	<
15857	<
15858	<	{ echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
15859	<	echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6; }
15860	<	if test "${ac_cv_prog_gxx_2_95+set}" = set; then
15861	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15862	<	else
15863	<
15864	<	cat > conftest.cpp <<EOF
15865	<	#ifdef __GNUC__ && !defined (__INTEL_COMPILER)
15866	<	#  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
15867	<	yes;
15868	<	#  endif
15869	<	#endif
15870	<	EOF
15871	<	if { ac_try='${CXX-c++} -E conftest.cpp'
15872	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15873	<	(eval $ac_try) 2>&5
15874	<	ac_status=$?
15875	<	echo "$as_me:$LINENO: \$? = $ac_status" >&5
15876	<	(exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
15877	<	ac_cv_prog_gxx_2_95=yes
15878	<	else
15879	<	ac_cv_prog_gxx_2_95=no
15880	<	fi
15881	<
15882	<	fi
15883	<	{ echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
15884	<	echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6; }
15885	<	if test "$ac_cv_prog_gxx_2_95" = yes; then
15886	<	:
15887	<
15888	<
15889	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
15890	<	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6; }
15891	<	if test "${ac_m_cpu_750+set}" = set; then
15892	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15893	<	else
15894	<	echo 'void f(){}' > conftest.cpp
15895	<	if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
15896	<	ac_m_cpu_750=yes
15897	<	else
15898	<	ac_m_cpu_750=no
15899	<	fi
15900	<	rm -f conftest*
15901	<
15902	<	fi
15903	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
15904	<	echo "${ECHO_T}$ac_m_cpu_750" >&6; }
15905	<	if test "$ac_m_cpu_750" = yes; then
15906	<	:
15907	<	CPU_FLAGS=-mcpu=750
15908	<	else
15909	<	:
15910	<
15911	<	fi
15912	<
15913	<	else
15914	<	:
15915	<
15916	<	fi
15917	<
15918	<	fi
15919	<	if test -z "$CPU_FLAGS"; then
15920	<
15921	<
15922	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
15923	<	echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6; }
15924	<	if test "${ac_m_cpu_powerpc+set}" = set; then
15925	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15926	<	else
15927	<	echo 'void f(){}' > conftest.cpp
15928	<	if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
15929	<	ac_m_cpu_powerpc=yes
15930	<	else
15931	<	ac_m_cpu_powerpc=no
15932	<	fi
15933	<	rm -f conftest*
15934	<
15935	<	fi
15936	<	{ echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
15937	<	echo "${ECHO_T}$ac_m_cpu_powerpc" >&6; }
15938	<	if test "$ac_m_cpu_powerpc" = yes; then
15939	<	:
15940	<	CPU_FLAGS=-mcpu=powerpc
15941	<	else
15942	<	:
15943	<
15944	<	fi
15945	<
15946	<	fi
15947	<	if test -z "$CPU_FLAGS"; then
15948	<
15949	<
15950	<	{ echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
15951	<	echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6; }
15952	<	if test "${ac_m_powerpc+set}" = set; then
15953	<	echo $ECHO_N "(cached) $ECHO_C" >&6
15954	<	else
15955	<	echo 'void f(){}' > conftest.cpp
15956	<	if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
15957	<	ac_m_powerpc=yes
15958	<	else
15959	<	ac_m_powerpc=no
15960	<	fi
15961	<	rm -f conftest*
15962	<
15963	<	fi
15964	<	{ echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
15965	<	echo "${ECHO_T}$ac_m_powerpc" >&6; }
15966	<	if test "$ac_m_powerpc" = yes; then
15967	<	:
15968	<	CPU_FLAGS=-mpowerpc
15969	<	else
15970	<	:
15971	<
15972	<	fi
15973	<
15974	<	fi
15975	<	esac
12076	>	if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
12077	>	CXXFLAGS="-O2"
12078		fi
12079
15978	–	if test -n "$CPU_FLAGS"; then
15979	–	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
15980	–	fi
15981	–
12080		if test -z "$CXXFLAGS"; then
12081		echo ""
12082		echo "**********************************************************"
12083		echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12084		echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12085	<	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12085	>	echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
12086		echo "**********************************************************"
12087		echo ""
12088	<	CXXFLAGS="-O3"
12088	>	CXXFLAGS="-O"
12089		fi
12090
12091
#	Line 16032 | Line 12130 | esac
12130		esac
12131
12132
16035	–	cat >>confdefs.h <<\_ACEOF
16036	–	#define OBAPI
16037	–	_ACEOF
16038	–
16039	–
16040	–
12133		acx_cgal_found=no
12134
12135		# Check whether --with-cgalmakefile was given.
#	Line 16135 | Line 12227 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12227		cat conftest.err >&5
12228		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12229		(exit $ac_status); } && {
12230	<	test -z "$ac_cxx_werror_flag" ||
12230	>	test -z "$ac_c_werror_flag" ||
12231		test ! -s conftest.err
12232		} && test -s conftest.$ac_objext; then
12233		ac_header_compiler=yes
#	Line 16174 | Line 12266 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12266		cat conftest.err >&5
12267		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12268		(exit $ac_status); } >/dev/null && {
12269	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
12269	>	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12270		test ! -s conftest.err
12271		}; then
12272		ac_header_preproc=yes
#	Line 16190 | Line 12282 | echo "${ECHO_T}$ac_header_preproc" >&6; }
12282		echo "${ECHO_T}$ac_header_preproc" >&6; }
12283
12284		# So?  What about this header?
12285	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12285	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12286		yes:no: )
12287		{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12288		echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 16283 | Line 12375 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12375		cat conftest.err >&5
12376		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12377		(exit $ac_status); } && {
12378	<	test -z "$ac_cxx_werror_flag" ||
12378	>	test -z "$ac_c_werror_flag" ||
12379		test ! -s conftest.err
12380		} && test -s conftest$ac_exeext &&
12381		$as_test_x conftest$ac_exeext; then
#	Line 16354 | Line 12446 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12446		cat conftest.err >&5
12447		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12448		(exit $ac_status); } && {
12449	<	test -z "$ac_cxx_werror_flag" ||
12449	>	test -z "$ac_c_werror_flag" ||
12450		test ! -s conftest.err
12451		} && test -s conftest$ac_exeext &&
12452		$as_test_x conftest$ac_exeext; then
#	Line 16427 | Line 12519 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12519		cat conftest.err >&5
12520		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12521		(exit $ac_status); } && {
12522	<	test -z "$ac_cxx_werror_flag" ||
12522	>	test -z "$ac_c_werror_flag" ||
12523		test ! -s conftest.err
12524		} && test -s conftest$ac_exeext &&
12525		$as_test_x conftest$ac_exeext; then
#	Line 16494 | Line 12586 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12586		cat conftest.err >&5
12587		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12588		(exit $ac_status); } && {
12589	<	test -z "$ac_cxx_werror_flag" ||
12589	>	test -z "$ac_c_werror_flag" ||
12590		test ! -s conftest.err
12591		} && test -s conftest$ac_exeext &&
12592		$as_test_x conftest$ac_exeext; then
#	Line 16561 | Line 12653 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12653		cat conftest.err >&5
12654		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12655		(exit $ac_status); } && {
12656	<	test -z "$ac_cxx_werror_flag" ||
12656	>	test -z "$ac_c_werror_flag" ||
12657		test ! -s conftest.err
12658		} && test -s conftest$ac_exeext &&
12659		$as_test_x conftest$ac_exeext; then
#	Line 16635 | Line 12727 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12727		cat conftest.err >&5
12728		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12729		(exit $ac_status); } && {
12730	<	test -z "$ac_cxx_werror_flag" ||
12730	>	test -z "$ac_c_werror_flag" ||
12731		test ! -s conftest.err
12732		} && test -s conftest$ac_exeext &&
12733		$as_test_x conftest$ac_exeext; then
#	Line 16850 | Line 12942 | fi
12942
12943
12944
12945	<	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/applications/atom2md/Makefile scripts/filepp"
12945	>	ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/integrators/Makefile src/applications/atom2md/Makefile scripts/filepp"
12946
12947
12948		cat >confcache <<\_ACEOF
#	Line 17267 | Line 13359 | config_headers="$ac_config_headers"
13359		# Files that config.status was made for.
13360		config_files="$ac_config_files"
13361		config_headers="$ac_config_headers"
17270	–	config_links="$ac_config_links"
13362
13363		_ACEOF
13364
#	Line 17293 | Line 13384 | $config_headers
13384
13385		Configuration headers:
13386		$config_headers
17296	–
17297	–	Configuration links:
17298	–	$config_links
13387
13388		Report bugs to <bug-autoconf@gnu.org>."
13389
#	Line 17411 | Line 13499 | do
13499		do
13500		case $ac_config_target in
13501		"src/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
17414	–	"src/getopt.h") CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
13502		"make/Makefile") CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
13503		"src/utils/Makefile") CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
13504		"src/math/Makefile") CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
13505	+	"src/integrators/Makefile") CONFIG_FILES="$CONFIG_FILES src/integrators/Makefile" ;;
13506		"src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
13507		"scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
13508
#	Line 17432 | Line 13520 | if $ac_need_defaults; then
13520		if $ac_need_defaults; then
13521		test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13522		test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
17435	–	test "${CONFIG_LINKS+set}" = set || CONFIG_LINKS=$config_links
13523		fi
13524
13525		# Have a temporary directory for convenience.  Make it in the build tree
#	Line 17562 | Line 13649 | RANLIB!$RANLIB$ac_delim
13649		LN_S!$LN_S$ac_delim
13650		SET_MAKE!$SET_MAKE$ac_delim
13651		RANLIB!$RANLIB$ac_delim
17565	–	YACC!$YACC$ac_delim
17566	–	YFLAGS!$YFLAGS$ac_delim
17567	–	LEX!$LEX$ac_delim
17568	–	LEX_OUTPUT_ROOT!$LEX_OUTPUT_ROOT$ac_delim
17569	–	LEXLIB!$LEXLIB$ac_delim
13652		PERLINTERP!$PERLINTERP$ac_delim
13653		PERL_SHEBANG!$PERL_SHEBANG$ac_delim
13654		INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
#	Line 17576 | Line 13658 | FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
13658		PS!$PS$ac_delim
13659		FCFLAGS_F90!$FCFLAGS_F90$ac_delim
13660		FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
13661	+	PREPDEFFLAG!$PREPDEFFLAG$ac_delim
13662	+	FCLIBS!$FCLIBS$ac_delim
13663	+	FC_FUNC!$FC_FUNC$ac_delim
13664	+	FC_FUNC_!$FC_FUNC_$ac_delim
13665	+	MOD!$MOD$ac_delim
13666		_ACEOF
13667
13668		if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
#	Line 17617 | Line 13704 | for ac_last_try in false false false false false :; do
13704		ac_delim='%!_!# '
13705		for ac_last_try in false false false false false :; do
13706		cat >conf$$subs.sed <<_ACEOF
17620	–	PREPDEFFLAG!$PREPDEFFLAG$ac_delim
17621	–	FCLIBS!$FCLIBS$ac_delim
17622	–	FC_FUNC!$FC_FUNC$ac_delim
17623	–	FC_FUNC_!$FC_FUNC_$ac_delim
17624	–	MOD!$MOD$ac_delim
13707		F90_WORK_FILES_ARG!$F90_WORK_FILES_ARG$ac_delim
13708		MODDIRFLAG!$MODDIRFLAG$ac_delim
13709		F90MODINCSPEC!$F90MODINCSPEC$ac_delim
#	Line 17643 | Line 13725 | POW_LIB!$POW_LIB$ac_delim
13725		USE_OPENBABEL!$USE_OPENBABEL$ac_delim
13726		LIBOBJS!$LIBOBJS$ac_delim
13727		POW_LIB!$POW_LIB$ac_delim
17646	–	__func__!$__func__$ac_delim
13728		CGAL_MAKEFILE!$CGAL_MAKEFILE$ac_delim
13729		CGAL_CXXFLAGS!$CGAL_CXXFLAGS$ac_delim
13730		CGAL_CPPFLAGS!$CGAL_CPPFLAGS$ac_delim
#	Line 17664 | Line 13745 | _ACEOF
13745		LTLIBOBJS!$LTLIBOBJS$ac_delim
13746		_ACEOF
13747
13748	<	if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 45; then
13748	>	if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 39; then
13749		break
13750		elif $ac_last_try; then
13751		{ { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
#	Line 17721 | Line 13802 | fi # test -n "$CONFIG_FILES"
13802		fi # test -n "$CONFIG_FILES"
13803
13804
13805	<	for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS  :L $CONFIG_LINKS
13805	>	for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS
13806		do
13807		case $ac_tag in
13808		:[FHLC]) ac_mode=$ac_tag; continue;;
#	Line 18059 | Line 14140 | echo "$as_me: $ac_file is unchanged" >&6;}
14140		fi
14141		rm -f "$tmp/out12"
14142		;;
18062	–	:L)
18063	–	#
18064	–	# CONFIG_LINK
18065	–	#
14143
18067	–	{ echo "$as_me:$LINENO: linking $srcdir/$ac_source to $ac_file" >&5
18068	–	echo "$as_me: linking $srcdir/$ac_source to $ac_file" >&6;}
14144
18070	–	if test ! -r "$srcdir/$ac_source"; then
18071	–	{ { echo "$as_me:$LINENO: error: $srcdir/$ac_source: file not found" >&5
18072	–	echo "$as_me: error: $srcdir/$ac_source: file not found" >&2;}
18073	–	{ (exit 1); exit 1; }; }
18074	–	fi
18075	–	rm -f "$ac_file"
18076	–
18077	–	# Try a relative symlink, then a hard link, then a copy.
18078	–	case $srcdir in
18079	–	[\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
18080	–	*) ac_rel_source=$ac_top_build_prefix$srcdir/$ac_source ;;
14145		esac
18082	–	ln -s "$ac_rel_source" "$ac_file" 2>/dev/null ||
18083	–	ln "$srcdir/$ac_source" "$ac_file" 2>/dev/null ||
18084	–	cp -p "$srcdir/$ac_source" "$ac_file" ||
18085	–	{ { echo "$as_me:$LINENO: error: cannot link or copy $srcdir/$ac_source to $ac_file" >&5
18086	–	echo "$as_me: error: cannot link or copy $srcdir/$ac_source to $ac_file" >&2;}
18087	–	{ (exit 1); exit 1; }; }
18088	–	;;
14146
18090	–	esac
14147
18092	–
14148		case $ac_file$ac_mode in
14149		"make/Makefile":F) chmod 0755 scripts/* ;;
14150		"src/utils/Makefile":F) chmod 0755 scripts/* ;;
14151		"src/math/Makefile":F) chmod 0755 scripts/* ;;
14152	+	"src/integrators/Makefile":F) chmod 0755 scripts/* ;;
14153		"src/applications/atom2md/Makefile":F) chmod 0755 scripts/* ;;
14154		"scripts/filepp":F) chmod 0755 scripts/* ;;
14155

Diff Legend

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