ViewVC Help

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

root/svn/hopm/trunk/configure

Comparing hopm/trunk/configure (file contents):
Revision 6110 by michael, Thu Jun 11 12:56:34 2015 UTC vs.
Revision 8850 by michael, Sat Feb 9 18:34:12 2019 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2	<	# From configure.ac Id: configure.ac 6106 2015-06-11 12:50:14Z michael .
2	>	# From configure.ac Id: configure.ac 8559 2018-09-23 09:25:41Z michael .
3		# Guess values for system-dependent variables and create Makefiles.
4		# Generated by GNU Autoconf 2.69 for hopm TRUNK.
5		#
#	Line 681 | Line 681 | am__nodep
681		AMDEPBACKSLASH
682		AMDEP_FALSE
683		AMDEP_TRUE
684	–	am__quote
684		am__include
685		DEPDIR
686		OBJEXT
#	Line 758 | Line 757 | PACKAGE_VERSION
757		PACKAGE_TARNAME
758		PACKAGE_NAME
759		PATH_SEPARATOR
760	<	SHELL'
760	>	SHELL
761	>	am__quote'
762		ac_subst_files=''
763		ac_user_opts='
764		enable_option_checking
#	Line 773 | Line 773 | with_aix_soname
773		with_gnu_ld
774		with_sysroot
775		enable_libtool_lock
776	+	enable_openssl
777		enable_assert
778	+	enable_warnings
779	+	enable_efence
780		'
781		ac_precious_vars='build_alias
782		host_alias
#	Line 1419 | Line 1422 | Optional Features:
1422		--enable-fast-install[=PKGS]
1423		optimize for fast installation [default=yes]
1424		--disable-libtool-lock  avoid locking (might break parallel builds)
1425	+	--enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1426	+	--disable-openssl            Disable LibreSSL/OpenSSL support.
1427		--enable-assert         Enable assert() statements
1428	+	--enable-warnings       Enable compiler warnings.
1429	+	--enable-efence         Enable linking with Electric Fence 'efence' memory
1430	+	debugger library.
1431
1432		Optional Packages:
1433		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
#	Line 2143 | Line 2151 | ac_link='$CC -o conftest$ac_exeext $CFLA
2151		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2152
2153
2154	<	am__api_version='1.15'
2154	>	am__api_version='1.16'
2155
2156		ac_aux_dir=
2157		for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
#	Line 2688 | Line 2696 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2696
2697		# For better backward compatibility.  To be removed once Automake 1.9.x
2698		# dies out for good.  For more background, see:
2699	<	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700	<	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2699	>	# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700	>	# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2701		mkdir_p='$(MKDIR_P)'
2702
2703		# We need awk for the "check" target (and possibly the TAP driver).  The
#	Line 2740 | Line 2748 | END
2748		Aborting the configuration process, to ensure you take notice of the issue.
2749
2750		You can download and install GNU coreutils to get an 'rm' implementation
2751	<	that behaves properly: <http://www.gnu.org/software/coreutils/>.
2751	>	that behaves properly: <https://www.gnu.org/software/coreutils/>.
2752
2753		If you want to complete the configuration process using your problematic
2754		'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
#	Line 2784 | Line 2792 | DEPDIR="${am__leading_dot}deps"
2792
2793		ac_config_commands="$ac_config_commands depfiles"
2794
2795	<
2796	<	am_make=${MAKE-make}
2797	<	cat > confinc << 'END'
2795	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
2796	>	$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
2797	>	cat > confinc.mk << 'END'
2798		am__doit:
2799	<	@echo this is the am__doit target
2799	>	@echo this is the am__doit target >confinc.out
2800		.PHONY: am__doit
2801		END
2794	–	# If we don't find an include directive, just comment out the code.
2795	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
2796	–	$as_echo_n "checking for style of include used by $am_make... " >&6; }
2802		am__include="#"
2803		am__quote=
2804	<	_am_result=none
2805	<	# First try GNU make style include.
2806	<	echo "include confinc" > confmf
2807	<	# Ignore all kinds of additional output from 'make'.
2808	<	case `$am_make -s -f confmf 2> /dev/null` in #(
2809	<	*the\ am__doit\ target*)
2810	<	am__include=include
2811	<	am__quote=
2812	<	_am_result=GNU
2813	<	;;
2814	<	esac
2815	<	# Now try BSD make style include.
2816	<	if test "$am__include" = "#"; then
2817	<	echo '.include "confinc"' > confmf
2818	<	case `$am_make -s -f confmf 2> /dev/null` in #(
2819	<	*the\ am__doit\ target*)
2820	<	am__include=.include
2821	<	am__quote="\""
2822	<	_am_result=BSD
2804	>	# BSD make does it like this.
2805	>	echo '.include "confinc.mk" # ignored' > confmf.BSD
2806	>	# Other make implementations (GNU, Solaris 10, AIX) do it like this.
2807	>	echo 'include confinc.mk # ignored' > confmf.GNU
2808	>	_am_result=no
2809	>	for s in GNU BSD; do
2810	>	{ echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
2811	>	(${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
2812	>	ac_status=$?
2813	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
2814	>	(exit $ac_status); }
2815	>	case $?:`cat confinc.out 2>/dev/null` in #(
2816	>	'0:this is the am__doit target') :
2817	>	case $s in #(
2818	>	BSD) :
2819	>	am__include='.include' am__quote='"' ;; #(
2820	>	*) :
2821	>	am__include='include' am__quote='' ;;
2822	>	esac ;; #(
2823	>	*) :
2824		;;
2825	<	esac
2826	<	fi
2827	<
2828	<
2829	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
2830	<	$as_echo "$_am_result" >&6; }
2831	<	rm -f confinc confmf
2825	>	esac
2826	>	if test "$am__include" != "#"; then
2827	>	_am_result="yes ($s style)"
2828	>	break
2829	>	fi
2830	>	done
2831	>	rm -f confinc.* confmf.*
2832	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
2833	>	$as_echo "${_am_result}" >&6; }
2834
2835		# Check whether --enable-dependency-tracking was given.
2836		if test "${enable_dependency_tracking+set}" = set; then :
#	Line 12575 | Line 12583 | fi
12583
12584
12585
12586	+	# Check whether --enable-openssl was given.
12587	+	if test "${enable_openssl+set}" = set; then :
12588	+	enableval=$enable_openssl;  cf_enable_openssl=$enableval
12589	+	else
12590	+	cf_enable_openssl="auto"
12591	+	fi
12592	+
12593	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12594	+	$as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12595	+	if test "$cf_enable_openssl" != "no"; then
12596	+	cf_openssl_basedir=""
12597	+	if test "$cf_enable_openssl" != "auto" &&
12598	+	test "$cf_enable_openssl" != "yes"; then
12599	+	cf_openssl_basedir="${cf_enable_openssl}"
12600	+	else
12601	+	for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12602	+	/opt /opt/openssl /usr/local/openssl; do
12603	+	if test -f "${dirs}/include/openssl/opensslv.h"; then
12604	+	cf_openssl_basedir="${dirs}"
12605	+	break
12606	+	fi
12607	+	done
12608	+	unset dirs
12609	+	fi
12610	+
12611	+	if test ! -z "$cf_openssl_basedir"; then
12612	+	if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12613	+	CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12614	+	LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12615	+	else
12616	+	cf_openssl_basedir=""
12617	+	fi
12618	+	else
12619	+	if test -f "/usr/include/openssl/opensslv.h"; then
12620	+	cf_openssl_basedir="/usr"
12621	+	fi
12622	+	fi
12623	+
12624	+	if test ! -z "$cf_openssl_basedir"; then
12625	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12626	+	$as_echo "$cf_openssl_basedir" >&6; }
12627	+	cf_enable_openssl="yes"
12628	+	else
12629	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12630	+	$as_echo "not found. Please check your path." >&6; }
12631	+	cf_enable_openssl="no"
12632	+	fi
12633	+	unset cf_openssl_basedir
12634	+	else
12635	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12636	+	$as_echo "disabled" >&6; }
12637	+	fi
12638	+
12639	+	if test "$cf_enable_openssl" != "no"; then :
12640	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 1.0.1d and above" >&5
12641	+	$as_echo_n "checking for LibreSSL or OpenSSL 1.0.1d and above... " >&6; }
12642	+	if test "$cross_compiling" = yes; then :
12643	+	cf_openssl_version_ok=no
12644	+	else
12645	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12646	+	/* end confdefs.h.  */
12647	+
12648	+
12649	+	#include <openssl/opensslv.h>
12650	+	#include <stdlib.h>
12651	+	int
12652	+	main ()
12653	+	{
12654	+	exit(!(OPENSSL_VERSION_NUMBER >= 0x1000104fL));
12655	+	;
12656	+	return 0;
12657	+	}
12658	+	_ACEOF
12659	+	if ac_fn_c_try_run "$LINENO"; then :
12660	+	cf_openssl_version_ok=yes
12661	+	else
12662	+	cf_openssl_version_ok=no
12663	+	fi
12664	+	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12665	+	conftest.$ac_objext conftest.beam conftest.$ac_ext
12666	+	fi
12667	+
12668	+
12669	+	if test "$cf_openssl_version_ok" = "yes"; then :
12670	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12671	+	$as_echo "found" >&6; }
12672	+
12673	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12674	+	$as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12675	+	if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12676	+	$as_echo_n "(cached) " >&6
12677	+	else
12678	+	ac_check_lib_save_LIBS=$LIBS
12679	+	LIBS="-lcrypto  $LIBS"
12680	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12681	+	/* end confdefs.h.  */
12682	+
12683	+	/* Override any GCC internal prototype to avoid an error.
12684	+	Use char because int might match the return type of a GCC
12685	+	builtin and then its argument prototype would still apply.  */
12686	+	#ifdef __cplusplus
12687	+	extern "C"
12688	+	#endif
12689	+	char RSA_free ();
12690	+	int
12691	+	main ()
12692	+	{
12693	+	return RSA_free ();
12694	+	;
12695	+	return 0;
12696	+	}
12697	+	_ACEOF
12698	+	if ac_fn_c_try_link "$LINENO"; then :
12699	+	ac_cv_lib_crypto_RSA_free=yes
12700	+	else
12701	+	ac_cv_lib_crypto_RSA_free=no
12702	+	fi
12703	+	rm -f core conftest.err conftest.$ac_objext \
12704	+	conftest$ac_exeext conftest.$ac_ext
12705	+	LIBS=$ac_check_lib_save_LIBS
12706	+	fi
12707	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12708	+	$as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12709	+	if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12710	+	cat >>confdefs.h <<_ACEOF
12711	+	#define HAVE_LIBCRYPTO 1
12712	+	_ACEOF
12713	+
12714	+	LIBS="-lcrypto $LIBS"
12715	+
12716	+	fi
12717	+
12718	+	if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12719	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12720	+	$as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12721	+	if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12722	+	$as_echo_n "(cached) " >&6
12723	+	else
12724	+	ac_check_lib_save_LIBS=$LIBS
12725	+	LIBS="-lssl  $LIBS"
12726	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12727	+	/* end confdefs.h.  */
12728	+
12729	+	/* Override any GCC internal prototype to avoid an error.
12730	+	Use char because int might match the return type of a GCC
12731	+	builtin and then its argument prototype would still apply.  */
12732	+	#ifdef __cplusplus
12733	+	extern "C"
12734	+	#endif
12735	+	char SSL_connect ();
12736	+	int
12737	+	main ()
12738	+	{
12739	+	return SSL_connect ();
12740	+	;
12741	+	return 0;
12742	+	}
12743	+	_ACEOF
12744	+	if ac_fn_c_try_link "$LINENO"; then :
12745	+	ac_cv_lib_ssl_SSL_connect=yes
12746	+	else
12747	+	ac_cv_lib_ssl_SSL_connect=no
12748	+	fi
12749	+	rm -f core conftest.err conftest.$ac_objext \
12750	+	conftest$ac_exeext conftest.$ac_ext
12751	+	LIBS=$ac_check_lib_save_LIBS
12752	+	fi
12753	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12754	+	$as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12755	+	if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12756	+	cat >>confdefs.h <<_ACEOF
12757	+	#define HAVE_LIBSSL 1
12758	+	_ACEOF
12759	+
12760	+	LIBS="-lssl $LIBS"
12761	+
12762	+	fi
12763	+
12764	+	fi
12765	+
12766	+	else
12767	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12768	+	$as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12769	+	cf_enable_openssl="no"
12770	+	fi
12771	+	fi
12772	+
12773	+
12774		# Check whether --enable-assert was given.
12775		if test "${enable_assert+set}" = set; then :
12776		enableval=$enable_assert; assert=$enableval
#	Line 12590 | Line 12786 | $as_echo "#define NDEBUG 1" >>confdefs.h
12786		fi
12787
12788
12789	<	for ac_func in strlcpy strlcat
12790	<	do :
12791	<	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12792	<	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12793	<	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12794	<	cat >>confdefs.h <<_ACEOF
12795	<	#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12789	>	# Check whether --enable-warnings was given.
12790	>	if test "${enable_warnings+set}" = set; then :
12791	>	enableval=$enable_warnings; warnings="$enableval"
12792	>	else
12793	>	warnings="no"
12794	>	fi
12795	>
12796	>
12797	>	if test "$warnings" = "yes"; then :
12798	>
12799	>
12800	>
12801	>
12802	>
12803	>	for flag in -Wall; do
12804	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12805	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12806	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12807	>	if eval \${$as_CACHEVAR+:} false; then :
12808	>	$as_echo_n "(cached) " >&6
12809	>	else
12810	>
12811	>	ax_check_save_flags=$CFLAGS
12812	>	CFLAGS="$CFLAGS  $flag"
12813	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12814	>	/* end confdefs.h.  */
12815	>
12816	>	int
12817	>	main ()
12818	>	{
12819	>
12820	>	;
12821	>	return 0;
12822	>	}
12823		_ACEOF
12824	+	if ac_fn_c_try_compile "$LINENO"; then :
12825	+	eval "$as_CACHEVAR=yes"
12826	+	else
12827	+	eval "$as_CACHEVAR=no"
12828	+	fi
12829	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12830	+	CFLAGS=$ax_check_save_flags
12831	+	fi
12832	+	eval ac_res=\$$as_CACHEVAR
12833	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12834	+	$as_echo "$ac_res" >&6; }
12835	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12836	+
12837	+	if ${CFLAGS+:} false; then :
12838	+
12839	+	case " $CFLAGS " in #(
12840	+	*" $flag "*) :
12841	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12842	+	(: CFLAGS already contains $flag) 2>&5
12843	+	ac_status=$?
12844	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12845	+	test $ac_status = 0; } ;; #(
12846	+	*) :
12847	+
12848	+	as_fn_append CFLAGS " $flag"
12849	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12850	+	(: CFLAGS="$CFLAGS") 2>&5
12851	+	ac_status=$?
12852	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12853	+	test $ac_status = 0; }
12854	+	;;
12855	+	esac
12856	+
12857	+	else
12858	+
12859	+	CFLAGS=$flag
12860	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12861	+	(: CFLAGS="$CFLAGS") 2>&5
12862	+	ac_status=$?
12863	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12864	+	test $ac_status = 0; }
12865
12866		fi
12867	+
12868	+	else
12869	+	:
12870	+	fi
12871	+
12872		done
12873
12874
12875	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
12876	<	$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
12877	<	if ${ac_cv_c_bigendian+:} false; then :
12875	>
12876	>
12877	>
12878	>	for flag in -Wbad-function-cast; do
12879	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12880	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12881	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12882	>	if eval \${$as_CACHEVAR+:} false; then :
12883		$as_echo_n "(cached) " >&6
12884		else
12885	<	ac_cv_c_bigendian=unknown
12886	<	# See if we're dealing with a universal compiler.
12887	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12885	>
12886	>	ax_check_save_flags=$CFLAGS
12887	>	CFLAGS="$CFLAGS  $flag"
12888	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12889		/* end confdefs.h.  */
12615	–	#ifndef __APPLE_CC__
12616	–	not a universal capable compiler
12617	–	#endif
12618	–	typedef int dummy;
12890
12891	+	int
12892	+	main ()
12893	+	{
12894	+
12895	+	;
12896	+	return 0;
12897	+	}
12898		_ACEOF
12899		if ac_fn_c_try_compile "$LINENO"; then :
12900	+	eval "$as_CACHEVAR=yes"
12901	+	else
12902	+	eval "$as_CACHEVAR=no"
12903	+	fi
12904	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12905	+	CFLAGS=$ax_check_save_flags
12906	+	fi
12907	+	eval ac_res=\$$as_CACHEVAR
12908	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12909	+	$as_echo "$ac_res" >&6; }
12910	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12911
12912	<	# Check for potential -arch flags.  It is not universal unless
12913	<	# there are at least two -arch flags with different values.
12914	<	ac_arch=
12915	<	ac_prev=
12916	<	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12917	<	if test -n "$ac_prev"; then
12918	<	case $ac_word in
12919	<	i?86 | x86_64 | ppc | ppc64)
12920	<	if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12921	<	ac_arch=$ac_word
12922	<	else
12923	<	ac_cv_c_bigendian=universal
12924	<	break
12925	<	fi
12926	<	;;
12927	<	esac
12928	<	ac_prev=
12929	<	elif test "x$ac_word" = "x-arch"; then
12930	<	ac_prev=arch
12931	<	fi
12932	<	done
12912	>	if ${CFLAGS+:} false; then :
12913	>
12914	>	case " $CFLAGS " in #(
12915	>	*" $flag "*) :
12916	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12917	>	(: CFLAGS already contains $flag) 2>&5
12918	>	ac_status=$?
12919	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12920	>	test $ac_status = 0; } ;; #(
12921	>	*) :
12922	>
12923	>	as_fn_append CFLAGS " $flag"
12924	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12925	>	(: CFLAGS="$CFLAGS") 2>&5
12926	>	ac_status=$?
12927	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12928	>	test $ac_status = 0; }
12929	>	;;
12930	>	esac
12931	>
12932	>	else
12933	>
12934	>	CFLAGS=$flag
12935	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12936	>	(: CFLAGS="$CFLAGS") 2>&5
12937	>	ac_status=$?
12938	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12939	>	test $ac_status = 0; }
12940	>
12941	>	fi
12942	>
12943	>	else
12944	>	:
12945	>	fi
12946	>
12947	>	done
12948	>
12949	>
12950	>
12951	>
12952	>
12953	>	for flag in -Wcast-align; do
12954	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12955	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12956	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12957	>	if eval \${$as_CACHEVAR+:} false; then :
12958	>	$as_echo_n "(cached) " >&6
12959	>	else
12960	>
12961	>	ax_check_save_flags=$CFLAGS
12962	>	CFLAGS="$CFLAGS  $flag"
12963	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12964	>	/* end confdefs.h.  */
12965	>
12966	>	int
12967	>	main ()
12968	>	{
12969	>
12970	>	;
12971	>	return 0;
12972	>	}
12973	>	_ACEOF
12974	>	if ac_fn_c_try_compile "$LINENO"; then :
12975	>	eval "$as_CACHEVAR=yes"
12976	>	else
12977	>	eval "$as_CACHEVAR=no"
12978		fi
12979		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12980	<	if test $ac_cv_c_bigendian = unknown; then
12981	<	# See if sys/param.h defines the BYTE_ORDER macro.
12982	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12980	>	CFLAGS=$ax_check_save_flags
12981	>	fi
12982	>	eval ac_res=\$$as_CACHEVAR
12983	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12984	>	$as_echo "$ac_res" >&6; }
12985	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12986	>
12987	>	if ${CFLAGS+:} false; then :
12988	>
12989	>	case " $CFLAGS " in #(
12990	>	*" $flag "*) :
12991	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12992	>	(: CFLAGS already contains $flag) 2>&5
12993	>	ac_status=$?
12994	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12995	>	test $ac_status = 0; } ;; #(
12996	>	*) :
12997	>
12998	>	as_fn_append CFLAGS " $flag"
12999	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13000	>	(: CFLAGS="$CFLAGS") 2>&5
13001	>	ac_status=$?
13002	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13003	>	test $ac_status = 0; }
13004	>	;;
13005	>	esac
13006	>
13007	>	else
13008	>
13009	>	CFLAGS=$flag
13010	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13011	>	(: CFLAGS="$CFLAGS") 2>&5
13012	>	ac_status=$?
13013	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13014	>	test $ac_status = 0; }
13015	>
13016	>	fi
13017	>
13018	>	else
13019	>	:
13020	>	fi
13021	>
13022	>	done
13023	>
13024	>
13025	>
13026	>
13027	>
13028	>	for flag in -Wcast-qual; do
13029	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13030	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13031	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13032	>	if eval \${$as_CACHEVAR+:} false; then :
13033	>	$as_echo_n "(cached) " >&6
13034	>	else
13035	>
13036	>	ax_check_save_flags=$CFLAGS
13037	>	CFLAGS="$CFLAGS  $flag"
13038	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13039		/* end confdefs.h.  */
12650	–	#include <sys/types.h>
12651	–	#include <sys/param.h>
13040
13041		int
13042		main ()
13043		{
12656	–	#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
12657	–	&& defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
12658	–	&& LITTLE_ENDIAN)
12659	–	bogus endian macros
12660	–	#endif
13044
13045		;
13046		return 0;
13047		}
13048		_ACEOF
13049		if ac_fn_c_try_compile "$LINENO"; then :
13050	<	# It does; now see whether it defined to BIG_ENDIAN or not.
13051	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13050	>	eval "$as_CACHEVAR=yes"
13051	>	else
13052	>	eval "$as_CACHEVAR=no"
13053	>	fi
13054	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13055	>	CFLAGS=$ax_check_save_flags
13056	>	fi
13057	>	eval ac_res=\$$as_CACHEVAR
13058	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13059	>	$as_echo "$ac_res" >&6; }
13060	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13061	>
13062	>	if ${CFLAGS+:} false; then :
13063	>
13064	>	case " $CFLAGS " in #(
13065	>	*" $flag "*) :
13066	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13067	>	(: CFLAGS already contains $flag) 2>&5
13068	>	ac_status=$?
13069	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13070	>	test $ac_status = 0; } ;; #(
13071	>	*) :
13072	>
13073	>	as_fn_append CFLAGS " $flag"
13074	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13075	>	(: CFLAGS="$CFLAGS") 2>&5
13076	>	ac_status=$?
13077	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13078	>	test $ac_status = 0; }
13079	>	;;
13080	>	esac
13081	>
13082	>	else
13083	>
13084	>	CFLAGS=$flag
13085	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13086	>	(: CFLAGS="$CFLAGS") 2>&5
13087	>	ac_status=$?
13088	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13089	>	test $ac_status = 0; }
13090	>
13091	>	fi
13092	>
13093	>	else
13094	>	:
13095	>	fi
13096	>
13097	>	done
13098	>
13099	>
13100	>
13101	>
13102	>
13103	>	for flag in -Wclobbered; do
13104	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13105	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13106	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13107	>	if eval \${$as_CACHEVAR+:} false; then :
13108	>	$as_echo_n "(cached) " >&6
13109	>	else
13110	>
13111	>	ax_check_save_flags=$CFLAGS
13112	>	CFLAGS="$CFLAGS  $flag"
13113	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13114	>	/* end confdefs.h.  */
13115	>
13116	>	int
13117	>	main ()
13118	>	{
13119	>
13120	>	;
13121	>	return 0;
13122	>	}
13123	>	_ACEOF
13124	>	if ac_fn_c_try_compile "$LINENO"; then :
13125	>	eval "$as_CACHEVAR=yes"
13126	>	else
13127	>	eval "$as_CACHEVAR=no"
13128	>	fi
13129	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13130	>	CFLAGS=$ax_check_save_flags
13131	>	fi
13132	>	eval ac_res=\$$as_CACHEVAR
13133	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13134	>	$as_echo "$ac_res" >&6; }
13135	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13136	>
13137	>	if ${CFLAGS+:} false; then :
13138	>
13139	>	case " $CFLAGS " in #(
13140	>	*" $flag "*) :
13141	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13142	>	(: CFLAGS already contains $flag) 2>&5
13143	>	ac_status=$?
13144	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13145	>	test $ac_status = 0; } ;; #(
13146	>	*) :
13147	>
13148	>	as_fn_append CFLAGS " $flag"
13149	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13150	>	(: CFLAGS="$CFLAGS") 2>&5
13151	>	ac_status=$?
13152	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13153	>	test $ac_status = 0; }
13154	>	;;
13155	>	esac
13156	>
13157	>	else
13158	>
13159	>	CFLAGS=$flag
13160	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13161	>	(: CFLAGS="$CFLAGS") 2>&5
13162	>	ac_status=$?
13163	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13164	>	test $ac_status = 0; }
13165	>
13166	>	fi
13167	>
13168	>	else
13169	>	:
13170	>	fi
13171	>
13172	>	done
13173	>
13174	>
13175	>
13176	>
13177	>
13178	>	for flag in -Wduplicated-cond; do
13179	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13180	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13181	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13182	>	if eval \${$as_CACHEVAR+:} false; then :
13183	>	$as_echo_n "(cached) " >&6
13184	>	else
13185	>
13186	>	ax_check_save_flags=$CFLAGS
13187	>	CFLAGS="$CFLAGS  $flag"
13188	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13189		/* end confdefs.h.  */
12670	–	#include <sys/types.h>
12671	–	#include <sys/param.h>
13190
13191		int
13192		main ()
13193		{
12676	–	#if BYTE_ORDER != BIG_ENDIAN
12677	–	not big endian
12678	–	#endif
13194
13195		;
13196		return 0;
13197		}
13198		_ACEOF
13199		if ac_fn_c_try_compile "$LINENO"; then :
13200	<	ac_cv_c_bigendian=yes
13200	>	eval "$as_CACHEVAR=yes"
13201		else
13202	<	ac_cv_c_bigendian=no
13202	>	eval "$as_CACHEVAR=no"
13203		fi
13204		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13205	+	CFLAGS=$ax_check_save_flags
13206	+	fi
13207	+	eval ac_res=\$$as_CACHEVAR
13208	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13209	+	$as_echo "$ac_res" >&6; }
13210	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13211	+
13212	+	if ${CFLAGS+:} false; then :
13213	+
13214	+	case " $CFLAGS " in #(
13215	+	*" $flag "*) :
13216	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13217	+	(: CFLAGS already contains $flag) 2>&5
13218	+	ac_status=$?
13219	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13220	+	test $ac_status = 0; } ;; #(
13221	+	*) :
13222	+
13223	+	as_fn_append CFLAGS " $flag"
13224	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13225	+	(: CFLAGS="$CFLAGS") 2>&5
13226	+	ac_status=$?
13227	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13228	+	test $ac_status = 0; }
13229	+	;;
13230	+	esac
13231	+
13232	+	else
13233	+
13234	+	CFLAGS=$flag
13235	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13236	+	(: CFLAGS="$CFLAGS") 2>&5
13237	+	ac_status=$?
13238	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13239	+	test $ac_status = 0; }
13240	+
13241	+	fi
13242	+
13243	+	else
13244	+	:
13245	+	fi
13246	+
13247	+	done
13248	+
13249	+
13250	+
13251	+
13252	+
13253	+	for flag in -Wempty-body; do
13254	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13255	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13256	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13257	+	if eval \${$as_CACHEVAR+:} false; then :
13258	+	$as_echo_n "(cached) " >&6
13259	+	else
13260	+
13261	+	ax_check_save_flags=$CFLAGS
13262	+	CFLAGS="$CFLAGS  $flag"
13263	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13264	+	/* end confdefs.h.  */
13265	+
13266	+	int
13267	+	main ()
13268	+	{
13269	+
13270	+	;
13271	+	return 0;
13272	+	}
13273	+	_ACEOF
13274	+	if ac_fn_c_try_compile "$LINENO"; then :
13275	+	eval "$as_CACHEVAR=yes"
13276	+	else
13277	+	eval "$as_CACHEVAR=no"
13278		fi
13279		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13280	<	fi
13281	<	if test $ac_cv_c_bigendian = unknown; then
13282	<	# See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13283	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13280	>	CFLAGS=$ax_check_save_flags
13281	>	fi
13282	>	eval ac_res=\$$as_CACHEVAR
13283	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13284	>	$as_echo "$ac_res" >&6; }
13285	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13286	>
13287	>	if ${CFLAGS+:} false; then :
13288	>
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_fn_append CFLAGS " $flag"
13299	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13300	>	(: CFLAGS="$CFLAGS") 2>&5
13301	>	ac_status=$?
13302	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13303	>	test $ac_status = 0; }
13304	>	;;
13305	>	esac
13306	>
13307	>	else
13308	>
13309	>	CFLAGS=$flag
13310	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13311	>	(: CFLAGS="$CFLAGS") 2>&5
13312	>	ac_status=$?
13313	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13314	>	test $ac_status = 0; }
13315	>
13316	>	fi
13317	>
13318	>	else
13319	>	:
13320	>	fi
13321	>
13322	>	done
13323	>
13324	>
13325	>
13326	>
13327	>
13328	>	for flag in -Wignored-qualifiers; do
13329	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13330	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13331	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13332	>	if eval \${$as_CACHEVAR+:} false; then :
13333	>	$as_echo_n "(cached) " >&6
13334	>	else
13335	>
13336	>	ax_check_save_flags=$CFLAGS
13337	>	CFLAGS="$CFLAGS  $flag"
13338	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13339		/* end confdefs.h.  */
12697	–	#include <limits.h>
13340
13341		int
13342		main ()
13343		{
12702	–	#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
12703	–	bogus endian macros
12704	–	#endif
13344
13345		;
13346		return 0;
13347		}
13348		_ACEOF
13349		if ac_fn_c_try_compile "$LINENO"; then :
13350	<	# It does; now see whether it defined to _BIG_ENDIAN or not.
13351	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13350	>	eval "$as_CACHEVAR=yes"
13351	>	else
13352	>	eval "$as_CACHEVAR=no"
13353	>	fi
13354	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13355	>	CFLAGS=$ax_check_save_flags
13356	>	fi
13357	>	eval ac_res=\$$as_CACHEVAR
13358	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13359	>	$as_echo "$ac_res" >&6; }
13360	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13361	>
13362	>	if ${CFLAGS+:} false; then :
13363	>
13364	>	case " $CFLAGS " in #(
13365	>	*" $flag "*) :
13366	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13367	>	(: CFLAGS already contains $flag) 2>&5
13368	>	ac_status=$?
13369	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13370	>	test $ac_status = 0; } ;; #(
13371	>	*) :
13372	>
13373	>	as_fn_append CFLAGS " $flag"
13374	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13375	>	(: CFLAGS="$CFLAGS") 2>&5
13376	>	ac_status=$?
13377	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13378	>	test $ac_status = 0; }
13379	>	;;
13380	>	esac
13381	>
13382	>	else
13383	>
13384	>	CFLAGS=$flag
13385	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13386	>	(: CFLAGS="$CFLAGS") 2>&5
13387	>	ac_status=$?
13388	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13389	>	test $ac_status = 0; }
13390	>
13391	>	fi
13392	>
13393	>	else
13394	>	:
13395	>	fi
13396	>
13397	>	done
13398	>
13399	>
13400	>
13401	>
13402	>
13403	>	for flag in -Wlogical-op; do
13404	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13405	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13406	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13407	>	if eval \${$as_CACHEVAR+:} false; then :
13408	>	$as_echo_n "(cached) " >&6
13409	>	else
13410	>
13411	>	ax_check_save_flags=$CFLAGS
13412	>	CFLAGS="$CFLAGS  $flag"
13413	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13414		/* end confdefs.h.  */
12714	–	#include <limits.h>
13415
13416		int
13417		main ()
13418		{
12719	–	#ifndef _BIG_ENDIAN
12720	–	not big endian
12721	–	#endif
13419
13420		;
13421		return 0;
13422		}
13423		_ACEOF
13424		if ac_fn_c_try_compile "$LINENO"; then :
13425	<	ac_cv_c_bigendian=yes
13425	>	eval "$as_CACHEVAR=yes"
13426		else
13427	<	ac_cv_c_bigendian=no
13427	>	eval "$as_CACHEVAR=no"
13428		fi
13429		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13430	+	CFLAGS=$ax_check_save_flags
13431	+	fi
13432	+	eval ac_res=\$$as_CACHEVAR
13433	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13434	+	$as_echo "$ac_res" >&6; }
13435	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13436	+
13437	+	if ${CFLAGS+:} false; then :
13438	+
13439	+	case " $CFLAGS " in #(
13440	+	*" $flag "*) :
13441	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13442	+	(: CFLAGS already contains $flag) 2>&5
13443	+	ac_status=$?
13444	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13445	+	test $ac_status = 0; } ;; #(
13446	+	*) :
13447	+
13448	+	as_fn_append CFLAGS " $flag"
13449	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13450	+	(: CFLAGS="$CFLAGS") 2>&5
13451	+	ac_status=$?
13452	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13453	+	test $ac_status = 0; }
13454	+	;;
13455	+	esac
13456	+
13457	+	else
13458	+
13459	+	CFLAGS=$flag
13460	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13461	+	(: CFLAGS="$CFLAGS") 2>&5
13462	+	ac_status=$?
13463	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13464	+	test $ac_status = 0; }
13465	+
13466	+	fi
13467	+
13468	+	else
13469	+	:
13470	+	fi
13471	+
13472	+	done
13473	+
13474	+
13475	+
13476	+
13477	+
13478	+	for flag in -Wmissing-declarations; do
13479	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13480	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13481	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13482	+	if eval \${$as_CACHEVAR+:} false; then :
13483	+	$as_echo_n "(cached) " >&6
13484	+	else
13485	+
13486	+	ax_check_save_flags=$CFLAGS
13487	+	CFLAGS="$CFLAGS  $flag"
13488	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13489	+	/* end confdefs.h.  */
13490	+
13491	+	int
13492	+	main ()
13493	+	{
13494	+
13495	+	;
13496	+	return 0;
13497	+	}
13498	+	_ACEOF
13499	+	if ac_fn_c_try_compile "$LINENO"; then :
13500	+	eval "$as_CACHEVAR=yes"
13501	+	else
13502	+	eval "$as_CACHEVAR=no"
13503		fi
13504		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13505	<	fi
13506	<	if test $ac_cv_c_bigendian = unknown; then
13507	<	# Compile a test program.
13508	<	if test "$cross_compiling" = yes; then :
13509	<	# Try to guess by grepping values from an object file.
13510	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13505	>	CFLAGS=$ax_check_save_flags
13506	>	fi
13507	>	eval ac_res=\$$as_CACHEVAR
13508	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13509	>	$as_echo "$ac_res" >&6; }
13510	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13511	>
13512	>	if ${CFLAGS+:} false; then :
13513	>
13514	>	case " $CFLAGS " in #(
13515	>	*" $flag "*) :
13516	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13517	>	(: CFLAGS already contains $flag) 2>&5
13518	>	ac_status=$?
13519	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13520	>	test $ac_status = 0; } ;; #(
13521	>	*) :
13522	>
13523	>	as_fn_append CFLAGS " $flag"
13524	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13525	>	(: CFLAGS="$CFLAGS") 2>&5
13526	>	ac_status=$?
13527	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13528	>	test $ac_status = 0; }
13529	>	;;
13530	>	esac
13531	>
13532	>	else
13533	>
13534	>	CFLAGS=$flag
13535	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13536	>	(: CFLAGS="$CFLAGS") 2>&5
13537	>	ac_status=$?
13538	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13539	>	test $ac_status = 0; }
13540	>
13541	>	fi
13542	>
13543	>	else
13544	>	:
13545	>	fi
13546	>
13547	>	done
13548	>
13549	>
13550	>
13551	>
13552	>
13553	>	for flag in -Wmissing-field-initializers; do
13554	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13555	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13556	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13557	>	if eval \${$as_CACHEVAR+:} false; then :
13558	>	$as_echo_n "(cached) " >&6
13559	>	else
13560	>
13561	>	ax_check_save_flags=$CFLAGS
13562	>	CFLAGS="$CFLAGS  $flag"
13563	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13564		/* end confdefs.h.  */
12742	–	short int ascii_mm[] =
12743	–	{ 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
12744	–	short int ascii_ii[] =
12745	–	{ 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
12746	–	int use_ascii (int i) {
12747	–	return ascii_mm[i] + ascii_ii[i];
12748	–	}
12749	–	short int ebcdic_ii[] =
12750	–	{ 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
12751	–	short int ebcdic_mm[] =
12752	–	{ 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
12753	–	int use_ebcdic (int i) {
12754	–	return ebcdic_mm[i] + ebcdic_ii[i];
12755	–	}
12756	–	extern int foo;
13565
13566		int
13567		main ()
13568		{
13569	<	return use_ascii (foo) == use_ebcdic (foo);
13569	>
13570		;
13571		return 0;
13572		}
13573		_ACEOF
13574		if ac_fn_c_try_compile "$LINENO"; then :
13575	<	if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
13576	<	ac_cv_c_bigendian=yes
13577	<	fi
12770	<	if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
12771	<	if test "$ac_cv_c_bigendian" = unknown; then
12772	<	ac_cv_c_bigendian=no
12773	<	else
12774	<	# finding both strings is unlikely to happen, but who knows?
12775	<	ac_cv_c_bigendian=unknown
12776	<	fi
12777	<	fi
13575	>	eval "$as_CACHEVAR=yes"
13576	>	else
13577	>	eval "$as_CACHEVAR=no"
13578		fi
13579		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13580	+	CFLAGS=$ax_check_save_flags
13581	+	fi
13582	+	eval ac_res=\$$as_CACHEVAR
13583	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13584	+	$as_echo "$ac_res" >&6; }
13585	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13586	+
13587	+	if ${CFLAGS+:} false; then :
13588	+
13589	+	case " $CFLAGS " in #(
13590	+	*" $flag "*) :
13591	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13592	+	(: CFLAGS already contains $flag) 2>&5
13593	+	ac_status=$?
13594	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13595	+	test $ac_status = 0; } ;; #(
13596	+	*) :
13597	+
13598	+	as_fn_append CFLAGS " $flag"
13599	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13600	+	(: CFLAGS="$CFLAGS") 2>&5
13601	+	ac_status=$?
13602	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13603	+	test $ac_status = 0; }
13604	+	;;
13605	+	esac
13606	+
13607	+	else
13608	+
13609	+	CFLAGS=$flag
13610	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13611	+	(: CFLAGS="$CFLAGS") 2>&5
13612	+	ac_status=$?
13613	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13614	+	test $ac_status = 0; }
13615	+
13616	+	fi
13617	+
13618		else
13619	+	:
13620	+	fi
13621	+
13622	+	done
13623	+
13624	+
13625	+
13626	+
13627	+
13628	+	for flag in -Wmissing-include-dirs; do
13629	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13630	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13631	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13632	+	if eval \${$as_CACHEVAR+:} false; then :
13633	+	$as_echo_n "(cached) " >&6
13634	+	else
13635	+
13636	+	ax_check_save_flags=$CFLAGS
13637	+	CFLAGS="$CFLAGS  $flag"
13638		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13639		/* end confdefs.h.  */
13640	<	$ac_includes_default
13640	>
13641		int
13642		main ()
13643		{
13644
13645	<	/* Are we little or big endian?  From Harbison&Steele.  */
13646	<	union
13647	<	{
13648	<	long int l;
13649	<	char c[sizeof (long int)];
13650	<	} u;
13651	<	u.l = 1;
13652	<	return u.c[sizeof (long int) - 1] == 1;
13645	>	;
13646	>	return 0;
13647	>	}
13648	>	_ACEOF
13649	>	if ac_fn_c_try_compile "$LINENO"; then :
13650	>	eval "$as_CACHEVAR=yes"
13651	>	else
13652	>	eval "$as_CACHEVAR=no"
13653	>	fi
13654	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13655	>	CFLAGS=$ax_check_save_flags
13656	>	fi
13657	>	eval ac_res=\$$as_CACHEVAR
13658	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13659	>	$as_echo "$ac_res" >&6; }
13660	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13661	>
13662	>	if ${CFLAGS+:} false; then :
13663	>
13664	>	case " $CFLAGS " in #(
13665	>	*" $flag "*) :
13666	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13667	>	(: CFLAGS already contains $flag) 2>&5
13668	>	ac_status=$?
13669	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13670	>	test $ac_status = 0; } ;; #(
13671	>	*) :
13672	>
13673	>	as_fn_append CFLAGS " $flag"
13674	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13675	>	(: CFLAGS="$CFLAGS") 2>&5
13676	>	ac_status=$?
13677	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13678	>	test $ac_status = 0; }
13679	>	;;
13680	>	esac
13681	>
13682	>	else
13683	>
13684	>	CFLAGS=$flag
13685	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13686	>	(: CFLAGS="$CFLAGS") 2>&5
13687	>	ac_status=$?
13688	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13689	>	test $ac_status = 0; }
13690	>
13691	>	fi
13692	>
13693	>	else
13694	>	:
13695	>	fi
13696	>
13697	>	done
13698	>
13699	>
13700	>
13701	>
13702	>
13703	>	for flag in -Wmissing-parameter-type; do
13704	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13705	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13706	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13707	>	if eval \${$as_CACHEVAR+:} false; then :
13708	>	$as_echo_n "(cached) " >&6
13709	>	else
13710	>
13711	>	ax_check_save_flags=$CFLAGS
13712	>	CFLAGS="$CFLAGS  $flag"
13713	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13714	>	/* end confdefs.h.  */
13715	>
13716	>	int
13717	>	main ()
13718	>	{
13719
13720		;
13721		return 0;
13722		}
13723		_ACEOF
13724	<	if ac_fn_c_try_run "$LINENO"; then :
13725	<	ac_cv_c_bigendian=no
13724	>	if ac_fn_c_try_compile "$LINENO"; then :
13725	>	eval "$as_CACHEVAR=yes"
13726		else
13727	<	ac_cv_c_bigendian=yes
13727	>	eval "$as_CACHEVAR=no"
13728		fi
13729	<	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
13730	<	conftest.$ac_objext conftest.beam conftest.$ac_ext
13729	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13730	>	CFLAGS=$ax_check_save_flags
13731	>	fi
13732	>	eval ac_res=\$$as_CACHEVAR
13733	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13734	>	$as_echo "$ac_res" >&6; }
13735	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13736	>
13737	>	if ${CFLAGS+:} false; then :
13738	>
13739	>	case " $CFLAGS " in #(
13740	>	*" $flag "*) :
13741	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13742	>	(: CFLAGS already contains $flag) 2>&5
13743	>	ac_status=$?
13744	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13745	>	test $ac_status = 0; } ;; #(
13746	>	*) :
13747	>
13748	>	as_fn_append CFLAGS " $flag"
13749	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13750	>	(: CFLAGS="$CFLAGS") 2>&5
13751	>	ac_status=$?
13752	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13753	>	test $ac_status = 0; }
13754	>	;;
13755	>	esac
13756	>
13757	>	else
13758	>
13759	>	CFLAGS=$flag
13760	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13761	>	(: CFLAGS="$CFLAGS") 2>&5
13762	>	ac_status=$?
13763	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13764	>	test $ac_status = 0; }
13765	>
13766		fi
13767
13768	<	fi
13768	>	else
13769	>	:
13770		fi
12812	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
12813	–	$as_echo "$ac_cv_c_bigendian" >&6; }
12814	–	case $ac_cv_c_bigendian in #(
12815	–	yes)
12816	–	$as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
12817	–	;; #(
12818	–	no)
12819	–	;; #(
12820	–	universal)
13771
13772	<	$as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13772	>	done
13773	>
13774	>
13775	>
13776	>
13777	>
13778	>	for flag in -Wmissing-prototypes; do
13779	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13780	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13781	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13782	>	if eval \${$as_CACHEVAR+:} false; then :
13783	>	$as_echo_n "(cached) " >&6
13784	>	else
13785	>
13786	>	ax_check_save_flags=$CFLAGS
13787	>	CFLAGS="$CFLAGS  $flag"
13788	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13789	>	/* end confdefs.h.  */
13790	>
13791	>	int
13792	>	main ()
13793	>	{
13794	>
13795	>	;
13796	>	return 0;
13797	>	}
13798	>	_ACEOF
13799	>	if ac_fn_c_try_compile "$LINENO"; then :
13800	>	eval "$as_CACHEVAR=yes"
13801	>	else
13802	>	eval "$as_CACHEVAR=no"
13803	>	fi
13804	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13805	>	CFLAGS=$ax_check_save_flags
13806	>	fi
13807	>	eval ac_res=\$$as_CACHEVAR
13808	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13809	>	$as_echo "$ac_res" >&6; }
13810	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13811	>
13812	>	if ${CFLAGS+:} false; then :
13813	>
13814	>	case " $CFLAGS " in #(
13815	>	*" $flag "*) :
13816	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13817	>	(: CFLAGS already contains $flag) 2>&5
13818	>	ac_status=$?
13819	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13820	>	test $ac_status = 0; } ;; #(
13821	>	*) :
13822	>
13823	>	as_fn_append CFLAGS " $flag"
13824	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13825	>	(: CFLAGS="$CFLAGS") 2>&5
13826	>	ac_status=$?
13827	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13828	>	test $ac_status = 0; }
13829	>	;;
13830	>	esac
13831	>
13832	>	else
13833	>
13834	>	CFLAGS=$flag
13835	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13836	>	(: CFLAGS="$CFLAGS") 2>&5
13837	>	ac_status=$?
13838	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13839	>	test $ac_status = 0; }
13840	>
13841	>	fi
13842	>
13843	>	else
13844	>	:
13845	>	fi
13846	>
13847	>	done
13848	>
13849	>
13850	>
13851	>
13852	>
13853	>	for flag in -Wnested-externs; do
13854	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13855	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13856	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13857	>	if eval \${$as_CACHEVAR+:} false; then :
13858	>	$as_echo_n "(cached) " >&6
13859	>	else
13860	>
13861	>	ax_check_save_flags=$CFLAGS
13862	>	CFLAGS="$CFLAGS  $flag"
13863	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13864	>	/* end confdefs.h.  */
13865	>
13866	>	int
13867	>	main ()
13868	>	{
13869	>
13870	>	;
13871	>	return 0;
13872	>	}
13873	>	_ACEOF
13874	>	if ac_fn_c_try_compile "$LINENO"; then :
13875	>	eval "$as_CACHEVAR=yes"
13876	>	else
13877	>	eval "$as_CACHEVAR=no"
13878	>	fi
13879	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13880	>	CFLAGS=$ax_check_save_flags
13881	>	fi
13882	>	eval ac_res=\$$as_CACHEVAR
13883	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13884	>	$as_echo "$ac_res" >&6; }
13885	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13886	>
13887	>	if ${CFLAGS+:} false; then :
13888	>
13889	>	case " $CFLAGS " in #(
13890	>	*" $flag "*) :
13891	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13892	>	(: CFLAGS already contains $flag) 2>&5
13893	>	ac_status=$?
13894	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13895	>	test $ac_status = 0; } ;; #(
13896	>	*) :
13897	>
13898	>	as_fn_append CFLAGS " $flag"
13899	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13900	>	(: CFLAGS="$CFLAGS") 2>&5
13901	>	ac_status=$?
13902	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13903	>	test $ac_status = 0; }
13904	>	;;
13905	>	esac
13906	>
13907	>	else
13908	>
13909	>	CFLAGS=$flag
13910	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13911	>	(: CFLAGS="$CFLAGS") 2>&5
13912	>	ac_status=$?
13913	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13914	>	test $ac_status = 0; }
13915	>
13916	>	fi
13917	>
13918	>	else
13919	>	:
13920	>	fi
13921	>
13922	>	done
13923	>
13924	>
13925	>
13926	>
13927	>
13928	>	for flag in -Wold-style-declaration; do
13929	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13930	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13931	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13932	>	if eval \${$as_CACHEVAR+:} false; then :
13933	>	$as_echo_n "(cached) " >&6
13934	>	else
13935	>
13936	>	ax_check_save_flags=$CFLAGS
13937	>	CFLAGS="$CFLAGS  $flag"
13938	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13939	>	/* end confdefs.h.  */
13940	>
13941	>	int
13942	>	main ()
13943	>	{
13944	>
13945	>	;
13946	>	return 0;
13947	>	}
13948	>	_ACEOF
13949	>	if ac_fn_c_try_compile "$LINENO"; then :
13950	>	eval "$as_CACHEVAR=yes"
13951	>	else
13952	>	eval "$as_CACHEVAR=no"
13953	>	fi
13954	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13955	>	CFLAGS=$ax_check_save_flags
13956	>	fi
13957	>	eval ac_res=\$$as_CACHEVAR
13958	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13959	>	$as_echo "$ac_res" >&6; }
13960	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13961	>
13962	>	if ${CFLAGS+:} false; then :
13963	>
13964	>	case " $CFLAGS " in #(
13965	>	*" $flag "*) :
13966	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13967	>	(: CFLAGS already contains $flag) 2>&5
13968	>	ac_status=$?
13969	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13970	>	test $ac_status = 0; } ;; #(
13971	>	*) :
13972	>
13973	>	as_fn_append CFLAGS " $flag"
13974	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13975	>	(: CFLAGS="$CFLAGS") 2>&5
13976	>	ac_status=$?
13977	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13978	>	test $ac_status = 0; }
13979	>	;;
13980	>	esac
13981	>
13982	>	else
13983	>
13984	>	CFLAGS=$flag
13985	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13986	>	(: CFLAGS="$CFLAGS") 2>&5
13987	>	ac_status=$?
13988	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13989	>	test $ac_status = 0; }
13990	>
13991	>	fi
13992	>
13993	>	else
13994	>	:
13995	>	fi
13996	>
13997	>	done
13998	>
13999	>
14000	>
14001	>
14002	>
14003	>	for flag in -Woverride-init; do
14004	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14005	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14006	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14007	>	if eval \${$as_CACHEVAR+:} false; then :
14008	>	$as_echo_n "(cached) " >&6
14009	>	else
14010	>
14011	>	ax_check_save_flags=$CFLAGS
14012	>	CFLAGS="$CFLAGS  $flag"
14013	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14014	>	/* end confdefs.h.  */
14015	>
14016	>	int
14017	>	main ()
14018	>	{
14019	>
14020	>	;
14021	>	return 0;
14022	>	}
14023	>	_ACEOF
14024	>	if ac_fn_c_try_compile "$LINENO"; then :
14025	>	eval "$as_CACHEVAR=yes"
14026	>	else
14027	>	eval "$as_CACHEVAR=no"
14028	>	fi
14029	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14030	>	CFLAGS=$ax_check_save_flags
14031	>	fi
14032	>	eval ac_res=\$$as_CACHEVAR
14033	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14034	>	$as_echo "$ac_res" >&6; }
14035	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14036	>
14037	>	if ${CFLAGS+:} false; then :
14038	>
14039	>	case " $CFLAGS " in #(
14040	>	*" $flag "*) :
14041	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14042	>	(: CFLAGS already contains $flag) 2>&5
14043	>	ac_status=$?
14044	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14045	>	test $ac_status = 0; } ;; #(
14046	>	*) :
14047	>
14048	>	as_fn_append CFLAGS " $flag"
14049	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14050	>	(: CFLAGS="$CFLAGS") 2>&5
14051	>	ac_status=$?
14052	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14053	>	test $ac_status = 0; }
14054	>	;;
14055	>	esac
14056	>
14057	>	else
14058	>
14059	>	CFLAGS=$flag
14060	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14061	>	(: CFLAGS="$CFLAGS") 2>&5
14062	>	ac_status=$?
14063	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14064	>	test $ac_status = 0; }
14065	>
14066	>	fi
14067	>
14068	>	else
14069	>	:
14070	>	fi
14071	>
14072	>	done
14073	>
14074	>
14075	>
14076	>
14077	>
14078	>	for flag in -Wpointer-arith; do
14079	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14080	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14081	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14082	>	if eval \${$as_CACHEVAR+:} false; then :
14083	>	$as_echo_n "(cached) " >&6
14084	>	else
14085	>
14086	>	ax_check_save_flags=$CFLAGS
14087	>	CFLAGS="$CFLAGS  $flag"
14088	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14089	>	/* end confdefs.h.  */
14090	>
14091	>	int
14092	>	main ()
14093	>	{
14094	>
14095	>	;
14096	>	return 0;
14097	>	}
14098	>	_ACEOF
14099	>	if ac_fn_c_try_compile "$LINENO"; then :
14100	>	eval "$as_CACHEVAR=yes"
14101	>	else
14102	>	eval "$as_CACHEVAR=no"
14103	>	fi
14104	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14105	>	CFLAGS=$ax_check_save_flags
14106	>	fi
14107	>	eval ac_res=\$$as_CACHEVAR
14108	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14109	>	$as_echo "$ac_res" >&6; }
14110	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14111	>
14112	>	if ${CFLAGS+:} false; then :
14113	>
14114	>	case " $CFLAGS " in #(
14115	>	*" $flag "*) :
14116	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14117	>	(: CFLAGS already contains $flag) 2>&5
14118	>	ac_status=$?
14119	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14120	>	test $ac_status = 0; } ;; #(
14121	>	*) :
14122	>
14123	>	as_fn_append CFLAGS " $flag"
14124	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14125	>	(: CFLAGS="$CFLAGS") 2>&5
14126	>	ac_status=$?
14127	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14128	>	test $ac_status = 0; }
14129	>	;;
14130	>	esac
14131	>
14132	>	else
14133	>
14134	>	CFLAGS=$flag
14135	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14136	>	(: CFLAGS="$CFLAGS") 2>&5
14137	>	ac_status=$?
14138	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14139	>	test $ac_status = 0; }
14140	>
14141	>	fi
14142	>
14143	>	else
14144	>	:
14145	>	fi
14146	>
14147	>	done
14148	>
14149	>
14150	>
14151	>
14152	>
14153	>	for flag in -Wredundant-decls; do
14154	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14155	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14156	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14157	>	if eval \${$as_CACHEVAR+:} false; then :
14158	>	$as_echo_n "(cached) " >&6
14159	>	else
14160	>
14161	>	ax_check_save_flags=$CFLAGS
14162	>	CFLAGS="$CFLAGS  $flag"
14163	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14164	>	/* end confdefs.h.  */
14165	>
14166	>	int
14167	>	main ()
14168	>	{
14169	>
14170	>	;
14171	>	return 0;
14172	>	}
14173	>	_ACEOF
14174	>	if ac_fn_c_try_compile "$LINENO"; then :
14175	>	eval "$as_CACHEVAR=yes"
14176	>	else
14177	>	eval "$as_CACHEVAR=no"
14178	>	fi
14179	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14180	>	CFLAGS=$ax_check_save_flags
14181	>	fi
14182	>	eval ac_res=\$$as_CACHEVAR
14183	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14184	>	$as_echo "$ac_res" >&6; }
14185	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14186	>
14187	>	if ${CFLAGS+:} false; then :
14188	>
14189	>	case " $CFLAGS " in #(
14190	>	*" $flag "*) :
14191	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14192	>	(: CFLAGS already contains $flag) 2>&5
14193	>	ac_status=$?
14194	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14195	>	test $ac_status = 0; } ;; #(
14196	>	*) :
14197	>
14198	>	as_fn_append CFLAGS " $flag"
14199	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14200	>	(: CFLAGS="$CFLAGS") 2>&5
14201	>	ac_status=$?
14202	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14203	>	test $ac_status = 0; }
14204	>	;;
14205	>	esac
14206	>
14207	>	else
14208	>
14209	>	CFLAGS=$flag
14210	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14211	>	(: CFLAGS="$CFLAGS") 2>&5
14212	>	ac_status=$?
14213	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14214	>	test $ac_status = 0; }
14215	>
14216	>	fi
14217	>
14218	>	else
14219	>	:
14220	>	fi
14221	>
14222	>	done
14223	>
14224	>
14225	>
14226	>
14227	>
14228	>	for flag in -Wshadow; do
14229	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14230	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14231	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14232	>	if eval \${$as_CACHEVAR+:} false; then :
14233	>	$as_echo_n "(cached) " >&6
14234	>	else
14235	>
14236	>	ax_check_save_flags=$CFLAGS
14237	>	CFLAGS="$CFLAGS  $flag"
14238	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14239	>	/* end confdefs.h.  */
14240	>
14241	>	int
14242	>	main ()
14243	>	{
14244	>
14245	>	;
14246	>	return 0;
14247	>	}
14248	>	_ACEOF
14249	>	if ac_fn_c_try_compile "$LINENO"; then :
14250	>	eval "$as_CACHEVAR=yes"
14251	>	else
14252	>	eval "$as_CACHEVAR=no"
14253	>	fi
14254	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14255	>	CFLAGS=$ax_check_save_flags
14256	>	fi
14257	>	eval ac_res=\$$as_CACHEVAR
14258	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14259	>	$as_echo "$ac_res" >&6; }
14260	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14261	>
14262	>	if ${CFLAGS+:} false; then :
14263	>
14264	>	case " $CFLAGS " in #(
14265	>	*" $flag "*) :
14266	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14267	>	(: CFLAGS already contains $flag) 2>&5
14268	>	ac_status=$?
14269	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14270	>	test $ac_status = 0; } ;; #(
14271	>	*) :
14272	>
14273	>	as_fn_append CFLAGS " $flag"
14274	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14275	>	(: CFLAGS="$CFLAGS") 2>&5
14276	>	ac_status=$?
14277	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14278	>	test $ac_status = 0; }
14279	>	;;
14280	>	esac
14281	>
14282	>	else
14283	>
14284	>	CFLAGS=$flag
14285	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14286	>	(: CFLAGS="$CFLAGS") 2>&5
14287	>	ac_status=$?
14288	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14289	>	test $ac_status = 0; }
14290	>
14291	>	fi
14292	>
14293	>	else
14294	>	:
14295	>	fi
14296	>
14297	>	done
14298	>
14299	>
14300	>
14301	>
14302	>
14303	>	for flag in -Wshift-negative-value; do
14304	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14305	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14306	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14307	>	if eval \${$as_CACHEVAR+:} false; then :
14308	>	$as_echo_n "(cached) " >&6
14309	>	else
14310	>
14311	>	ax_check_save_flags=$CFLAGS
14312	>	CFLAGS="$CFLAGS  $flag"
14313	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14314	>	/* end confdefs.h.  */
14315	>
14316	>	int
14317	>	main ()
14318	>	{
14319	>
14320	>	;
14321	>	return 0;
14322	>	}
14323	>	_ACEOF
14324	>	if ac_fn_c_try_compile "$LINENO"; then :
14325	>	eval "$as_CACHEVAR=yes"
14326	>	else
14327	>	eval "$as_CACHEVAR=no"
14328	>	fi
14329	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14330	>	CFLAGS=$ax_check_save_flags
14331	>	fi
14332	>	eval ac_res=\$$as_CACHEVAR
14333	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14334	>	$as_echo "$ac_res" >&6; }
14335	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14336	>
14337	>	if ${CFLAGS+:} false; then :
14338	>
14339	>	case " $CFLAGS " in #(
14340	>	*" $flag "*) :
14341	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14342	>	(: CFLAGS already contains $flag) 2>&5
14343	>	ac_status=$?
14344	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14345	>	test $ac_status = 0; } ;; #(
14346	>	*) :
14347	>
14348	>	as_fn_append CFLAGS " $flag"
14349	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14350	>	(: CFLAGS="$CFLAGS") 2>&5
14351	>	ac_status=$?
14352	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14353	>	test $ac_status = 0; }
14354	>	;;
14355	>	esac
14356	>
14357	>	else
14358	>
14359	>	CFLAGS=$flag
14360	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14361	>	(: CFLAGS="$CFLAGS") 2>&5
14362	>	ac_status=$?
14363	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14364	>	test $ac_status = 0; }
14365	>
14366	>	fi
14367	>
14368	>	else
14369	>	:
14370	>	fi
14371	>
14372	>	done
14373	>
14374	>
14375	>
14376
14377	<	;; #(
14378	<	*)
14379	<	as_fn_error $? "unknown endianness
14380	<	presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
14381	<	esac
14377	>
14378	>	for flag in -Wsign-compare; do
14379	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14380	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14381	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14382	>	if eval \${$as_CACHEVAR+:} false; then :
14383	>	$as_echo_n "(cached) " >&6
14384	>	else
14385	>
14386	>	ax_check_save_flags=$CFLAGS
14387	>	CFLAGS="$CFLAGS  $flag"
14388	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14389	>	/* end confdefs.h.  */
14390	>
14391	>	int
14392	>	main ()
14393	>	{
14394	>
14395	>	;
14396	>	return 0;
14397	>	}
14398	>	_ACEOF
14399	>	if ac_fn_c_try_compile "$LINENO"; then :
14400	>	eval "$as_CACHEVAR=yes"
14401	>	else
14402	>	eval "$as_CACHEVAR=no"
14403	>	fi
14404	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14405	>	CFLAGS=$ax_check_save_flags
14406	>	fi
14407	>	eval ac_res=\$$as_CACHEVAR
14408	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14409	>	$as_echo "$ac_res" >&6; }
14410	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14411	>
14412	>	if ${CFLAGS+:} false; then :
14413	>
14414	>	case " $CFLAGS " in #(
14415	>	*" $flag "*) :
14416	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14417	>	(: CFLAGS already contains $flag) 2>&5
14418	>	ac_status=$?
14419	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14420	>	test $ac_status = 0; } ;; #(
14421	>	*) :
14422	>
14423	>	as_fn_append CFLAGS " $flag"
14424	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14425	>	(: CFLAGS="$CFLAGS") 2>&5
14426	>	ac_status=$?
14427	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14428	>	test $ac_status = 0; }
14429	>	;;
14430	>	esac
14431	>
14432	>	else
14433	>
14434	>	CFLAGS=$flag
14435	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14436	>	(: CFLAGS="$CFLAGS") 2>&5
14437	>	ac_status=$?
14438	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14439	>	test $ac_status = 0; }
14440	>
14441	>	fi
14442	>
14443	>	else
14444	>	:
14445	>	fi
14446	>
14447	>	done
14448	>
14449	>
14450	>
14451	>
14452	>
14453	>	for flag in -Wtype-limits; do
14454	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14455	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14456	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14457	>	if eval \${$as_CACHEVAR+:} false; then :
14458	>	$as_echo_n "(cached) " >&6
14459	>	else
14460	>
14461	>	ax_check_save_flags=$CFLAGS
14462	>	CFLAGS="$CFLAGS  $flag"
14463	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14464	>	/* end confdefs.h.  */
14465	>
14466	>	int
14467	>	main ()
14468	>	{
14469	>
14470	>	;
14471	>	return 0;
14472	>	}
14473	>	_ACEOF
14474	>	if ac_fn_c_try_compile "$LINENO"; then :
14475	>	eval "$as_CACHEVAR=yes"
14476	>	else
14477	>	eval "$as_CACHEVAR=no"
14478	>	fi
14479	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14480	>	CFLAGS=$ax_check_save_flags
14481	>	fi
14482	>	eval ac_res=\$$as_CACHEVAR
14483	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14484	>	$as_echo "$ac_res" >&6; }
14485	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14486	>
14487	>	if ${CFLAGS+:} false; then :
14488	>
14489	>	case " $CFLAGS " in #(
14490	>	*" $flag "*) :
14491	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14492	>	(: CFLAGS already contains $flag) 2>&5
14493	>	ac_status=$?
14494	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14495	>	test $ac_status = 0; } ;; #(
14496	>	*) :
14497	>
14498	>	as_fn_append CFLAGS " $flag"
14499	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14500	>	(: CFLAGS="$CFLAGS") 2>&5
14501	>	ac_status=$?
14502	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14503	>	test $ac_status = 0; }
14504	>	;;
14505	>	esac
14506	>
14507	>	else
14508	>
14509	>	CFLAGS=$flag
14510	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14511	>	(: CFLAGS="$CFLAGS") 2>&5
14512	>	ac_status=$?
14513	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14514	>	test $ac_status = 0; }
14515	>
14516	>	fi
14517	>
14518	>	else
14519	>	:
14520	>	fi
14521	>
14522	>	done
14523	>
14524	>
14525	>
14526	>
14527	>
14528	>	for flag in -Wundef; do
14529	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14530	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14531	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14532	>	if eval \${$as_CACHEVAR+:} false; then :
14533	>	$as_echo_n "(cached) " >&6
14534	>	else
14535	>
14536	>	ax_check_save_flags=$CFLAGS
14537	>	CFLAGS="$CFLAGS  $flag"
14538	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14539	>	/* end confdefs.h.  */
14540	>
14541	>	int
14542	>	main ()
14543	>	{
14544	>
14545	>	;
14546	>	return 0;
14547	>	}
14548	>	_ACEOF
14549	>	if ac_fn_c_try_compile "$LINENO"; then :
14550	>	eval "$as_CACHEVAR=yes"
14551	>	else
14552	>	eval "$as_CACHEVAR=no"
14553	>	fi
14554	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14555	>	CFLAGS=$ax_check_save_flags
14556	>	fi
14557	>	eval ac_res=\$$as_CACHEVAR
14558	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14559	>	$as_echo "$ac_res" >&6; }
14560	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14561	>
14562	>	if ${CFLAGS+:} false; then :
14563	>
14564	>	case " $CFLAGS " in #(
14565	>	*" $flag "*) :
14566	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14567	>	(: CFLAGS already contains $flag) 2>&5
14568	>	ac_status=$?
14569	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14570	>	test $ac_status = 0; } ;; #(
14571	>	*) :
14572	>
14573	>	as_fn_append CFLAGS " $flag"
14574	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14575	>	(: CFLAGS="$CFLAGS") 2>&5
14576	>	ac_status=$?
14577	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14578	>	test $ac_status = 0; }
14579	>	;;
14580	>	esac
14581	>
14582	>	else
14583	>
14584	>	CFLAGS=$flag
14585	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14586	>	(: CFLAGS="$CFLAGS") 2>&5
14587	>	ac_status=$?
14588	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14589	>	test $ac_status = 0; }
14590	>
14591	>	fi
14592	>
14593	>	else
14594	>	:
14595	>	fi
14596	>
14597	>	done
14598	>
14599	>
14600	>
14601	>
14602	>
14603	>	for flag in -Wuninitialized; do
14604	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14605	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14606	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14607	>	if eval \${$as_CACHEVAR+:} false; then :
14608	>	$as_echo_n "(cached) " >&6
14609	>	else
14610	>
14611	>	ax_check_save_flags=$CFLAGS
14612	>	CFLAGS="$CFLAGS  $flag"
14613	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14614	>	/* end confdefs.h.  */
14615	>
14616	>	int
14617	>	main ()
14618	>	{
14619	>
14620	>	;
14621	>	return 0;
14622	>	}
14623	>	_ACEOF
14624	>	if ac_fn_c_try_compile "$LINENO"; then :
14625	>	eval "$as_CACHEVAR=yes"
14626	>	else
14627	>	eval "$as_CACHEVAR=no"
14628	>	fi
14629	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14630	>	CFLAGS=$ax_check_save_flags
14631	>	fi
14632	>	eval ac_res=\$$as_CACHEVAR
14633	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14634	>	$as_echo "$ac_res" >&6; }
14635	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14636	>
14637	>	if ${CFLAGS+:} false; then :
14638	>
14639	>	case " $CFLAGS " in #(
14640	>	*" $flag "*) :
14641	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14642	>	(: CFLAGS already contains $flag) 2>&5
14643	>	ac_status=$?
14644	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14645	>	test $ac_status = 0; } ;; #(
14646	>	*) :
14647	>
14648	>	as_fn_append CFLAGS " $flag"
14649	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14650	>	(: CFLAGS="$CFLAGS") 2>&5
14651	>	ac_status=$?
14652	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14653	>	test $ac_status = 0; }
14654	>	;;
14655	>	esac
14656	>
14657	>	else
14658	>
14659	>	CFLAGS=$flag
14660	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14661	>	(: CFLAGS="$CFLAGS") 2>&5
14662	>	ac_status=$?
14663	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14664	>	test $ac_status = 0; }
14665	>
14666	>	fi
14667	>
14668	>	else
14669	>	:
14670	>	fi
14671	>
14672	>	done
14673	>
14674	>
14675	>
14676	>
14677	>
14678	>	for flag in -Wwrite-strings; do
14679	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14680	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14681	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14682	>	if eval \${$as_CACHEVAR+:} false; then :
14683	>	$as_echo_n "(cached) " >&6
14684	>	else
14685	>
14686	>	ax_check_save_flags=$CFLAGS
14687	>	CFLAGS="$CFLAGS  $flag"
14688	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14689	>	/* end confdefs.h.  */
14690	>
14691	>	int
14692	>	main ()
14693	>	{
14694	>
14695	>	;
14696	>	return 0;
14697	>	}
14698	>	_ACEOF
14699	>	if ac_fn_c_try_compile "$LINENO"; then :
14700	>	eval "$as_CACHEVAR=yes"
14701	>	else
14702	>	eval "$as_CACHEVAR=no"
14703	>	fi
14704	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14705	>	CFLAGS=$ax_check_save_flags
14706	>	fi
14707	>	eval ac_res=\$$as_CACHEVAR
14708	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14709	>	$as_echo "$ac_res" >&6; }
14710	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14711	>
14712	>	if ${CFLAGS+:} false; then :
14713	>
14714	>	case " $CFLAGS " in #(
14715	>	*" $flag "*) :
14716	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14717	>	(: CFLAGS already contains $flag) 2>&5
14718	>	ac_status=$?
14719	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14720	>	test $ac_status = 0; } ;; #(
14721	>	*) :
14722	>
14723	>	as_fn_append CFLAGS " $flag"
14724	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14725	>	(: CFLAGS="$CFLAGS") 2>&5
14726	>	ac_status=$?
14727	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14728	>	test $ac_status = 0; }
14729	>	;;
14730	>	esac
14731	>
14732	>	else
14733	>
14734	>	CFLAGS=$flag
14735	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14736	>	(: CFLAGS="$CFLAGS") 2>&5
14737	>	ac_status=$?
14738	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14739	>	test $ac_status = 0; }
14740	>
14741	>	fi
14742	>
14743	>	else
14744	>	:
14745	>	fi
14746	>
14747	>	done
14748	>
14749	>
14750	>	fi
14751	>
14752	>
14753	>	# Check whether --enable-efence was given.
14754	>	if test "${enable_efence+set}" = set; then :
14755	>	enableval=$enable_efence; efence="$enableval"
14756	>	else
14757	>	efence="no"
14758	>	fi
14759	>
14760	>
14761	>	if test "$efence" = "yes"; then :
14762	>
14763	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14764	>	$as_echo_n "checking for library containing EF_Print... " >&6; }
14765	>	if ${ac_cv_search_EF_Print+:} false; then :
14766	>	$as_echo_n "(cached) " >&6
14767	>	else
14768	>	ac_func_search_save_LIBS=$LIBS
14769	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14770	>	/* end confdefs.h.  */
14771	>
14772	>	/* Override any GCC internal prototype to avoid an error.
14773	>	Use char because int might match the return type of a GCC
14774	>	builtin and then its argument prototype would still apply.  */
14775	>	#ifdef __cplusplus
14776	>	extern "C"
14777	>	#endif
14778	>	char EF_Print ();
14779	>	int
14780	>	main ()
14781	>	{
14782	>	return EF_Print ();
14783	>	;
14784	>	return 0;
14785	>	}
14786	>	_ACEOF
14787	>	for ac_lib in '' efence; do
14788	>	if test -z "$ac_lib"; then
14789	>	ac_res="none required"
14790	>	else
14791	>	ac_res=-l$ac_lib
14792	>	LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14793	>	fi
14794	>	if ac_fn_c_try_link "$LINENO"; then :
14795	>	ac_cv_search_EF_Print=$ac_res
14796	>	fi
14797	>	rm -f core conftest.err conftest.$ac_objext \
14798	>	conftest$ac_exeext
14799	>	if ${ac_cv_search_EF_Print+:} false; then :
14800	>	break
14801	>	fi
14802	>	done
14803	>	if ${ac_cv_search_EF_Print+:} false; then :
14804	>
14805	>	else
14806	>	ac_cv_search_EF_Print=no
14807	>	fi
14808	>	rm conftest.$ac_ext
14809	>	LIBS=$ac_func_search_save_LIBS
14810	>	fi
14811	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14812	>	$as_echo "$ac_cv_search_EF_Print" >&6; }
14813	>	ac_res=$ac_cv_search_EF_Print
14814	>	if test "$ac_res" != no; then :
14815	>	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14816	>
14817	>	else
14818	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14819	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14820	>	as_fn_error $? "Electric Fence 'efence' library not found
14821	>	See \`config.log' for more details" "$LINENO" 5; }
14822	>	fi
14823	>
14824	>
14825	>	fi
14826	>
14827	>
14828	>	for ac_func in strlcpy strlcat
14829	>	do :
14830	>	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14831	>	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14832	>	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14833	>	cat >>confdefs.h <<_ACEOF
14834	>	#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14835	>	_ACEOF
14836	>
14837	>	fi
14838	>	done
14839
14840
14841		ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
#	Line 12968 | Line 14978 | if test -z "${am__fastdepCC_TRUE}" && te
14978		Usually this means the macro was only invoked conditionally." "$LINENO" 5
14979		fi
14980
12971	–
14981		: "${CONFIG_STATUS=./config.status}"
14982		ac_write_fail=0
14983		ac_clean_files_save=$ac_clean_files
#	Line 13550 | Line 15559 | cat >>$CONFIG_STATUS <<_ACEOF || ac_writ
15559		#
15560		# INIT-COMMANDS
15561		#
15562	<	AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
15562	>	AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
15563
15564
15565		# The HP-UX ksh and POSIX shell print the target directory to stdout
#	Line 14450 | Line 16459 | $as_echo "$as_me: executing $ac_file com
16459		# Older Autoconf quotes --file arguments for eval, but not when files
16460		# are listed without --file.  Let's play safe and only enable the eval
16461		# if we detect the quoting.
16462	<	case $CONFIG_FILES in
16463	<	*\'*) eval set x "$CONFIG_FILES" ;;
16464	<	*)   set x $CONFIG_FILES ;;
16465	<	esac
16462	>	# TODO: see whether this extra hack can be removed once we start
16463	>	# requiring Autoconf 2.70 or later.
16464	>	case $CONFIG_FILES in #(
16465	>	*\'*) :
16466	>	eval set x "$CONFIG_FILES" ;; #(
16467	>	*) :
16468	>	set x $CONFIG_FILES ;; #(
16469	>	*) :
16470	>	;;
16471	>	esac
16472		shift
16473	<	for mf
16473	>	# Used to flag and report bootstrapping failures.
16474	>	am_rc=0
16475	>	for am_mf
16476		do
16477		# Strip MF so we end up with the name of the file.
16478	<	mf=`echo "$mf" | sed -e 's/:.*$//'`
16479	<	# Check whether this is an Automake generated Makefile or not.
16480	<	# We used to match only the files named 'Makefile.in', but
16481	<	# some people rename them; so instead we look at the file content.
14465	<	# Grep'ing the first line is not enough: some people post-process
14466	<	# each Makefile.in and add a new line on top of each file to say so.
14467	<	# Grep'ing the whole file is not good either: AIX grep has a line
16478	>	am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
16479	>	# Check whether this is an Automake generated Makefile which includes
16480	>	# dependency-tracking related rules and includes.
16481	>	# Grep'ing the whole file directly is not great: AIX grep has a line
16482		# limit of 2048, but all sed's we know have understand at least 4000.
16483	<	if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
16484	<	dirpart=`$as_dirname -- "$mf" ||
16485	<	$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16486	<	X"$mf" : 'X\(//\)[^/]' \| \
16487	<	X"$mf" : 'X\(//\)$' \| \
16488	<	X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
16489	<	$as_echo X"$mf" |
16483	>	sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
16484	>	|| continue
16485	>	am_dirpart=`$as_dirname -- "$am_mf" ||
16486	>	$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16487	>	X"$am_mf" : 'X\(//\)[^/]' \| \
16488	>	X"$am_mf" : 'X\(//\)$' \| \
16489	>	X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16490	>	$as_echo X"$am_mf" |
16491		sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
16492		s//\1/
16493		q
#	Line 14490 | Line 16505 | $as_echo X"$mf" |
16505		q
16506		}
16507		s/.*/./; q'`
16508	<	else
16509	<	continue
16510	<	fi
16511	<	# Extract the definition of DEPDIR, am__include, and am__quote
16512	<	# from the Makefile without running 'make'.
16513	<	DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
14499	<	test -z "$DEPDIR" && continue
14500	<	am__include=`sed -n 's/^am__include = //p' < "$mf"`
14501	<	test -z "$am__include" && continue
14502	<	am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
14503	<	# Find all dependency output files, they are included files with
14504	<	# $(DEPDIR) in their names.  We invoke sed twice because it is the
14505	<	# simplest approach to changing $(DEPDIR) to its actual value in the
14506	<	# expansion.
14507	<	for file in `sed -n "
14508	<	s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
14509	<	sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
14510	<	# Make sure the directory exists.
14511	<	test -f "$dirpart/$file" && continue
14512	<	fdir=`$as_dirname -- "$file" ||
14513	<	$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14514	<	X"$file" : 'X\(//\)[^/]' \| \
14515	<	X"$file" : 'X\(//\)$' \| \
14516	<	X"$file" : 'X\(/\)' \| . 2>/dev/null ||
14517	<	$as_echo X"$file" |
14518	<	sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14519	<	s//\1/
14520	<	q
14521	<	}
14522	<	/^X\(\/\/\)[^/].*/{
16508	>	am_filepart=`$as_basename -- "$am_mf" ||
16509	>	$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
16510	>	X"$am_mf" : 'X\(//\)$' \| \
16511	>	X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16512	>	$as_echo X/"$am_mf" |
16513	>	sed '/^.*\/\([^/][^/]*\)\/*$/{
16514		s//\1/
16515		q
16516		}
16517	<	/^X\(\/\/\)$/{
16517	>	/^X\/\(\/\/\)$/{
16518		s//\1/
16519		q
16520		}
16521	<	/^X\(\/\).*/{
16521	>	/^X\/\(\/\).*/{
16522		s//\1/
16523		q
16524		}
16525		s/.*/./; q'`
16526	<	as_dir=$dirpart/$fdir; as_fn_mkdir_p
16527	<	# echo "creating $dirpart/$file"
16528	<	echo '# dummy' > "$dirpart/$file"
16529	<	done
16526	>	{ echo "$as_me:$LINENO: cd "$am_dirpart" \
16527	>	&& sed -e '/# am--include-marker/d' "$am_filepart" \
16528	>	| $MAKE -f - am--depfiles" >&5
16529	>	(cd "$am_dirpart" \
16530	>	&& sed -e '/# am--include-marker/d' "$am_filepart" \
16531	>	| $MAKE -f - am--depfiles) >&5 2>&5
16532	>	ac_status=$?
16533	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
16534	>	(exit $ac_status); } || am_rc=$?
16535		done
16536	+	if test $am_rc -ne 0; then
16537	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
16538	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
16539	+	as_fn_error $? "Something went wrong bootstrapping makefile fragments
16540	+	for automatic dependency tracking.  Try re-running configure with the
16541	+	'--disable-dependency-tracking' option to at least be able to build
16542	+	the package (albeit without support for automatic dependency tracking).
16543	+	See \`config.log' for more details" "$LINENO" 5; }
16544	+	fi
16545	+	{ am_dirpart=; unset am_dirpart;}
16546	+	{ am_filepart=; unset am_filepart;}
16547	+	{ am_mf=; unset am_mf;}
16548	+	{ am_rc=; unset am_rc;}
16549	+	rm -f conftest-deps.mk
16550		}
16551		;;
16552		"libtool":C)

Diff Legend

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