ViewVC Help

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

root/svn/ircd-hybrid/trunk/configure

Comparing ircd-hybrid/trunk/configure (file contents):
Revision 2318 by michael, Fri Jun 21 17:47:52 2013 UTC vs.
Revision 4360 by michael, Sat Aug 2 20:40:29 2014 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2	<	# From configure.ac Id: configure.ac 2228 2013-06-13 19:46:30Z michael .
2	>	# From configure.ac Id: configure.ac 4359 2014-08-02 20:37:47Z michael .
3		# Guess values for system-dependent variables and create Makefiles.
4		# Generated by GNU Autoconf 2.69 for ircd-hybrid TRUNK.
5		#
#	Line 805 | Line 805 | with_included_ltdl
805		with_ltdl_include
806		with_ltdl_lib
807		enable_ltdl_install
808	<	enable_libGeoIP
808	>	enable_libgeoip
809		enable_openssl
810		enable_assert
811		enable_kqueue
812		enable_epoll
813		enable_devpoll
814		enable_poll
815	–	enable_select
816	–	enable_halfops
815		enable_debugging
816		enable_warnings
817		'
#	Line 1469 | Line 1467 | Optional Features:
1467		--enable-epoll          Force epoll usage.
1468		--enable-devpoll        Force devpoll usage.
1469		--enable-poll           Force poll usage.
1472	–	--enable-select         Force select usage.
1473	–	--enable-halfops        Enable halfops support.
1470		--enable-debugging      Enable debugging.
1471		--enable-warnings       Enable compiler warnings.
1472
#	Line 1943 | Line 1939 | $as_echo "$ac_res" >&6; }
1939
1940		} # ac_fn_c_check_type
1941
1946	–	# ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
1947	–	# --------------------------------------------
1948	–	# Tries to find the compile-time value of EXPR in a program that includes
1949	–	# INCLUDES, setting VAR accordingly. Returns whether the value could be
1950	–	# computed
1951	–	ac_fn_c_compute_int ()
1952	–	{
1953	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1954	–	if test "$cross_compiling" = yes; then
1955	–	# Depending upon the size, compute the lo and hi bounds.
1956	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1957	–	/* end confdefs.h.  */
1958	–	$4
1959	–	int
1960	–	main ()
1961	–	{
1962	–	static int test_array [1 - 2 * !(($2) >= 0)];
1963	–	test_array [0] = 0;
1964	–	return test_array [0];
1965	–
1966	–	;
1967	–	return 0;
1968	–	}
1969	–	_ACEOF
1970	–	if ac_fn_c_try_compile "$LINENO"; then :
1971	–	ac_lo=0 ac_mid=0
1972	–	while :; do
1973	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1974	–	/* end confdefs.h.  */
1975	–	$4
1976	–	int
1977	–	main ()
1978	–	{
1979	–	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1980	–	test_array [0] = 0;
1981	–	return test_array [0];
1982	–
1983	–	;
1984	–	return 0;
1985	–	}
1986	–	_ACEOF
1987	–	if ac_fn_c_try_compile "$LINENO"; then :
1988	–	ac_hi=$ac_mid; break
1989	–	else
1990	–	as_fn_arith $ac_mid + 1 && ac_lo=$as_val
1991	–	if test $ac_lo -le $ac_mid; then
1992	–	ac_lo= ac_hi=
1993	–	break
1994	–	fi
1995	–	as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
1996	–	fi
1997	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1998	–	done
1999	–	else
2000	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2001	–	/* end confdefs.h.  */
2002	–	$4
2003	–	int
2004	–	main ()
2005	–	{
2006	–	static int test_array [1 - 2 * !(($2) < 0)];
2007	–	test_array [0] = 0;
2008	–	return test_array [0];
2009	–
2010	–	;
2011	–	return 0;
2012	–	}
2013	–	_ACEOF
2014	–	if ac_fn_c_try_compile "$LINENO"; then :
2015	–	ac_hi=-1 ac_mid=-1
2016	–	while :; do
2017	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2018	–	/* end confdefs.h.  */
2019	–	$4
2020	–	int
2021	–	main ()
2022	–	{
2023	–	static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2024	–	test_array [0] = 0;
2025	–	return test_array [0];
2026	–
2027	–	;
2028	–	return 0;
2029	–	}
2030	–	_ACEOF
2031	–	if ac_fn_c_try_compile "$LINENO"; then :
2032	–	ac_lo=$ac_mid; break
2033	–	else
2034	–	as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2035	–	if test $ac_mid -le $ac_hi; then
2036	–	ac_lo= ac_hi=
2037	–	break
2038	–	fi
2039	–	as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2040	–	fi
2041	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2042	–	done
2043	–	else
2044	–	ac_lo= ac_hi=
2045	–	fi
2046	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2047	–	fi
2048	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2049	–	# Binary search between lo and hi bounds.
2050	–	while test "x$ac_lo" != "x$ac_hi"; do
2051	–	as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2052	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2053	–	/* end confdefs.h.  */
2054	–	$4
2055	–	int
2056	–	main ()
2057	–	{
2058	–	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2059	–	test_array [0] = 0;
2060	–	return test_array [0];
2061	–
2062	–	;
2063	–	return 0;
2064	–	}
2065	–	_ACEOF
2066	–	if ac_fn_c_try_compile "$LINENO"; then :
2067	–	ac_hi=$ac_mid
2068	–	else
2069	–	as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2070	–	fi
2071	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2072	–	done
2073	–	case $ac_lo in #((
2074	–	?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2075	–	'') ac_retval=1 ;;
2076	–	esac
2077	–	else
2078	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2079	–	/* end confdefs.h.  */
2080	–	$4
2081	–	static long int longval () { return $2; }
2082	–	static unsigned long int ulongval () { return $2; }
2083	–	#include <stdio.h>
2084	–	#include <stdlib.h>
2085	–	int
2086	–	main ()
2087	–	{
2088	–
2089	–	FILE *f = fopen ("conftest.val", "w");
2090	–	if (! f)
2091	–	return 1;
2092	–	if (($2) < 0)
2093	–	{
2094	–	long int i = longval ();
2095	–	if (i != ($2))
2096	–	return 1;
2097	–	fprintf (f, "%ld", i);
2098	–	}
2099	–	else
2100	–	{
2101	–	unsigned long int i = ulongval ();
2102	–	if (i != ($2))
2103	–	return 1;
2104	–	fprintf (f, "%lu", i);
2105	–	}
2106	–	/* Do not output a trailing newline, as this causes \r\n confusion
2107	–	on some platforms.  */
2108	–	return ferror (f) || fclose (f) != 0;
2109	–
2110	–	;
2111	–	return 0;
2112	–	}
2113	–	_ACEOF
2114	–	if ac_fn_c_try_run "$LINENO"; then :
2115	–	echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2116	–	else
2117	–	ac_retval=1
2118	–	fi
2119	–	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2120	–	conftest.$ac_objext conftest.beam conftest.$ac_ext
2121	–	rm -f conftest.val
2122	–
2123	–	fi
2124	–	eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2125	–	as_fn_set_status $ac_retval
2126	–
2127	–	} # ac_fn_c_compute_int
2128	–
1942		# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES
1943		# ----------------------------------------------------
1944		# Tries to find if the field MEMBER exists in type AGGR, after including
#	Line 2636 | Line 2449 | ac_link='$CC -o conftest$ac_exeext $CFLA
2449		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2450
2451
2452	<	am__api_version='1.13'
2452	>	am__api_version='1.14'
2453
2454		ac_aux_dir=
2455		for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
#	Line 3202 | Line 3015 | am__tar='$${TAR-tar} chof - "$$tardir"'
3015
3016
3017
3018	+	# POSIX will say in a future version that running "rm -f" with no argument
3019	+	# is OK; and we want to be able to make that assumption in our Makefile
3020	+	# recipes.  So use an aggressive probe to check that the usage we want is
3021	+	# actually supported "in the wild" to an acceptable degree.
3022	+	# See automake bug#10828.
3023	+	# To make any issue more visible, cause the running configure to be aborted
3024	+	# by default if the 'rm' program in use doesn't match our expectations; the
3025	+	# user can still override this though.
3026	+	if rm -f && rm -fr && rm -rf; then : OK; else
3027	+	cat >&2 <<'END'
3028	+	Oops!
3029	+
3030	+	Your 'rm' program seems unable to run without file operands specified
3031	+	on the command line, even when the '-f' option is present.  This is contrary
3032	+	to the behaviour of most rm programs out there, and not conforming with
3033	+	the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
3034	+
3035	+	Please tell bug-automake@gnu.org about your system, including the value
3036	+	of your $PATH and any error possibly output before this message.  This
3037	+	can help us improve future automake versions.
3038	+
3039	+	END
3040	+	if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
3041	+	echo 'Configuration will proceed anyway, since you have set the' >&2
3042	+	echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
3043	+	echo >&2
3044	+	else
3045	+	cat >&2 <<'END'
3046	+	Aborting the configuration process, to ensure you take notice of the issue.
3047	+
3048	+	You can download and install GNU coreutils to get an 'rm' implementation
3049	+	that behaves properly: <http://www.gnu.org/software/coreutils/>.
3050	+
3051	+	If you want to complete the configuration process using your problematic
3052	+	'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
3053	+	to "yes", and re-run configure.
3054	+
3055	+	END
3056	+	as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
3057	+	fi
3058	+	fi
3059
3060		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
3061		$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
#	Line 3225 | Line 3079 | fi
3079		MAINT=$MAINTAINER_MODE_TRUE
3080
3081
3082	+
3083		ac_config_headers="$ac_config_headers config.h"
3084
3085
#	Line 4082 | Line 3937 | ac_compile='$CC -c $CFLAGS $CPPFLAGS con
3937		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3938		ac_compiler_gnu=$ac_cv_c_compiler_gnu
3939
3940	+	ac_ext=c
3941	+	ac_cpp='$CPP $CPPFLAGS'
3942	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3943	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3944	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3945	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
3946	+	$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
3947	+	if ${am_cv_prog_cc_c_o+:} false; then :
3948	+	$as_echo_n "(cached) " >&6
3949	+	else
3950	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3951	+	/* end confdefs.h.  */
3952	+
3953	+	int
3954	+	main ()
3955	+	{
3956	+
3957	+	;
3958	+	return 0;
3959	+	}
3960	+	_ACEOF
3961	+	# Make sure it works both with $CC and with simple cc.
3962	+	# Following AC_PROG_CC_C_O, we do the test twice because some
3963	+	# compilers refuse to overwrite an existing .o file with -o,
3964	+	# though they will create one.
3965	+	am_cv_prog_cc_c_o=yes
3966	+	for am_i in 1 2; do
3967	+	if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
3968	+	($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
3969	+	ac_status=$?
3970	+	echo "$as_me:$LINENO: \$? = $ac_status" >&5
3971	+	(exit $ac_status); } \
3972	+	&& test -f conftest2.$ac_objext; then
3973	+	: OK
3974	+	else
3975	+	am_cv_prog_cc_c_o=no
3976	+	break
3977	+	fi
3978	+	done
3979	+	rm -f core conftest*
3980	+	unset am_i
3981	+	fi
3982	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
3983	+	$as_echo "$am_cv_prog_cc_c_o" >&6; }
3984	+	if test "$am_cv_prog_cc_c_o" != yes; then
3985	+	# Losing compiler, so override with the script.
3986	+	# FIXME: It is wrong to rewrite CC.
3987	+	# But if we don't then we get into trouble of one sort or another.
3988	+	# A longer-term fix would be to have automake use am__CC in this case,
3989	+	# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
3990	+	CC="$am_aux_dir/compile $CC"
3991	+	fi
3992	+	ac_ext=c
3993	+	ac_cpp='$CPP $CPPFLAGS'
3994	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3995	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3996	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3997	+
3998	+
3999		depcc="$CC"   am_compiler_list=
4000
4001		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
#	Line 8642 | Line 8556 | _lt_linker_boilerplate=`cat conftest.err
8556		$RM -r conftest*
8557
8558
8559	+	## CAVEAT EMPTOR:
8560	+	## There is no encapsulation within the following macros, do not change
8561	+	## the running order or otherwise move them around unless you know exactly
8562	+	## what you are doing...
8563		if test -n "$compiler"; then
8564
8565		lt_prog_compiler_no_builtin_flag=
#	Line 13253 | Line 13171 | eval "LTDLOPEN=\"$libname_spec\""
13171
13172		LIBTOOL="$LIBTOOL --silent"
13173
13174	<	# The cast to long int works around a bug in the HP C Compiler
13257	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13258	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13259	<	# This bug is HP SR number 8606223364.
13260	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13261	<	$as_echo_n "checking size of short... " >&6; }
13262	<	if ${ac_cv_sizeof_short+:} false; then :
13263	<	$as_echo_n "(cached) " >&6
13264	<	else
13265	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
13266	<
13267	<	else
13268	<	if test "$ac_cv_type_short" = yes; then
13269	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13270	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13271	<	as_fn_error 77 "cannot compute sizeof (short)
13272	<	See \`config.log' for more details" "$LINENO" 5; }
13273	<	else
13274	<	ac_cv_sizeof_short=0
13275	<	fi
13276	<	fi
13277	<
13278	<	fi
13279	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13280	<	$as_echo "$ac_cv_sizeof_short" >&6; }
13281	<
13282	<
13283	<
13284	<	cat >>confdefs.h <<_ACEOF
13285	<	#define SIZEOF_SHORT $ac_cv_sizeof_short
13286	<	_ACEOF
13287	<
13288	<
13289	<	# The cast to long int works around a bug in the HP C Compiler
13290	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13291	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13292	<	# This bug is HP SR number 8606223364.
13293	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
13294	<	$as_echo_n "checking size of int... " >&6; }
13295	<	if ${ac_cv_sizeof_int+:} false; then :
13296	<	$as_echo_n "(cached) " >&6
13297	<	else
13298	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
13299	<
13300	<	else
13301	<	if test "$ac_cv_type_int" = yes; then
13302	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13303	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13304	<	as_fn_error 77 "cannot compute sizeof (int)
13305	<	See \`config.log' for more details" "$LINENO" 5; }
13306	<	else
13307	<	ac_cv_sizeof_int=0
13308	<	fi
13309	<	fi
13310	<
13311	<	fi
13312	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
13313	<	$as_echo "$ac_cv_sizeof_int" >&6; }
13314	<
13315	<
13316	<
13317	<	cat >>confdefs.h <<_ACEOF
13318	<	#define SIZEOF_INT $ac_cv_sizeof_int
13319	<	_ACEOF
13320	<
13321	<
13322	<	# The cast to long int works around a bug in the HP C Compiler
13323	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13324	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13325	<	# This bug is HP SR number 8606223364.
13326	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
13327	<	$as_echo_n "checking size of long... " >&6; }
13328	<	if ${ac_cv_sizeof_long+:} false; then :
13329	<	$as_echo_n "(cached) " >&6
13330	<	else
13331	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
13332	<
13333	<	else
13334	<	if test "$ac_cv_type_long" = yes; then
13335	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13336	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13337	<	as_fn_error 77 "cannot compute sizeof (long)
13338	<	See \`config.log' for more details" "$LINENO" 5; }
13339	<	else
13340	<	ac_cv_sizeof_long=0
13341	<	fi
13342	<	fi
13343	<
13344	<	fi
13345	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13346	<	$as_echo "$ac_cv_sizeof_long" >&6; }
13347	<
13348	<
13349	<
13350	<	cat >>confdefs.h <<_ACEOF
13351	<	#define SIZEOF_LONG $ac_cv_sizeof_long
13352	<	_ACEOF
13174	>	# Checks for libraries.
13175
13176
13177	<	# The cast to long int works around a bug in the HP C Compiler
13178	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13179	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13180	<	# This bug is HP SR number 8606223364.
13359	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of void *" >&5
13360	<	$as_echo_n "checking size of void *... " >&6; }
13361	<	if ${ac_cv_sizeof_void_p+:} false; then :
13177	>	if test "X$CC" != "X"; then
13178	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
13179	>	$as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
13180	>	if ${ssp_cv_cc+:} false; then :
13181		$as_echo_n "(cached) " >&6
13182		else
13183	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (void *))" "ac_cv_sizeof_void_p"        "$ac_includes_default"; then :
13184	<
13185	<	else
13186	<	if test "$ac_cv_type_void_p" = yes; then
13368	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13369	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13370	<	as_fn_error 77 "cannot compute sizeof (void *)
13371	<	See \`config.log' for more details" "$LINENO" 5; }
13372	<	else
13373	<	ac_cv_sizeof_void_p=0
13374	<	fi
13375	<	fi
13376	<
13377	<	fi
13378	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_void_p" >&5
13379	<	$as_echo "$ac_cv_sizeof_void_p" >&6; }
13380	<
13183	>	ssp_old_cflags="$CFLAGS"
13184	>	CFLAGS="$CFLAGS -fstack-protector"
13185	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13186	>	/* end confdefs.h.  */
13187
13188	+	int
13189	+	main ()
13190	+	{
13191
13192	<	cat >>confdefs.h <<_ACEOF
13193	<	#define SIZEOF_VOID_P $ac_cv_sizeof_void_p
13192	>	;
13193	>	return 0;
13194	>	}
13195		_ACEOF
13196	<
13197	<
13388	<	# The cast to long int works around a bug in the HP C Compiler
13389	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13390	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13391	<	# This bug is HP SR number 8606223364.
13392	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int64_t" >&5
13393	<	$as_echo_n "checking size of int64_t... " >&6; }
13394	<	if ${ac_cv_sizeof_int64_t+:} false; then :
13395	<	$as_echo_n "(cached) " >&6
13396	<	else
13397	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int64_t))" "ac_cv_sizeof_int64_t"        "$ac_includes_default"; then :
13398	<
13196	>	if ac_fn_c_try_compile "$LINENO"; then :
13197	>	ssp_cv_cc=yes
13198		else
13199	<	if test "$ac_cv_type_int64_t" = yes; then
13401	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13402	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13403	<	as_fn_error 77 "cannot compute sizeof (int64_t)
13404	<	See \`config.log' for more details" "$LINENO" 5; }
13405	<	else
13406	<	ac_cv_sizeof_int64_t=0
13407	<	fi
13199	>	ssp_cv_cc=no
13200		fi
13201	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13202	+	CFLAGS="$ssp_old_cflags"
13203
13204		fi
13205	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int64_t" >&5
13206	<	$as_echo "$ac_cv_sizeof_int64_t" >&6; }
13205	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
13206	>	$as_echo "$ssp_cv_cc" >&6; }
13207	>	if test $ssp_cv_cc = yes; then
13208	>	CFLAGS="$CFLAGS -fstack-protector"
13209
13210	+	$as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
13211
13212	<
13213	<	cat >>confdefs.h <<_ACEOF
13417	<	#define SIZEOF_INT64_T $ac_cv_sizeof_int64_t
13418	<	_ACEOF
13212	>	fi
13213	>	fi
13214
13215
13216	<	# The cast to long int works around a bug in the HP C Compiler
13217	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13218	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13424	<	# This bug is HP SR number 8606223364.
13425	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5
13426	<	$as_echo_n "checking size of long long... " >&6; }
13427	<	if ${ac_cv_sizeof_long_long+:} false; then :
13216	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
13217	>	$as_echo_n "checking whether libssp exists... " >&6; }
13218	>	if ${ssp_cv_lib+:} false; then :
13219		$as_echo_n "(cached) " >&6
13220		else
13221	<	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long long))" "ac_cv_sizeof_long_long"        "$ac_includes_default"; then :
13222	<
13223	<	else
13224	<	if test "$ac_cv_type_long_long" = yes; then
13434	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13435	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13436	<	as_fn_error 77 "cannot compute sizeof (long long)
13437	<	See \`config.log' for more details" "$LINENO" 5; }
13438	<	else
13439	<	ac_cv_sizeof_long_long=0
13440	<	fi
13441	<	fi
13442	<
13443	<	fi
13444	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long" >&5
13445	<	$as_echo "$ac_cv_sizeof_long_long" >&6; }
13446	<
13447	<
13448	<
13449	<	cat >>confdefs.h <<_ACEOF
13450	<	#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
13451	<	_ACEOF
13452	<
13453	<
13454	<
13455	<	if test "$ac_cv_sizeof_int" = 2 ; then
13456	<	ac_fn_c_check_type "$LINENO" "int16_t" "ac_cv_type_int16_t" "$ac_includes_default"
13457	<	if test "x$ac_cv_type_int16_t" = xyes; then :
13458	<
13459	<	else
13460	<
13461	<	cat >>confdefs.h <<_ACEOF
13462	<	#define int16_t int
13463	<	_ACEOF
13464	<
13465	<	fi
13466	<
13467	<	ac_fn_c_check_type "$LINENO" "uint16_t" "ac_cv_type_uint16_t" "$ac_includes_default"
13468	<	if test "x$ac_cv_type_uint16_t" = xyes; then :
13469	<
13470	<	else
13471	<
13472	<	cat >>confdefs.h <<_ACEOF
13473	<	#define uint16_t unsigned int
13474	<	_ACEOF
13475	<
13476	<	fi
13477	<
13478	<	elif test "$ac_cv_sizeof_short" = 2 ; then
13479	<	ac_fn_c_check_type "$LINENO" "int16_t" "ac_cv_type_int16_t" "$ac_includes_default"
13480	<	if test "x$ac_cv_type_int16_t" = xyes; then :
13481	<
13482	<	else
13483	<
13484	<	cat >>confdefs.h <<_ACEOF
13485	<	#define int16_t short
13486	<	_ACEOF
13487	<
13488	<	fi
13489	<
13490	<	ac_fn_c_check_type "$LINENO" "uint16_t" "ac_cv_type_uint16_t" "$ac_includes_default"
13491	<	if test "x$ac_cv_type_uint16_t" = xyes; then :
13492	<
13493	<	else
13494	<
13495	<	cat >>confdefs.h <<_ACEOF
13496	<	#define uint16_t unsigned short
13497	<	_ACEOF
13498	<
13499	<	fi
13500	<
13501	<	else
13502	<	as_fn_error $? "Cannot find a type with size of 16 bits" "$LINENO" 5
13503	<	fi
13504	<	if test "$ac_cv_sizeof_int" = 4 ; then
13505	<	ac_fn_c_check_type "$LINENO" "int32_t" "ac_cv_type_int32_t" "$ac_includes_default"
13506	<	if test "x$ac_cv_type_int32_t" = xyes; then :
13221	>	ssp_old_libs="$LIBS"
13222	>	LIBS="$LIBS -lssp"
13223	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13224	>	/* end confdefs.h.  */
13225
13226	<	else
13226	>	int
13227	>	main ()
13228	>	{
13229
13230	<	cat >>confdefs.h <<_ACEOF
13231	<	#define int32_t int
13230	>	;
13231	>	return 0;
13232	>	}
13233		_ACEOF
13234	<
13235	<	fi
13515	<
13516	<	ac_fn_c_check_type "$LINENO" "uint32_t" "ac_cv_type_uint32_t" "$ac_includes_default"
13517	<	if test "x$ac_cv_type_uint32_t" = xyes; then :
13518	<
13234	>	if ac_fn_c_try_link "$LINENO"; then :
13235	>	ssp_cv_lib=yes
13236		else
13237	<
13521	<	cat >>confdefs.h <<_ACEOF
13522	<	#define uint32_t unsigned int
13523	<	_ACEOF
13524	<
13237	>	ssp_cv_lib=no
13238		fi
13239	<
13240	<	elif test "$ac_cv_sizeof_short" = 4 ; then
13241	<	ac_fn_c_check_type "$LINENO" "int32_t" "ac_cv_type_int32_t" "$ac_includes_default"
13529	<	if test "x$ac_cv_type_int32_t" = xyes; then :
13530	<
13531	<	else
13532	<
13533	<	cat >>confdefs.h <<_ACEOF
13534	<	#define int32_t short
13535	<	_ACEOF
13239	>	rm -f core conftest.err conftest.$ac_objext \
13240	>	conftest$ac_exeext conftest.$ac_ext
13241	>	LIBS="$ssp_old_libs"
13242
13243		fi
13244	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
13245	+	$as_echo "$ssp_cv_lib" >&6; }
13246	+	if test $ssp_cv_lib = yes; then
13247	+	LIBS="$LIBS -lssp"
13248	+	fi
13249
13539	–	ac_fn_c_check_type "$LINENO" "uint32_t" "ac_cv_type_uint32_t" "$ac_includes_default"
13540	–	if test "x$ac_cv_type_uint32_t" = xyes; then :
13250
13542	–	else
13251
13544	–	cat >>confdefs.h <<_ACEOF
13545	–	#define uint32_t unsigned short
13546	–	_ACEOF
13252
13548	–	fi
13253
13550	–	elif test "$ac_cv_sizeof_long" = 4 ; then
13551	–	ac_fn_c_check_type "$LINENO" "int32_t" "ac_cv_type_int32_t" "$ac_includes_default"
13552	–	if test "x$ac_cv_type_int32_t" = xyes; then :
13254
13255	+	for flag in -fno-strict-aliasing; do
13256	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13257	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13258	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13259	+	if eval \${$as_CACHEVAR+:} false; then :
13260	+	$as_echo_n "(cached) " >&6
13261		else
13262
13263	<	cat >>confdefs.h <<_ACEOF
13264	<	#define int32_t long
13265	<	_ACEOF
13266	<
13560	<	fi
13561	<
13562	<	ac_fn_c_check_type "$LINENO" "uint32_t" "ac_cv_type_uint32_t" "$ac_includes_default"
13563	<	if test "x$ac_cv_type_uint32_t" = xyes; then :
13263	>	ax_check_save_flags=$CFLAGS
13264	>	CFLAGS="$CFLAGS  $flag"
13265	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13266	>	/* end confdefs.h.  */
13267
13268	<	else
13268	>	int
13269	>	main ()
13270	>	{
13271
13272	<	cat >>confdefs.h <<_ACEOF
13273	<	#define uint32_t unsigned long
13272	>	;
13273	>	return 0;
13274	>	}
13275		_ACEOF
13276	<
13277	<	fi
13572	<
13276	>	if ac_fn_c_try_compile "$LINENO"; then :
13277	>	eval "$as_CACHEVAR=yes"
13278		else
13279	<	as_fn_error $? "Cannot find a type with size of 32 bits" "$LINENO" 5
13575	<	fi
13576	<	if test "$ac_cv_sizeof_int64_t" = 8 ; then
13577	<	ac_fn_c_check_type "$LINENO" "int64_t" "ac_cv_type_int64_t" "$ac_includes_default"
13578	<	if test "x$ac_cv_type_int64_t" = xyes; then :
13579	<
13279	>	eval "$as_CACHEVAR=no"
13280		fi
13281	<
13282	<	ac_fn_c_check_type "$LINENO" "uint64_t" "ac_cv_type_uint64_t" "$ac_includes_default"
13583	<	if test "x$ac_cv_type_uint64_t" = xyes; then :
13584	<
13585	<	fi
13586	<
13587	<	elif test "$ac_cv_sizeof_long_long" = 8 ; then
13588	<	ac_fn_c_check_type "$LINENO" "int64_t" "ac_cv_type_int64_t" "$ac_includes_default"
13589	<	if test "x$ac_cv_type_int64_t" = xyes; then :
13590	<
13591	<	else
13592	<
13593	<	cat >>confdefs.h <<_ACEOF
13594	<	#define int64_t long long
13595	<	_ACEOF
13596	<
13281	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13282	>	CFLAGS=$ax_check_save_flags
13283		fi
13284	<
13285	<	ac_fn_c_check_type "$LINENO" "uint64_t" "ac_cv_type_uint64_t" "$ac_includes_default"
13286	<	if test "x$ac_cv_type_uint64_t" = xyes; then :
13287	<
13284	>	eval ac_res=\$$as_CACHEVAR
13285	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13286	>	$as_echo "$ac_res" >&6; }
13287	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
13288	>	if ${CFLAGS+:} false; then :
13289	>	case " $CFLAGS " in
13290	>	*" $flag "*)
13291	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13292	>	(: CFLAGS already contains $flag) 2>&5
13293	>	ac_status=$?
13294	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13295	>	test $ac_status = 0; }
13296	>	;;
13297	>	*)
13298	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
13299	>	(: CFLAGS="$CFLAGS $flag") 2>&5
13300	>	ac_status=$?
13301	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13302	>	test $ac_status = 0; }
13303	>	CFLAGS="$CFLAGS $flag"
13304	>	;;
13305	>	esac
13306		else
13307	<
13604	<	cat >>confdefs.h <<_ACEOF
13605	<	#define uint64_t unsigned long long
13606	<	_ACEOF
13607	<
13307	>	CFLAGS="$flag"
13308		fi
13309
13310		else
13311	<	as_fn_error $? "Cannot find a type with size of 64 bits" "$LINENO" 5
13311	>	:
13312		fi
13313
13314	+	done
13315
13615	–	# Checks for libraries.
13316
13317		ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
13318		if test "x$ac_cv_func_getaddrinfo" = xyes; then :
#	Line 13796 | Line 13496 | else
13496		as_fn_error $? "socket library not found" "$LINENO" 5
13497		fi
13498
13499	+	ac_fn_c_check_type "$LINENO" "struct sockaddr_in6" "ac_cv_type_struct_sockaddr_in6" "#include <netinet/in.h>
13500	+	"
13501	+	if test "x$ac_cv_type_struct_sockaddr_in6" = xyes; then :
13502	+
13503	+	$as_echo "#define IPV6 1" >>confdefs.h
13504	+
13505	+	fi
13506	+
13507		ac_fn_c_check_type "$LINENO" "struct sockaddr_in" "ac_cv_type_struct_sockaddr_in" "#include <sys/types.h>
13508		#include <sys/socket.h>
13509		#include <netdb.h>
#	Line 13850 | Line 13558 | fi
13558
13559
13560
13853	–	ac_fn_c_check_type "$LINENO" "struct sockaddr_in6" "ac_cv_type_struct_sockaddr_in6" "#include <netinet/in.h>
13854	–	"
13855	–	if test "x$ac_cv_type_struct_sockaddr_in6" = xyes; then :
13856	–
13857	–	$as_echo "#define IPV6 1" >>confdefs.h
13858	–
13859	–	fi
13860	–
13861	–
13862	–
13561		# Checks for typedefs, structures, and compiler characteristics.
13562		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
13563		$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
#	Line 14203 | Line 13901 | if test "$ac_res" != no; then :
13901		fi
13902
13903
13904	<	# Check whether --enable-libGeoIP was given.
13905	<	if test "${enable_libGeoIP+set}" = set; then :
13906	<	enableval=$enable_libGeoIP;
13904	>	# Check whether --enable-libgeoip was given.
13905	>	if test "${enable_libgeoip+set}" = set; then :
13906	>	enableval=$enable_libgeoip;
13907		else
13908		ac_fn_c_check_header_mongrel "$LINENO" "GeoIP.h" "ac_cv_header_GeoIP_h" "$ac_includes_default"
13909		if test "x$ac_cv_header_GeoIP_h" = xyes; then :
#	Line 14273 | Line 13971 | fi
13971		fi
13972
13973
13974	+
13975		# Check whether --enable-openssl was given.
13976		if test "${enable_openssl+set}" = set; then :
13977		enableval=$enable_openssl;  cf_enable_openssl=$enableval
#	Line 14327 | Line 14026 | $as_echo "disabled" >&6; }
14026		fi
14027
14028		if test "$cf_enable_openssl" != "no"; then :
14029	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenSSL 0.9.8 or above" >&5
14030	<	$as_echo_n "checking for OpenSSL 0.9.8 or above... " >&6; }
14029	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenSSL 0.9.8o or above" >&5
14030	>	$as_echo_n "checking for OpenSSL 0.9.8o or above... " >&6; }
14031		if test "$cross_compiling" = yes; then :
14032		cf_openssl_version_ok=no
14033		else
#	Line 14341 | Line 14040 | else
14040		int
14041		main ()
14042		{
14043	<	exit(!(OPENSSL_VERSION_NUMBER >= 0x00908000));
14043	>	exit(!(OPENSSL_VERSION_NUMBER >= 0x009080ffL));
14044		;
14045		return 0;
14046		}
#	Line 14529 | Line 14228 | $as_echo "#define MP_CHUNK_SIZE_IP_ENTRY
14228
14229		# Argument processing.
14230
14231	<	desired_iopoll_mechanism="none"
14232	<	# Check whether --enable-kqueue was given.
14231	>	desired_iopoll_mechanism="none"
14232	>
14233	>	# Check whether --enable-kqueue was given.
14234		if test "${enable_kqueue+set}" = set; then :
14235		enableval=$enable_kqueue; desired_iopoll_mechanism="kqueue"
14236		fi
#	Line 14550 | Line 14250 | if test "${enable_poll+set}" = set; then
14250		enableval=$enable_poll; desired_iopoll_mechanism="poll"
14251		fi
14252
14553	–	# Check whether --enable-select was given.
14554	–	if test "${enable_select+set}" = set; then :
14555	–	enableval=$enable_select; desired_iopoll_mechanism="select"
14556	–	fi
14253
14254	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for optimal/desired iopoll mechanism" >&5
14254	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for optimal/desired iopoll mechanism" >&5
14255		$as_echo_n "checking for optimal/desired iopoll mechanism... " >&6; }
14256	+
14257		iopoll_mechanism_none=0
14258
14259		cat >>confdefs.h <<_ACEOF
14260		#define __IOPOLL_MECHANISM_NONE $iopoll_mechanism_none
14261		_ACEOF
14262
14263	<	iopoll_mechanism_kqueue=1
14263	>
14264	>	iopoll_mechanism_kqueue=1
14265
14266		cat >>confdefs.h <<_ACEOF
14267		#define __IOPOLL_MECHANISM_KQUEUE $iopoll_mechanism_kqueue
#	Line 14617 | Line 14315 | else
14315		fi
14316		rm -f core conftest.err conftest.$ac_objext \
14317		conftest$ac_exeext conftest.$ac_ext
14318	<	iopoll_mechanism_epoll=2
14318	>
14319	>	iopoll_mechanism_epoll=2
14320
14321		cat >>confdefs.h <<_ACEOF
14322		#define __IOPOLL_MECHANISM_EPOLL $iopoll_mechanism_epoll
14323		_ACEOF
14324
14626	–	if test "$cross_compiling" = yes; then :
14627	–	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14628	–	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14629	–	as_fn_error $? "cannot run test program while cross compiling
14630	–	See \`config.log' for more details" "$LINENO" 5; }
14631	–	else
14325		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14326		/* end confdefs.h.  */
14634	–
14327		#include <sys/epoll.h>
14636	–	#include <sys/syscall.h>
14637	–	#if defined(__stub_epoll_create) || defined(__stub___epoll_create) || defined(EPOLL_NEED_BODY)
14638	–	#if !defined(__NR_epoll_create)
14639	–	#if defined(__ia64__)
14640	–	#define __NR_epoll_create 1243
14641	–	#elif defined(__x86_64__)
14642	–	#define __NR_epoll_create 214
14643	–	#elif defined(__sparc64__) || defined(__sparc__)
14644	–	#define __NR_epoll_create 193
14645	–	#elif defined(__s390__) || defined(__m68k__)
14646	–	#define __NR_epoll_create 249
14647	–	#elif defined(__ppc64__) || defined(__ppc__)
14648	–	#define __NR_epoll_create 236
14649	–	#elif defined(__parisc__) || defined(__arm26__) || defined(__arm__)
14650	–	#define __NR_epoll_create 224
14651	–	#elif defined(__alpha__)
14652	–	#define __NR_epoll_create 407
14653	–	#elif defined(__sh64__)
14654	–	#define __NR_epoll_create 282
14655	–	#elif defined(__i386__) || defined(__sh__) || defined(__m32r__) || defined(__h8300__) || defined(__frv__)
14656	–	#define __NR_epoll_create 254
14657	–	#else
14658	–	#error No system call numbers defined for epoll family.
14659	–	#endif
14660	–	#endif
14661	–	_syscall1(int, epoll_create, int, size)
14662	–	#endif
14663	–
14328		int
14329		main ()
14330		{
14331	<	return epoll_create(256) == -1 ? 1 : 0
14331	>	epoll_create(256);
14332		;
14333		return 0;
14334		}
14335		_ACEOF
14336	<	if ac_fn_c_try_run "$LINENO"; then :
14336	>	if ac_fn_c_try_link "$LINENO"; then :
14337		is_epoll_mechanism_available="yes"
14338		else
14339		is_epoll_mechanism_available="no"
14340		fi
14341	<	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
14342	<	conftest.$ac_objext conftest.beam conftest.$ac_ext
14679	<	fi
14341	>	rm -f core conftest.err conftest.$ac_objext \
14342	>	conftest$ac_exeext conftest.$ac_ext
14343
14344	<	iopoll_mechanism_devpoll=3
14344	>	iopoll_mechanism_devpoll=3
14345
14346		cat >>confdefs.h <<_ACEOF
14347		#define __IOPOLL_MECHANISM_DEVPOLL $iopoll_mechanism_devpoll
#	Line 14728 | Line 14391 | rm -f core conftest.err conftest.$ac_obj
14391		$as_echo "#define HAVE_SYS_DEVPOLL_H 1" >>confdefs.h
14392
14393		fi
14394	<	iopoll_mechanism_poll=4
14394	>
14395	>	iopoll_mechanism_poll=4
14396
14397		cat >>confdefs.h <<_ACEOF
14398		#define __IOPOLL_MECHANISM_POLL $iopoll_mechanism_poll
#	Line 14782 | Line 14446 | else
14446		fi
14447		rm -f core conftest.err conftest.$ac_objext \
14448		conftest$ac_exeext conftest.$ac_ext
14785	–	iopoll_mechanism_select=5
14786	–
14787	–	cat >>confdefs.h <<_ACEOF
14788	–	#define __IOPOLL_MECHANISM_SELECT $iopoll_mechanism_select
14789	–	_ACEOF
14790	–
14791	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14792	–	/* end confdefs.h.  */
14793	–	/* Define select to an innocuous variant, in case <limits.h> declares select.
14794	–	For example, HP-UX 11i <limits.h> declares gettimeofday.  */
14795	–	#define select innocuous_select
14796	–
14797	–	/* System header to define __stub macros and hopefully few prototypes,
14798	–	which can conflict with char select (); below.
14799	–	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
14800	–	<limits.h> exists even on freestanding compilers.  */
14801	–
14802	–	#ifdef __STDC__
14803	–	# include <limits.h>
14804	–	#else
14805	–	# include <assert.h>
14806	–	#endif
14807	–
14808	–	#undef select
14809	–
14810	–	/* Override any GCC internal prototype to avoid an error.
14811	–	Use char because int might match the return type of a GCC
14812	–	builtin and then its argument prototype would still apply.  */
14813	–	#ifdef __cplusplus
14814	–	extern "C"
14815	–	#endif
14816	–	char select ();
14817	–	/* The GNU C library defines this for functions which it implements
14818	–	to always fail with ENOSYS.  Some functions are actually named
14819	–	something starting with __ and the normal name is an alias.  */
14820	–	#if defined __stub_select || defined __stub___select
14821	–	choke me
14822	–	#endif
14449
14450	<	int
14451	<	main ()
14826	<	{
14827	<	return select ();
14828	<	;
14829	<	return 0;
14830	<	}
14831	<	_ACEOF
14832	<	if ac_fn_c_try_link "$LINENO"; then :
14833	<	is_select_mechanism_available="yes"
14834	<	else
14835	<	is_select_mechanism_available="no"
14836	<	fi
14837	<	rm -f core conftest.err conftest.$ac_objext \
14838	<	conftest$ac_exeext conftest.$ac_ext
14839	<	optimal_iopoll_mechanism="none"
14840	<	for mechanism in "kqueue" "epoll" "devpoll" "poll" "select" ; do # order is important
14450	>	optimal_iopoll_mechanism="none"
14451	>	for mechanism in "kqueue" "epoll" "devpoll" "poll" ; do # order is important
14452		eval "is_optimal_iopoll_mechanism_available=\$is_${mechanism}_mechanism_available"
14453		if test "$is_optimal_iopoll_mechanism_available" = "yes" ; then
14454		optimal_iopoll_mechanism="$mechanism"
14455		break
14456		fi
14457		done
14458	<	if test "$desired_iopoll_mechanism" = "none" ; then
14458	>
14459	>	if test "$desired_iopoll_mechanism" = "none" ; then
14460		if test "$optimal_iopoll_mechanism" = "none" ; then
14461		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
14462		$as_echo "none" >&6; }
#	Line 14866 | Line 14478 | $as_echo "none" >&6; }
14478		as_fn_error $? "desired iopoll mechanism, $desired_iopoll_mechanism, is not available" "$LINENO" 5
14479		fi
14480		fi
14481	<	eval "use_iopoll_mechanism=\$iopoll_mechanism_${selected_iopoll_mechanism}"
14481	>
14482	>	eval "use_iopoll_mechanism=\$iopoll_mechanism_${selected_iopoll_mechanism}"
14483
14484		cat >>confdefs.h <<_ACEOF
14485		#define USE_IOPOLL_MECHANISM $use_iopoll_mechanism
#	Line 14874 | Line 14487 | _ACEOF
14487
14488
14489
14877	–	# Check whether --enable-halfops was given.
14878	–	if test "${enable_halfops+set}" = set; then :
14879	–	enableval=$enable_halfops; halfops="$enableval"
14880	–	else
14881	–	halfops="no"
14882	–	fi
14883	–
14884	–	if test "$halfops" = "yes" ; then
14885	–
14886	–	$as_echo "#define HALFOPS 1" >>confdefs.h
14887	–
14888	–	fi
14889	–
14890	–
14490		# Check whether --enable-debugging was given.
14491		if test "${enable_debugging+set}" = set; then :
14492		enableval=$enable_debugging; debugging="$enableval"
#	Line 14907 | Line 14506 | else
14506		warnings="no"
14507		fi
14508
14509	+
14510		if test "$warnings" = "yes" ; then
14511	<	CFLAGS="-Wall -Wextra -Wno-unused -Wcast-qual -Wcast-align -Wbad-function-cast -Wmissing-declarations -Wmissing-prototypes -Wnested-externs -Wredundant-decls -Wshadow -Wwrite-strings -Wundef"
14511	>
14512	>
14513	>
14514	>
14515	>	for flag in -Wall; do
14516	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14517	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14518	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14519	>	if eval \${$as_CACHEVAR+:} false; then :
14520	>	$as_echo_n "(cached) " >&6
14521	>	else
14522	>
14523	>	ax_check_save_flags=$CFLAGS
14524	>	CFLAGS="$CFLAGS  $flag"
14525	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14526	>	/* end confdefs.h.  */
14527	>
14528	>	int
14529	>	main ()
14530	>	{
14531	>
14532	>	;
14533	>	return 0;
14534	>	}
14535	>	_ACEOF
14536	>	if ac_fn_c_try_compile "$LINENO"; then :
14537	>	eval "$as_CACHEVAR=yes"
14538	>	else
14539	>	eval "$as_CACHEVAR=no"
14540	>	fi
14541	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14542	>	CFLAGS=$ax_check_save_flags
14543	>	fi
14544	>	eval ac_res=\$$as_CACHEVAR
14545	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14546	>	$as_echo "$ac_res" >&6; }
14547	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14548	>	if ${CFLAGS+:} false; then :
14549	>	case " $CFLAGS " in
14550	>	*" $flag "*)
14551	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14552	>	(: CFLAGS already contains $flag) 2>&5
14553	>	ac_status=$?
14554	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14555	>	test $ac_status = 0; }
14556	>	;;
14557	>	*)
14558	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14559	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14560	>	ac_status=$?
14561	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14562	>	test $ac_status = 0; }
14563	>	CFLAGS="$CFLAGS $flag"
14564	>	;;
14565	>	esac
14566	>	else
14567	>	CFLAGS="$flag"
14568	>	fi
14569	>
14570	>	else
14571	>	:
14572	>	fi
14573	>
14574	>	done
14575	>
14576	>
14577	>
14578	>
14579	>
14580	>	for flag in -Wextra; do
14581	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14582	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14583	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14584	>	if eval \${$as_CACHEVAR+:} false; then :
14585	>	$as_echo_n "(cached) " >&6
14586	>	else
14587	>
14588	>	ax_check_save_flags=$CFLAGS
14589	>	CFLAGS="$CFLAGS  $flag"
14590	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14591	>	/* end confdefs.h.  */
14592	>
14593	>	int
14594	>	main ()
14595	>	{
14596	>
14597	>	;
14598	>	return 0;
14599	>	}
14600	>	_ACEOF
14601	>	if ac_fn_c_try_compile "$LINENO"; then :
14602	>	eval "$as_CACHEVAR=yes"
14603	>	else
14604	>	eval "$as_CACHEVAR=no"
14605	>	fi
14606	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14607	>	CFLAGS=$ax_check_save_flags
14608	>	fi
14609	>	eval ac_res=\$$as_CACHEVAR
14610	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14611	>	$as_echo "$ac_res" >&6; }
14612	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14613	>	if ${CFLAGS+:} false; then :
14614	>	case " $CFLAGS " in
14615	>	*" $flag "*)
14616	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14617	>	(: CFLAGS already contains $flag) 2>&5
14618	>	ac_status=$?
14619	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14620	>	test $ac_status = 0; }
14621	>	;;
14622	>	*)
14623	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14624	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14625	>	ac_status=$?
14626	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14627	>	test $ac_status = 0; }
14628	>	CFLAGS="$CFLAGS $flag"
14629	>	;;
14630	>	esac
14631	>	else
14632	>	CFLAGS="$flag"
14633	>	fi
14634	>
14635	>	else
14636	>	:
14637	>	fi
14638	>
14639	>	done
14640	>
14641	>
14642	>
14643	>
14644	>
14645	>	for flag in -Wno-unused; do
14646	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14647	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14648	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14649	>	if eval \${$as_CACHEVAR+:} false; then :
14650	>	$as_echo_n "(cached) " >&6
14651	>	else
14652	>
14653	>	ax_check_save_flags=$CFLAGS
14654	>	CFLAGS="$CFLAGS  $flag"
14655	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14656	>	/* end confdefs.h.  */
14657	>
14658	>	int
14659	>	main ()
14660	>	{
14661	>
14662	>	;
14663	>	return 0;
14664	>	}
14665	>	_ACEOF
14666	>	if ac_fn_c_try_compile "$LINENO"; then :
14667	>	eval "$as_CACHEVAR=yes"
14668	>	else
14669	>	eval "$as_CACHEVAR=no"
14670	>	fi
14671	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14672	>	CFLAGS=$ax_check_save_flags
14673	>	fi
14674	>	eval ac_res=\$$as_CACHEVAR
14675	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14676	>	$as_echo "$ac_res" >&6; }
14677	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14678	>	if ${CFLAGS+:} false; then :
14679	>	case " $CFLAGS " in
14680	>	*" $flag "*)
14681	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14682	>	(: CFLAGS already contains $flag) 2>&5
14683	>	ac_status=$?
14684	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14685	>	test $ac_status = 0; }
14686	>	;;
14687	>	*)
14688	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14689	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14690	>	ac_status=$?
14691	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14692	>	test $ac_status = 0; }
14693	>	CFLAGS="$CFLAGS $flag"
14694	>	;;
14695	>	esac
14696	>	else
14697	>	CFLAGS="$flag"
14698	>	fi
14699	>
14700	>	else
14701	>	:
14702	>	fi
14703	>
14704	>	done
14705	>
14706	>
14707	>
14708	>
14709	>
14710	>	for flag in -Wcast-qual; do
14711	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14712	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14713	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14714	>	if eval \${$as_CACHEVAR+:} false; then :
14715	>	$as_echo_n "(cached) " >&6
14716	>	else
14717	>
14718	>	ax_check_save_flags=$CFLAGS
14719	>	CFLAGS="$CFLAGS  $flag"
14720	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14721	>	/* end confdefs.h.  */
14722	>
14723	>	int
14724	>	main ()
14725	>	{
14726	>
14727	>	;
14728	>	return 0;
14729	>	}
14730	>	_ACEOF
14731	>	if ac_fn_c_try_compile "$LINENO"; then :
14732	>	eval "$as_CACHEVAR=yes"
14733	>	else
14734	>	eval "$as_CACHEVAR=no"
14735	>	fi
14736	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14737	>	CFLAGS=$ax_check_save_flags
14738	>	fi
14739	>	eval ac_res=\$$as_CACHEVAR
14740	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14741	>	$as_echo "$ac_res" >&6; }
14742	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14743	>	if ${CFLAGS+:} false; then :
14744	>	case " $CFLAGS " in
14745	>	*" $flag "*)
14746	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14747	>	(: CFLAGS already contains $flag) 2>&5
14748	>	ac_status=$?
14749	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14750	>	test $ac_status = 0; }
14751	>	;;
14752	>	*)
14753	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14754	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14755	>	ac_status=$?
14756	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14757	>	test $ac_status = 0; }
14758	>	CFLAGS="$CFLAGS $flag"
14759	>	;;
14760	>	esac
14761	>	else
14762	>	CFLAGS="$flag"
14763	>	fi
14764	>
14765	>	else
14766	>	:
14767	>	fi
14768	>
14769	>	done
14770	>
14771	>
14772	>
14773	>
14774	>
14775	>	for flag in -Wcast-align; do
14776	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14777	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14778	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14779	>	if eval \${$as_CACHEVAR+:} false; then :
14780	>	$as_echo_n "(cached) " >&6
14781	>	else
14782	>
14783	>	ax_check_save_flags=$CFLAGS
14784	>	CFLAGS="$CFLAGS  $flag"
14785	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14786	>	/* end confdefs.h.  */
14787	>
14788	>	int
14789	>	main ()
14790	>	{
14791	>
14792	>	;
14793	>	return 0;
14794	>	}
14795	>	_ACEOF
14796	>	if ac_fn_c_try_compile "$LINENO"; then :
14797	>	eval "$as_CACHEVAR=yes"
14798	>	else
14799	>	eval "$as_CACHEVAR=no"
14800	>	fi
14801	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14802	>	CFLAGS=$ax_check_save_flags
14803	>	fi
14804	>	eval ac_res=\$$as_CACHEVAR
14805	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14806	>	$as_echo "$ac_res" >&6; }
14807	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14808	>	if ${CFLAGS+:} false; then :
14809	>	case " $CFLAGS " in
14810	>	*" $flag "*)
14811	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14812	>	(: CFLAGS already contains $flag) 2>&5
14813	>	ac_status=$?
14814	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14815	>	test $ac_status = 0; }
14816	>	;;
14817	>	*)
14818	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14819	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14820	>	ac_status=$?
14821	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14822	>	test $ac_status = 0; }
14823	>	CFLAGS="$CFLAGS $flag"
14824	>	;;
14825	>	esac
14826	>	else
14827	>	CFLAGS="$flag"
14828	>	fi
14829	>
14830	>	else
14831	>	:
14832	>	fi
14833	>
14834	>	done
14835	>
14836	>
14837	>
14838	>
14839	>
14840	>	for flag in -Wbad-function-cast; do
14841	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14842	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14843	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14844	>	if eval \${$as_CACHEVAR+:} false; then :
14845	>	$as_echo_n "(cached) " >&6
14846	>	else
14847	>
14848	>	ax_check_save_flags=$CFLAGS
14849	>	CFLAGS="$CFLAGS  $flag"
14850	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14851	>	/* end confdefs.h.  */
14852	>
14853	>	int
14854	>	main ()
14855	>	{
14856	>
14857	>	;
14858	>	return 0;
14859	>	}
14860	>	_ACEOF
14861	>	if ac_fn_c_try_compile "$LINENO"; then :
14862	>	eval "$as_CACHEVAR=yes"
14863	>	else
14864	>	eval "$as_CACHEVAR=no"
14865	>	fi
14866	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14867	>	CFLAGS=$ax_check_save_flags
14868	>	fi
14869	>	eval ac_res=\$$as_CACHEVAR
14870	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14871	>	$as_echo "$ac_res" >&6; }
14872	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14873	>	if ${CFLAGS+:} false; then :
14874	>	case " $CFLAGS " in
14875	>	*" $flag "*)
14876	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14877	>	(: CFLAGS already contains $flag) 2>&5
14878	>	ac_status=$?
14879	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14880	>	test $ac_status = 0; }
14881	>	;;
14882	>	*)
14883	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14884	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14885	>	ac_status=$?
14886	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14887	>	test $ac_status = 0; }
14888	>	CFLAGS="$CFLAGS $flag"
14889	>	;;
14890	>	esac
14891	>	else
14892	>	CFLAGS="$flag"
14893	>	fi
14894	>
14895	>	else
14896	>	:
14897	>	fi
14898	>
14899	>	done
14900	>
14901	>
14902	>
14903	>
14904	>
14905	>	for flag in -Wlogical-op; do
14906	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14907	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14908	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14909	>	if eval \${$as_CACHEVAR+:} false; then :
14910	>	$as_echo_n "(cached) " >&6
14911	>	else
14912	>
14913	>	ax_check_save_flags=$CFLAGS
14914	>	CFLAGS="$CFLAGS  $flag"
14915	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14916	>	/* end confdefs.h.  */
14917	>
14918	>	int
14919	>	main ()
14920	>	{
14921	>
14922	>	;
14923	>	return 0;
14924	>	}
14925	>	_ACEOF
14926	>	if ac_fn_c_try_compile "$LINENO"; then :
14927	>	eval "$as_CACHEVAR=yes"
14928	>	else
14929	>	eval "$as_CACHEVAR=no"
14930	>	fi
14931	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14932	>	CFLAGS=$ax_check_save_flags
14933	>	fi
14934	>	eval ac_res=\$$as_CACHEVAR
14935	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14936	>	$as_echo "$ac_res" >&6; }
14937	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
14938	>	if ${CFLAGS+:} false; then :
14939	>	case " $CFLAGS " in
14940	>	*" $flag "*)
14941	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14942	>	(: CFLAGS already contains $flag) 2>&5
14943	>	ac_status=$?
14944	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14945	>	test $ac_status = 0; }
14946	>	;;
14947	>	*)
14948	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
14949	>	(: CFLAGS="$CFLAGS $flag") 2>&5
14950	>	ac_status=$?
14951	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14952	>	test $ac_status = 0; }
14953	>	CFLAGS="$CFLAGS $flag"
14954	>	;;
14955	>	esac
14956	>	else
14957	>	CFLAGS="$flag"
14958	>	fi
14959	>
14960	>	else
14961	>	:
14962	>	fi
14963	>
14964	>	done
14965	>
14966	>
14967	>
14968	>
14969	>
14970	>	for flag in -Wmissing-declarations; do
14971	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14972	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14973	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14974	>	if eval \${$as_CACHEVAR+:} false; then :
14975	>	$as_echo_n "(cached) " >&6
14976	>	else
14977	>
14978	>	ax_check_save_flags=$CFLAGS
14979	>	CFLAGS="$CFLAGS  $flag"
14980	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14981	>	/* end confdefs.h.  */
14982	>
14983	>	int
14984	>	main ()
14985	>	{
14986	>
14987	>	;
14988	>	return 0;
14989	>	}
14990	>	_ACEOF
14991	>	if ac_fn_c_try_compile "$LINENO"; then :
14992	>	eval "$as_CACHEVAR=yes"
14993	>	else
14994	>	eval "$as_CACHEVAR=no"
14995	>	fi
14996	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14997	>	CFLAGS=$ax_check_save_flags
14998	>	fi
14999	>	eval ac_res=\$$as_CACHEVAR
15000	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15001	>	$as_echo "$ac_res" >&6; }
15002	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15003	>	if ${CFLAGS+:} false; then :
15004	>	case " $CFLAGS " in
15005	>	*" $flag "*)
15006	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15007	>	(: CFLAGS already contains $flag) 2>&5
15008	>	ac_status=$?
15009	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15010	>	test $ac_status = 0; }
15011	>	;;
15012	>	*)
15013	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15014	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15015	>	ac_status=$?
15016	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15017	>	test $ac_status = 0; }
15018	>	CFLAGS="$CFLAGS $flag"
15019	>	;;
15020	>	esac
15021	>	else
15022	>	CFLAGS="$flag"
15023	>	fi
15024	>
15025	>	else
15026	>	:
15027	>	fi
15028	>
15029	>	done
15030	>
15031	>
15032	>
15033	>
15034	>
15035	>	for flag in -Wmissing-include-dirs; do
15036	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15037	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15038	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15039	>	if eval \${$as_CACHEVAR+:} false; then :
15040	>	$as_echo_n "(cached) " >&6
15041	>	else
15042	>
15043	>	ax_check_save_flags=$CFLAGS
15044	>	CFLAGS="$CFLAGS  $flag"
15045	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15046	>	/* end confdefs.h.  */
15047	>
15048	>	int
15049	>	main ()
15050	>	{
15051	>
15052	>	;
15053	>	return 0;
15054	>	}
15055	>	_ACEOF
15056	>	if ac_fn_c_try_compile "$LINENO"; then :
15057	>	eval "$as_CACHEVAR=yes"
15058	>	else
15059	>	eval "$as_CACHEVAR=no"
15060	>	fi
15061	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15062	>	CFLAGS=$ax_check_save_flags
15063	>	fi
15064	>	eval ac_res=\$$as_CACHEVAR
15065	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15066	>	$as_echo "$ac_res" >&6; }
15067	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15068	>	if ${CFLAGS+:} false; then :
15069	>	case " $CFLAGS " in
15070	>	*" $flag "*)
15071	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15072	>	(: CFLAGS already contains $flag) 2>&5
15073	>	ac_status=$?
15074	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15075	>	test $ac_status = 0; }
15076	>	;;
15077	>	*)
15078	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15079	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15080	>	ac_status=$?
15081	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15082	>	test $ac_status = 0; }
15083	>	CFLAGS="$CFLAGS $flag"
15084	>	;;
15085	>	esac
15086	>	else
15087	>	CFLAGS="$flag"
15088	>	fi
15089	>
15090	>	else
15091	>	:
15092	>	fi
15093	>
15094	>	done
15095	>
15096	>
15097	>
15098	>
15099	>
15100	>	for flag in -Wmissing-prototypes; do
15101	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15102	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15103	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15104	>	if eval \${$as_CACHEVAR+:} false; then :
15105	>	$as_echo_n "(cached) " >&6
15106	>	else
15107	>
15108	>	ax_check_save_flags=$CFLAGS
15109	>	CFLAGS="$CFLAGS  $flag"
15110	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15111	>	/* end confdefs.h.  */
15112	>
15113	>	int
15114	>	main ()
15115	>	{
15116	>
15117	>	;
15118	>	return 0;
15119	>	}
15120	>	_ACEOF
15121	>	if ac_fn_c_try_compile "$LINENO"; then :
15122	>	eval "$as_CACHEVAR=yes"
15123	>	else
15124	>	eval "$as_CACHEVAR=no"
15125	>	fi
15126	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15127	>	CFLAGS=$ax_check_save_flags
15128	>	fi
15129	>	eval ac_res=\$$as_CACHEVAR
15130	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15131	>	$as_echo "$ac_res" >&6; }
15132	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15133	>	if ${CFLAGS+:} false; then :
15134	>	case " $CFLAGS " in
15135	>	*" $flag "*)
15136	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15137	>	(: CFLAGS already contains $flag) 2>&5
15138	>	ac_status=$?
15139	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15140	>	test $ac_status = 0; }
15141	>	;;
15142	>	*)
15143	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15144	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15145	>	ac_status=$?
15146	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15147	>	test $ac_status = 0; }
15148	>	CFLAGS="$CFLAGS $flag"
15149	>	;;
15150	>	esac
15151	>	else
15152	>	CFLAGS="$flag"
15153	>	fi
15154	>
15155	>	else
15156	>	:
15157	>	fi
15158	>
15159	>	done
15160	>
15161	>
15162	>
15163	>
15164	>
15165	>	for flag in -Wnested-externs; do
15166	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15167	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15168	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15169	>	if eval \${$as_CACHEVAR+:} false; then :
15170	>	$as_echo_n "(cached) " >&6
15171	>	else
15172	>
15173	>	ax_check_save_flags=$CFLAGS
15174	>	CFLAGS="$CFLAGS  $flag"
15175	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15176	>	/* end confdefs.h.  */
15177	>
15178	>	int
15179	>	main ()
15180	>	{
15181	>
15182	>	;
15183	>	return 0;
15184	>	}
15185	>	_ACEOF
15186	>	if ac_fn_c_try_compile "$LINENO"; then :
15187	>	eval "$as_CACHEVAR=yes"
15188	>	else
15189	>	eval "$as_CACHEVAR=no"
15190	>	fi
15191	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15192	>	CFLAGS=$ax_check_save_flags
15193	>	fi
15194	>	eval ac_res=\$$as_CACHEVAR
15195	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15196	>	$as_echo "$ac_res" >&6; }
15197	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15198	>	if ${CFLAGS+:} false; then :
15199	>	case " $CFLAGS " in
15200	>	*" $flag "*)
15201	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15202	>	(: CFLAGS already contains $flag) 2>&5
15203	>	ac_status=$?
15204	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15205	>	test $ac_status = 0; }
15206	>	;;
15207	>	*)
15208	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15209	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15210	>	ac_status=$?
15211	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15212	>	test $ac_status = 0; }
15213	>	CFLAGS="$CFLAGS $flag"
15214	>	;;
15215	>	esac
15216	>	else
15217	>	CFLAGS="$flag"
15218	>	fi
15219	>
15220	>	else
15221	>	:
15222	>	fi
15223	>
15224	>	done
15225	>
15226	>
15227	>
15228	>
15229	>
15230	>	for flag in -Wpointer-arith; do
15231	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15232	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15233	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15234	>	if eval \${$as_CACHEVAR+:} false; then :
15235	>	$as_echo_n "(cached) " >&6
15236	>	else
15237	>
15238	>	ax_check_save_flags=$CFLAGS
15239	>	CFLAGS="$CFLAGS  $flag"
15240	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15241	>	/* end confdefs.h.  */
15242	>
15243	>	int
15244	>	main ()
15245	>	{
15246	>
15247	>	;
15248	>	return 0;
15249	>	}
15250	>	_ACEOF
15251	>	if ac_fn_c_try_compile "$LINENO"; then :
15252	>	eval "$as_CACHEVAR=yes"
15253	>	else
15254	>	eval "$as_CACHEVAR=no"
15255	>	fi
15256	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15257	>	CFLAGS=$ax_check_save_flags
15258	>	fi
15259	>	eval ac_res=\$$as_CACHEVAR
15260	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15261	>	$as_echo "$ac_res" >&6; }
15262	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15263	>	if ${CFLAGS+:} false; then :
15264	>	case " $CFLAGS " in
15265	>	*" $flag "*)
15266	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15267	>	(: CFLAGS already contains $flag) 2>&5
15268	>	ac_status=$?
15269	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15270	>	test $ac_status = 0; }
15271	>	;;
15272	>	*)
15273	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15274	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15275	>	ac_status=$?
15276	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15277	>	test $ac_status = 0; }
15278	>	CFLAGS="$CFLAGS $flag"
15279	>	;;
15280	>	esac
15281	>	else
15282	>	CFLAGS="$flag"
15283	>	fi
15284	>
15285	>	else
15286	>	:
15287	>	fi
15288	>
15289	>	done
15290	>
15291	>
15292	>
15293	>
15294	>
15295	>	for flag in -Wredundant-decls; do
15296	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15297	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15298	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15299	>	if eval \${$as_CACHEVAR+:} false; then :
15300	>	$as_echo_n "(cached) " >&6
15301	>	else
15302	>
15303	>	ax_check_save_flags=$CFLAGS
15304	>	CFLAGS="$CFLAGS  $flag"
15305	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15306	>	/* end confdefs.h.  */
15307	>
15308	>	int
15309	>	main ()
15310	>	{
15311	>
15312	>	;
15313	>	return 0;
15314	>	}
15315	>	_ACEOF
15316	>	if ac_fn_c_try_compile "$LINENO"; then :
15317	>	eval "$as_CACHEVAR=yes"
15318	>	else
15319	>	eval "$as_CACHEVAR=no"
15320	>	fi
15321	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15322	>	CFLAGS=$ax_check_save_flags
15323	>	fi
15324	>	eval ac_res=\$$as_CACHEVAR
15325	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15326	>	$as_echo "$ac_res" >&6; }
15327	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15328	>	if ${CFLAGS+:} false; then :
15329	>	case " $CFLAGS " in
15330	>	*" $flag "*)
15331	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15332	>	(: CFLAGS already contains $flag) 2>&5
15333	>	ac_status=$?
15334	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15335	>	test $ac_status = 0; }
15336	>	;;
15337	>	*)
15338	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15339	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15340	>	ac_status=$?
15341	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15342	>	test $ac_status = 0; }
15343	>	CFLAGS="$CFLAGS $flag"
15344	>	;;
15345	>	esac
15346	>	else
15347	>	CFLAGS="$flag"
15348	>	fi
15349	>
15350	>	else
15351	>	:
15352	>	fi
15353	>
15354	>	done
15355	>
15356	>
15357	>
15358	>
15359	>
15360	>	for flag in -Wshadow; do
15361	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15362	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15363	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15364	>	if eval \${$as_CACHEVAR+:} false; then :
15365	>	$as_echo_n "(cached) " >&6
15366	>	else
15367	>
15368	>	ax_check_save_flags=$CFLAGS
15369	>	CFLAGS="$CFLAGS  $flag"
15370	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15371	>	/* end confdefs.h.  */
15372	>
15373	>	int
15374	>	main ()
15375	>	{
15376	>
15377	>	;
15378	>	return 0;
15379	>	}
15380	>	_ACEOF
15381	>	if ac_fn_c_try_compile "$LINENO"; then :
15382	>	eval "$as_CACHEVAR=yes"
15383	>	else
15384	>	eval "$as_CACHEVAR=no"
15385	>	fi
15386	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15387	>	CFLAGS=$ax_check_save_flags
15388	>	fi
15389	>	eval ac_res=\$$as_CACHEVAR
15390	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15391	>	$as_echo "$ac_res" >&6; }
15392	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15393	>	if ${CFLAGS+:} false; then :
15394	>	case " $CFLAGS " in
15395	>	*" $flag "*)
15396	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15397	>	(: CFLAGS already contains $flag) 2>&5
15398	>	ac_status=$?
15399	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15400	>	test $ac_status = 0; }
15401	>	;;
15402	>	*)
15403	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15404	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15405	>	ac_status=$?
15406	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15407	>	test $ac_status = 0; }
15408	>	CFLAGS="$CFLAGS $flag"
15409	>	;;
15410	>	esac
15411	>	else
15412	>	CFLAGS="$flag"
15413	>	fi
15414	>
15415	>	else
15416	>	:
15417	>	fi
15418	>
15419	>	done
15420	>
15421	>
15422	>
15423	>
15424	>
15425	>	for flag in -Wwrite-strings; do
15426	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15427	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15428	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15429	>	if eval \${$as_CACHEVAR+:} false; then :
15430	>	$as_echo_n "(cached) " >&6
15431	>	else
15432	>
15433	>	ax_check_save_flags=$CFLAGS
15434	>	CFLAGS="$CFLAGS  $flag"
15435	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15436	>	/* end confdefs.h.  */
15437	>
15438	>	int
15439	>	main ()
15440	>	{
15441	>
15442	>	;
15443	>	return 0;
15444	>	}
15445	>	_ACEOF
15446	>	if ac_fn_c_try_compile "$LINENO"; then :
15447	>	eval "$as_CACHEVAR=yes"
15448	>	else
15449	>	eval "$as_CACHEVAR=no"
15450	>	fi
15451	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15452	>	CFLAGS=$ax_check_save_flags
15453	>	fi
15454	>	eval ac_res=\$$as_CACHEVAR
15455	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15456	>	$as_echo "$ac_res" >&6; }
15457	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15458	>	if ${CFLAGS+:} false; then :
15459	>	case " $CFLAGS " in
15460	>	*" $flag "*)
15461	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15462	>	(: CFLAGS already contains $flag) 2>&5
15463	>	ac_status=$?
15464	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15465	>	test $ac_status = 0; }
15466	>	;;
15467	>	*)
15468	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15469	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15470	>	ac_status=$?
15471	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15472	>	test $ac_status = 0; }
15473	>	CFLAGS="$CFLAGS $flag"
15474	>	;;
15475	>	esac
15476	>	else
15477	>	CFLAGS="$flag"
15478	>	fi
15479	>
15480	>	else
15481	>	:
15482	>	fi
15483	>
15484	>	done
15485	>
15486	>
15487	>
15488	>
15489	>
15490	>	for flag in -Wundef; do
15491	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
15492	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
15493	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
15494	>	if eval \${$as_CACHEVAR+:} false; then :
15495	>	$as_echo_n "(cached) " >&6
15496	>	else
15497	>
15498	>	ax_check_save_flags=$CFLAGS
15499	>	CFLAGS="$CFLAGS  $flag"
15500	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
15501	>	/* end confdefs.h.  */
15502	>
15503	>	int
15504	>	main ()
15505	>	{
15506	>
15507	>	;
15508	>	return 0;
15509	>	}
15510	>	_ACEOF
15511	>	if ac_fn_c_try_compile "$LINENO"; then :
15512	>	eval "$as_CACHEVAR=yes"
15513	>	else
15514	>	eval "$as_CACHEVAR=no"
15515	>	fi
15516	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
15517	>	CFLAGS=$ax_check_save_flags
15518	>	fi
15519	>	eval ac_res=\$$as_CACHEVAR
15520	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
15521	>	$as_echo "$ac_res" >&6; }
15522	>	if test x"`eval 'as_val=${'$as_CACHEVAR'};$as_echo "$as_val"'`" = xyes; then :
15523	>	if ${CFLAGS+:} false; then :
15524	>	case " $CFLAGS " in
15525	>	*" $flag "*)
15526	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
15527	>	(: CFLAGS already contains $flag) 2>&5
15528	>	ac_status=$?
15529	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15530	>	test $ac_status = 0; }
15531	>	;;
15532	>	*)
15533	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS \$flag\""; } >&5
15534	>	(: CFLAGS="$CFLAGS $flag") 2>&5
15535	>	ac_status=$?
15536	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
15537	>	test $ac_status = 0; }
15538	>	CFLAGS="$CFLAGS $flag"
15539	>	;;
15540	>	esac
15541	>	else
15542	>	CFLAGS="$flag"
15543	>	fi
15544	>
15545	>	else
15546	>	:
15547	>	fi
15548	>
15549	>	done
15550	>
15551		fi
15552
15553

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)