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 1226 by gezelter, Mon Feb 11 23:05:00 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
12155	–	{ echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
12156	–	echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6; }
12157	–	if test $ac_cv_lib_intl_strftime = yes; then
12158	–	cat >>confdefs.h <<\_ACEOF
12159	–	#define HAVE_STRFTIME 1
12160	–	_ACEOF
12161	–
12162	–	LIBS="-lintl $LIBS"
12163	–	fi
12164	–
12165	–	fi
12166	–	done
12167	–
12168	–	{ echo "$as_me:$LINENO: checking for working strtod" >&5
12169	–	echo $ECHO_N "checking for working strtod... $ECHO_C" >&6; }
12170	–	if test "${ac_cv_func_strtod+set}" = set; then
12171	–	echo $ECHO_N "(cached) $ECHO_C" >&6
12172	–	else
12173	–	if test "$cross_compiling" = yes; then
12174	–	ac_cv_func_strtod=no
12175	–	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
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
#	Line 12418 | Line 11536 | echo "$as_me: WARNING: cannot find library containing
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;}
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
11539		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
11540
11541	<	fi
11541	>	fi
11542
11543		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
11544
14003	–	cat >>confdefs.h <<\_ACEOF
14004	–	#define HAVE_STD_IOSTREAM 1
14005	–	_ACEOF
11545
14007	–	fi
14008	–	if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11546
14010	–	cat >>confdefs.h <<\_ACEOF
14011	–	#define __USE_STD_IOSTREAM 1
14012	–	_ACEOF
11547
14014	–	fi
11548
11549
11550
11551
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
11552
14025	–	ac_cv_cxx_have_std_stl=no
14026	–	if test "x$ac_cv_cxx_namespaces" = xyes; then
11553
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
11554
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>
11555
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
11556
11557
14081	–	fi
11558
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
11559
14090	–	fi
11560
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
11561
14097	–	cat >>confdefs.h <<\_ACEOF
14098	–	#define HAVE_STD_STL 1
14099	–	_ACEOF
11562
14101	–	fi
11563
11564
11565
11566	<	{ echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11567	<	echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6; }
11568	<	if test "${ac_cv_cxx_have_fstream_attach+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	<
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
11574	>	cat >conftest.$ac_ext <<_ACEOF
11575		/* confdefs.h.  */
11576		_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	<	#ifdef HAVE_IOSTREAM
11585	<	#include <fstream>
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 <fstream.h>
11592	>	# include <assert.h>
11593		#endif
14131	–	#ifdef HAVE_STD_IOSTREAM
14132	–	using namespace std;
14133	–	#endif
11594
11595	<	#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
11595	>	#undef $ac_func
11596
11597	<
11598	<	fi
11599	<
11600	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11601	<	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>
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	<	#ifdef HAVE_STD_IOSTREAM
11604	<	using namespace std;
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
#	Line 14237 | Line 11619 | main ()
11619		int
11620		main ()
11621		{
11622	<	ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
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_cxx_have_fstream_open=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	<
11650	>	eval "$as_ac_var=no"
11651		fi
11652
11653	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11654	<	# 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	<
11653	>	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11654	>	conftest$ac_exeext conftest.$ac_ext
11655		fi
11656	<
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'}'`
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	<	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
11659	>	if test `eval echo '${'$as_ac_var'}'` = yes; then
11660		cat >>confdefs.h <<_ACEOF
11661	<	#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11661	>	#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11662		_ACEOF
11663
11664		fi
14502	–
11665		done
11666
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
11667
11668	<	case $ac_cv_prog_cc_stdc in
11669	<	no) ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;;
11670	<	*) { echo "$as_me:$LINENO: checking for $CC option to accept ISO C99" >&5
11671	<	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
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	<	#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	<	}
14758	<
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];
14767	<
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];
14772	<
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
14820	<
14821	<
14822	<	fi
14823	<
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
14829	<
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
14849	<
14850	<
14851	<	fi
14852	<
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
14860	<
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
14869	<
14870	<
14871	<	{ echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
14872	<	echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6; }
14873	<	if test "${ac_cv_cpp_func+set}" = set; then
14874	<	echo $ECHO_N "(cached) $ECHO_C" >&6
14875	<	else
14876	<	cat >conftest.$ac_ext <<_ACEOF
14877	<	/* confdefs.h.  */
14878	<	_ACEOF
14879	<	cat confdefs.h >>conftest.$ac_ext
14880	<	cat >>conftest.$ac_ext <<_ACEOF
14881	<	/* end confdefs.h.  */
14882	<
11678	>	#include <sys/systemcfg.h>
11679		#ifdef FC_DUMMY_MAIN
11680		#ifndef FC_DUMMY_MAIN_EQ_F77
11681		#  ifdef __cplusplus
#	Line 14891 | Line 11687 | main ()
11687		int
11688		main ()
11689		{
11690	<	const char *foo = __func__;
11690	>	double x = _system_configuration.physmem;
11691		;
11692		return 0;
11693		}
#	Line 14910 | 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=yes
11713	<	else
14918	<	echo "$as_me: failed program was:" >&5
14919	<	sed 's/^/| /' conftest.$ac_ext >&5
11712	>	{ echo "$as_me:$LINENO: result: yes" >&5
11713	>	echo "${ECHO_T}yes" >&6; }
11714
11715	<	cat >conftest.$ac_ext <<_ACEOF
11716	<	/* confdefs.h.  */
11715	>	cat >>confdefs.h <<\_ACEOF
11716	>	#define HAVE__SYSTEM_CONFIGURATION 1
11717		_ACEOF
14924	–	cat confdefs.h >>conftest.$ac_ext
14925	–	cat >>conftest.$ac_ext <<_ACEOF
14926	–	/* end confdefs.h.  */
11718
14928	–	#ifdef FC_DUMMY_MAIN
14929	–	#ifndef FC_DUMMY_MAIN_EQ_F77
14930	–	#  ifdef __cplusplus
14931	–	extern "C"
14932	–	#  endif
14933	–	int FC_DUMMY_MAIN() { return 1; }
14934	–	#endif
14935	–	#endif
14936	–	int
14937	–	main ()
14938	–	{
14939	–	const char *foo = __FUNCTION__;
14940	–	;
14941	–	return 0;
14942	–	}
14943	–	_ACEOF
14944	–	rm -f conftest.$ac_objext
14945	–	if { (ac_try="$ac_compile"
14946	–	case "(($ac_try" in
14947	–	*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14948	–	*) ac_try_echo=$ac_try;;
14949	–	esac
14950	–	eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14951	–	(eval "$ac_compile") 2>conftest.er1
14952	–	ac_status=$?
14953	–	grep -v '^ *+' conftest.er1 >conftest.err
14954	–	rm -f conftest.er1
14955	–	cat conftest.err >&5
14956	–	echo "$as_me:$LINENO: \$? = $ac_status" >&5
14957	–	(exit $ac_status); } && {
14958	–	test -z "$ac_cxx_werror_flag" ||
14959	–	test ! -s conftest.err
14960	–	} && test -s conftest.$ac_objext; then
14961	–	ac_cv_cpp_func=__FUNCTION__
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
14971	–
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
14977	–
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
11728
14988	–	fi
11729
14990	–
14991	–
14992	–
14993	–
11730		case $debug in
11731		1)
11732		;;
#	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 16032 | Line 12768 | esac
12768		esac
12769
12770
16035	–	cat >>confdefs.h <<\_ACEOF
16036	–	#define OBAPI
16037	–	_ACEOF
16038	–
16039	–
16040	–
12771		acx_cgal_found=no
12772
12773		# Check whether --with-cgalmakefile was given.
#	Line 16135 | Line 12865 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12865		cat conftest.err >&5
12866		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12867		(exit $ac_status); } && {
12868	<	test -z "$ac_cxx_werror_flag" ||
12868	>	test -z "$ac_c_werror_flag" ||
12869		test ! -s conftest.err
12870		} && test -s conftest.$ac_objext; then
12871		ac_header_compiler=yes
#	Line 16174 | Line 12904 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12904		cat conftest.err >&5
12905		echo "$as_me:$LINENO: \$? = $ac_status" >&5
12906		(exit $ac_status); } >/dev/null && {
12907	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
12907	>	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12908		test ! -s conftest.err
12909		}; then
12910		ac_header_preproc=yes
#	Line 16190 | Line 12920 | echo "${ECHO_T}$ac_header_preproc" >&6; }
12920		echo "${ECHO_T}$ac_header_preproc" >&6; }
12921
12922		# So?  What about this header?
12923	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12923	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12924		yes:no: )
12925		{ echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12926		echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
#	Line 16283 | Line 13013 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13013		cat conftest.err >&5
13014		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13015		(exit $ac_status); } && {
13016	<	test -z "$ac_cxx_werror_flag" ||
13016	>	test -z "$ac_c_werror_flag" ||
13017		test ! -s conftest.err
13018		} && test -s conftest$ac_exeext &&
13019		$as_test_x conftest$ac_exeext; then
#	Line 16354 | Line 13084 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13084		cat conftest.err >&5
13085		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13086		(exit $ac_status); } && {
13087	<	test -z "$ac_cxx_werror_flag" ||
13087	>	test -z "$ac_c_werror_flag" ||
13088		test ! -s conftest.err
13089		} && test -s conftest$ac_exeext &&
13090		$as_test_x conftest$ac_exeext; then
#	Line 16427 | Line 13157 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13157		cat conftest.err >&5
13158		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13159		(exit $ac_status); } && {
13160	<	test -z "$ac_cxx_werror_flag" ||
13160	>	test -z "$ac_c_werror_flag" ||
13161		test ! -s conftest.err
13162		} && test -s conftest$ac_exeext &&
13163		$as_test_x conftest$ac_exeext; then
#	Line 16494 | Line 13224 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13224		cat conftest.err >&5
13225		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13226		(exit $ac_status); } && {
13227	<	test -z "$ac_cxx_werror_flag" ||
13227	>	test -z "$ac_c_werror_flag" ||
13228		test ! -s conftest.err
13229		} && test -s conftest$ac_exeext &&
13230		$as_test_x conftest$ac_exeext; then
#	Line 16561 | Line 13291 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13291		cat conftest.err >&5
13292		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13293		(exit $ac_status); } && {
13294	<	test -z "$ac_cxx_werror_flag" ||
13294	>	test -z "$ac_c_werror_flag" ||
13295		test ! -s conftest.err
13296		} && test -s conftest$ac_exeext &&
13297		$as_test_x conftest$ac_exeext; then
#	Line 16635 | Line 13365 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
13365		cat conftest.err >&5
13366		echo "$as_me:$LINENO: \$? = $ac_status" >&5
13367		(exit $ac_status); } && {
13368	<	test -z "$ac_cxx_werror_flag" ||
13368	>	test -z "$ac_c_werror_flag" ||
13369		test ! -s conftest.err
13370		} && test -s conftest$ac_exeext &&
13371		$as_test_x conftest$ac_exeext; then
#	Line 17267 | Line 13997 | config_headers="$ac_config_headers"
13997		# Files that config.status was made for.
13998		config_files="$ac_config_files"
13999		config_headers="$ac_config_headers"
17270	–	config_links="$ac_config_links"
14000
14001		_ACEOF
14002
#	Line 17293 | Line 14022 | $config_headers
14022
14023		Configuration headers:
14024		$config_headers
17296	–
17297	–	Configuration links:
17298	–	$config_links
14025
14026		Report bugs to <bug-autoconf@gnu.org>."
14027
#	Line 17411 | Line 14137 | do
14137		do
14138		case $ac_config_target in
14139		"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" ;;
14140		"make/Makefile") CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14141		"src/utils/Makefile") CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14142		"src/math/Makefile") CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
#	Line 17432 | Line 14157 | if $ac_need_defaults; then
14157		if $ac_need_defaults; then
14158		test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
14159		test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
17435	–	test "${CONFIG_LINKS+set}" = set || CONFIG_LINKS=$config_links
14160		fi
14161
14162		# Have a temporary directory for convenience.  Make it in the build tree
#	Line 17562 | Line 14286 | RANLIB!$RANLIB$ac_delim
14286		LN_S!$LN_S$ac_delim
14287		SET_MAKE!$SET_MAKE$ac_delim
14288		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
14289		PERLINTERP!$PERLINTERP$ac_delim
14290		PERL_SHEBANG!$PERL_SHEBANG$ac_delim
14291		INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
#	Line 17576 | Line 14295 | FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
14295		PS!$PS$ac_delim
14296		FCFLAGS_F90!$FCFLAGS_F90$ac_delim
14297		FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
14298	+	PREPDEFFLAG!$PREPDEFFLAG$ac_delim
14299	+	FCLIBS!$FCLIBS$ac_delim
14300	+	FC_FUNC!$FC_FUNC$ac_delim
14301	+	FC_FUNC_!$FC_FUNC_$ac_delim
14302	+	MOD!$MOD$ac_delim
14303		_ACEOF
14304
14305		if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
#	Line 17617 | Line 14341 | for ac_last_try in false false false false false :; do
14341		ac_delim='%!_!# '
14342		for ac_last_try in false false false false false :; do
14343		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
14344		F90_WORK_FILES_ARG!$F90_WORK_FILES_ARG$ac_delim
14345		MODDIRFLAG!$MODDIRFLAG$ac_delim
14346		F90MODINCSPEC!$F90MODINCSPEC$ac_delim
#	Line 17643 | Line 14362 | POW_LIB!$POW_LIB$ac_delim
14362		USE_OPENBABEL!$USE_OPENBABEL$ac_delim
14363		LIBOBJS!$LIBOBJS$ac_delim
14364		POW_LIB!$POW_LIB$ac_delim
17646	–	__func__!$__func__$ac_delim
14365		CGAL_MAKEFILE!$CGAL_MAKEFILE$ac_delim
14366		CGAL_CXXFLAGS!$CGAL_CXXFLAGS$ac_delim
14367		CGAL_CPPFLAGS!$CGAL_CPPFLAGS$ac_delim
#	Line 17664 | Line 14382 | _ACEOF
14382		LTLIBOBJS!$LTLIBOBJS$ac_delim
14383		_ACEOF
14384
14385	<	if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 45; then
14385	>	if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 39; then
14386		break
14387		elif $ac_last_try; then
14388		{ { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
#	Line 17721 | Line 14439 | fi # test -n "$CONFIG_FILES"
14439		fi # test -n "$CONFIG_FILES"
14440
14441
14442	<	for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS  :L $CONFIG_LINKS
14442	>	for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS
14443		do
14444		case $ac_tag in
14445		:[FHLC]) ac_mode=$ac_tag; continue;;
#	Line 18059 | Line 14777 | echo "$as_me: $ac_file is unchanged" >&6;}
14777		fi
14778		rm -f "$tmp/out12"
14779		;;
18062	–	:L)
18063	–	#
18064	–	# CONFIG_LINK
18065	–	#
14780
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;}
14781
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 ;;
14782		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	–	;;
14783
18090	–	esac
14784
18092	–
14785		case $ac_file$ac_mode in
14786		"make/Makefile":F) chmod 0755 scripts/* ;;
14787		"src/utils/Makefile":F) chmod 0755 scripts/* ;;

Diff Legend

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