ViewVC Help

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

root/svn/hopm/trunk/configure

Comparing hopm/trunk/configure (file contents):
Revision 5122 by michael, Thu Dec 25 16:50:00 2014 UTC vs.
Revision 8857 by michael, Sat Feb 9 18:53:54 2019 UTC

#	Line 1 | Line 1
1		#! /bin/sh
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 1.0.0beta1.
4	>	# Generated by GNU Autoconf 2.69 for hopm TRUNK.
5	>	#
6	>	# Report bugs to <bugs@ircd-hybrid.org>.
7		#
8		#
9		# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#	Line 272 | Line 275 | fi
275		$as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
276		$as_echo "$0: be upgraded to zsh 4.3.4 or later."
277		else
278	<	$as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
279	<	$0: including any error possibly output before this
280	<	$0: message. Then install a modern shell, or manually run
281	<	$0: the script under such a shell if you do have one."
278	>	$as_echo "$0: Please tell bug-autoconf@gnu.org and
279	>	$0: bugs@ircd-hybrid.org about your system, including any
280	>	$0: error possibly output before this message. Then install
281	>	$0: a modern shell, or manually run the script under such a
282	>	$0: shell if you do have one."
283		fi
284		exit 1
285		fi
#	Line 587 | Line 591 | MAKEFLAGS=
591		# Identity of this package.
592		PACKAGE_NAME='hopm'
593		PACKAGE_TARNAME='hopm'
594	<	PACKAGE_VERSION='1.0.0beta1'
595	<	PACKAGE_STRING='hopm 1.0.0beta1'
596	<	PACKAGE_BUGREPORT=''
594	>	PACKAGE_VERSION='TRUNK'
595	>	PACKAGE_STRING='hopm TRUNK'
596	>	PACKAGE_BUGREPORT='bugs@ircd-hybrid.org'
597		PACKAGE_URL=''
598
599		ac_unique_file="src/opercmd.h"
#	Line 630 | Line 634 | ac_includes_default="\
634		# include <unistd.h>
635		#endif"
636
633	–	enable_option_checking=no
637		ac_subst_vars='am__EXEEXT_FALSE
638		am__EXEEXT_TRUE
639		LTLIBOBJS
640		LIBOBJS
638	–	subdirs
641		LEXLIB
642		LEX_OUTPUT_ROOT
643		LEX
644		YFLAGS
645		YACC
646		CPP
647	+	LT_SYS_LIBRARY_PATH
648		OTOOL64
649		OTOOL
650		LIPO
#	Line 678 | Line 681 | am__nodep
681		AMDEPBACKSLASH
682		AMDEP_FALSE
683		AMDEP_TRUE
681	–	am__quote
684		am__include
685		DEPDIR
686		OBJEXT
#	Line 755 | 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
765		enable_silent_rules
766		enable_maintainer_mode
764	–	with_extra_fascism
767		enable_dependency_tracking
768		enable_shared
769		enable_static
#	Line 771 | 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 780 | Line 786 | CFLAGS
786		LDFLAGS
787		LIBS
788		CPPFLAGS
789	+	LT_SYS_LIBRARY_PATH
790		CPP
791		YACC
792		YFLAGS'
793	<	ac_subdirs_all='src/libopm'
793	>
794
795		# Initialize some variables set by options.
796		ac_init_help=
#	Line 1323 | Line 1330 | if test "$ac_init_help" = "long"; then
1330		# Omit some internal or obsolete options to make the list less imposing.
1331		# This message is too long to be a string in the A/UX 3.1 sh.
1332		cat <<_ACEOF
1333	<	\`configure' configures hopm 1.0.0beta1 to adapt to many kinds of systems.
1333	>	\`configure' configures hopm TRUNK to adapt to many kinds of systems.
1334
1335		Usage: $0 [OPTION]... [VAR=VALUE]...
1336
#	Line 1393 | Line 1400 | fi
1400
1401		if test -n "$ac_init_help"; then
1402		case $ac_init_help in
1403	<	short | recursive ) echo "Configuration of hopm 1.0.0beta1:";;
1403	>	short | recursive ) echo "Configuration of hopm TRUNK:";;
1404		esac
1405		cat <<\_ACEOF
1406
#	Line 1415 | 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]
1434		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1422	–	--with-extra-fascism    Add extra gcc3-specific warning flags
1435		--with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1436		both]
1437		--with-aix-soname=aix|svr4|both
#	Line 1437 | Line 1449 | Some influential environment variables:
1449		LIBS        libraries to pass to the linker, e.g. -l<library>
1450		CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1451		you have headers in a nonstandard directory <include dir>
1452	+	LT_SYS_LIBRARY_PATH
1453	+	User-defined run-time library search path.
1454		CPP         C preprocessor
1455		YACC        The `Yet Another Compiler Compiler' implementation to use.
1456		Defaults to the first program found out of: `bison -y', `byacc',
#	Line 1448 | Line 1462 | Some influential environment variables:
1462		Use these variables to override the choices made by `configure' or to help
1463		it to find libraries and programs with nonstandard names/locations.
1464
1465	<	Report bugs to the package provider.
1465	>	Report bugs to <bugs@ircd-hybrid.org>.
1466		_ACEOF
1467		ac_status=$?
1468		fi
#	Line 1511 | Line 1525 | fi
1525		test -n "$ac_init_help" && exit $ac_status
1526		if $ac_init_version; then
1527		cat <<\_ACEOF
1528	<	hopm configure 1.0.0beta1
1528	>	hopm configure TRUNK
1529		generated by GNU Autoconf 2.69
1530
1531		Copyright (C) 2012 Free Software Foundation, Inc.
#	Line 1785 | Line 1799 | $as_echo "$ac_res" >&6; }
1799		eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1800
1801		} # ac_fn_c_check_func
1788	–
1789	–	# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1790	–	# -------------------------------------------------------
1791	–	# Tests whether HEADER exists, giving a warning if it cannot be compiled using
1792	–	# the include files in INCLUDES and setting the cache variable VAR
1793	–	# accordingly.
1794	–	ac_fn_c_check_header_mongrel ()
1795	–	{
1796	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1797	–	if eval \${$3+:} false; then :
1798	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1799	–	$as_echo_n "checking for $2... " >&6; }
1800	–	if eval \${$3+:} false; then :
1801	–	$as_echo_n "(cached) " >&6
1802	–	fi
1803	–	eval ac_res=\$$3
1804	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1805	–	$as_echo "$ac_res" >&6; }
1806	–	else
1807	–	# Is the header compilable?
1808	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1809	–	$as_echo_n "checking $2 usability... " >&6; }
1810	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1811	–	/* end confdefs.h.  */
1812	–	$4
1813	–	#include <$2>
1814	–	_ACEOF
1815	–	if ac_fn_c_try_compile "$LINENO"; then :
1816	–	ac_header_compiler=yes
1817	–	else
1818	–	ac_header_compiler=no
1819	–	fi
1820	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1821	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1822	–	$as_echo "$ac_header_compiler" >&6; }
1823	–
1824	–	# Is the header present?
1825	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1826	–	$as_echo_n "checking $2 presence... " >&6; }
1827	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1828	–	/* end confdefs.h.  */
1829	–	#include <$2>
1830	–	_ACEOF
1831	–	if ac_fn_c_try_cpp "$LINENO"; then :
1832	–	ac_header_preproc=yes
1833	–	else
1834	–	ac_header_preproc=no
1835	–	fi
1836	–	rm -f conftest.err conftest.i conftest.$ac_ext
1837	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1838	–	$as_echo "$ac_header_preproc" >&6; }
1839	–
1840	–	# So?  What about this header?
1841	–	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1842	–	yes:no: )
1843	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1844	–	$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1845	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1846	–	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1847	–	;;
1848	–	no:yes:* )
1849	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1850	–	$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1851	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1852	–	$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1853	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1854	–	$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1855	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1856	–	$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1857	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1858	–	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1859	–	;;
1860	–	esac
1861	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1862	–	$as_echo_n "checking for $2... " >&6; }
1863	–	if eval \${$3+:} false; then :
1864	–	$as_echo_n "(cached) " >&6
1865	–	else
1866	–	eval "$3=\$ac_header_compiler"
1867	–	fi
1868	–	eval ac_res=\$$3
1869	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1870	–	$as_echo "$ac_res" >&6; }
1871	–	fi
1872	–	eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1873	–
1874	–	} # ac_fn_c_check_header_mongrel
1875	–
1876	–	# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
1877	–	# -------------------------------------------
1878	–	# Tests whether TYPE exists after having included INCLUDES, setting cache
1879	–	# variable VAR accordingly.
1880	–	ac_fn_c_check_type ()
1881	–	{
1882	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1883	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1884	–	$as_echo_n "checking for $2... " >&6; }
1885	–	if eval \${$3+:} false; then :
1886	–	$as_echo_n "(cached) " >&6
1887	–	else
1888	–	eval "$3=no"
1889	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1890	–	/* end confdefs.h.  */
1891	–	$4
1892	–	int
1893	–	main ()
1894	–	{
1895	–	if (sizeof ($2))
1896	–	return 0;
1897	–	;
1898	–	return 0;
1899	–	}
1900	–	_ACEOF
1901	–	if ac_fn_c_try_compile "$LINENO"; then :
1902	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1903	–	/* end confdefs.h.  */
1904	–	$4
1905	–	int
1906	–	main ()
1907	–	{
1908	–	if (sizeof (($2)))
1909	–	return 0;
1910	–	;
1911	–	return 0;
1912	–	}
1913	–	_ACEOF
1914	–	if ac_fn_c_try_compile "$LINENO"; then :
1915	–
1916	–	else
1917	–	eval "$3=yes"
1918	–	fi
1919	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1920	–	fi
1921	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1922	–	fi
1923	–	eval ac_res=\$$3
1924	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1925	–	$as_echo "$ac_res" >&6; }
1926	–	eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1927	–
1928	–	} # ac_fn_c_check_type
1929	–
1930	–	# ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
1931	–	# --------------------------------------------
1932	–	# Tries to find the compile-time value of EXPR in a program that includes
1933	–	# INCLUDES, setting VAR accordingly. Returns whether the value could be
1934	–	# computed
1935	–	ac_fn_c_compute_int ()
1936	–	{
1937	–	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1938	–	if test "$cross_compiling" = yes; then
1939	–	# Depending upon the size, compute the lo and hi bounds.
1940	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1941	–	/* end confdefs.h.  */
1942	–	$4
1943	–	int
1944	–	main ()
1945	–	{
1946	–	static int test_array [1 - 2 * !(($2) >= 0)];
1947	–	test_array [0] = 0;
1948	–	return test_array [0];
1949	–
1950	–	;
1951	–	return 0;
1952	–	}
1953	–	_ACEOF
1954	–	if ac_fn_c_try_compile "$LINENO"; then :
1955	–	ac_lo=0 ac_mid=0
1956	–	while :; do
1957	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1958	–	/* end confdefs.h.  */
1959	–	$4
1960	–	int
1961	–	main ()
1962	–	{
1963	–	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1964	–	test_array [0] = 0;
1965	–	return test_array [0];
1966	–
1967	–	;
1968	–	return 0;
1969	–	}
1970	–	_ACEOF
1971	–	if ac_fn_c_try_compile "$LINENO"; then :
1972	–	ac_hi=$ac_mid; break
1973	–	else
1974	–	as_fn_arith $ac_mid + 1 && ac_lo=$as_val
1975	–	if test $ac_lo -le $ac_mid; then
1976	–	ac_lo= ac_hi=
1977	–	break
1978	–	fi
1979	–	as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
1980	–	fi
1981	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1982	–	done
1983	–	else
1984	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1985	–	/* end confdefs.h.  */
1986	–	$4
1987	–	int
1988	–	main ()
1989	–	{
1990	–	static int test_array [1 - 2 * !(($2) < 0)];
1991	–	test_array [0] = 0;
1992	–	return test_array [0];
1993	–
1994	–	;
1995	–	return 0;
1996	–	}
1997	–	_ACEOF
1998	–	if ac_fn_c_try_compile "$LINENO"; then :
1999	–	ac_hi=-1 ac_mid=-1
2000	–	while :; do
2001	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2002	–	/* end confdefs.h.  */
2003	–	$4
2004	–	int
2005	–	main ()
2006	–	{
2007	–	static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2008	–	test_array [0] = 0;
2009	–	return test_array [0];
2010	–
2011	–	;
2012	–	return 0;
2013	–	}
2014	–	_ACEOF
2015	–	if ac_fn_c_try_compile "$LINENO"; then :
2016	–	ac_lo=$ac_mid; break
2017	–	else
2018	–	as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2019	–	if test $ac_mid -le $ac_hi; then
2020	–	ac_lo= ac_hi=
2021	–	break
2022	–	fi
2023	–	as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2024	–	fi
2025	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2026	–	done
2027	–	else
2028	–	ac_lo= ac_hi=
2029	–	fi
2030	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2031	–	fi
2032	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2033	–	# Binary search between lo and hi bounds.
2034	–	while test "x$ac_lo" != "x$ac_hi"; do
2035	–	as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2036	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2037	–	/* end confdefs.h.  */
2038	–	$4
2039	–	int
2040	–	main ()
2041	–	{
2042	–	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2043	–	test_array [0] = 0;
2044	–	return test_array [0];
2045	–
2046	–	;
2047	–	return 0;
2048	–	}
2049	–	_ACEOF
2050	–	if ac_fn_c_try_compile "$LINENO"; then :
2051	–	ac_hi=$ac_mid
2052	–	else
2053	–	as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2054	–	fi
2055	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2056	–	done
2057	–	case $ac_lo in #((
2058	–	?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2059	–	'') ac_retval=1 ;;
2060	–	esac
2061	–	else
2062	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2063	–	/* end confdefs.h.  */
2064	–	$4
2065	–	static long int longval () { return $2; }
2066	–	static unsigned long int ulongval () { return $2; }
2067	–	#include <stdio.h>
2068	–	#include <stdlib.h>
2069	–	int
2070	–	main ()
2071	–	{
2072	–
2073	–	FILE *f = fopen ("conftest.val", "w");
2074	–	if (! f)
2075	–	return 1;
2076	–	if (($2) < 0)
2077	–	{
2078	–	long int i = longval ();
2079	–	if (i != ($2))
2080	–	return 1;
2081	–	fprintf (f, "%ld", i);
2082	–	}
2083	–	else
2084	–	{
2085	–	unsigned long int i = ulongval ();
2086	–	if (i != ($2))
2087	–	return 1;
2088	–	fprintf (f, "%lu", i);
2089	–	}
2090	–	/* Do not output a trailing newline, as this causes \r\n confusion
2091	–	on some platforms.  */
2092	–	return ferror (f) || fclose (f) != 0;
2093	–
2094	–	;
2095	–	return 0;
2096	–	}
2097	–	_ACEOF
2098	–	if ac_fn_c_try_run "$LINENO"; then :
2099	–	echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2100	–	else
2101	–	ac_retval=1
2102	–	fi
2103	–	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2104	–	conftest.$ac_objext conftest.beam conftest.$ac_ext
2105	–	rm -f conftest.val
2106	–
2107	–	fi
2108	–	eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2109	–	as_fn_set_status $ac_retval
2110	–
2111	–	} # ac_fn_c_compute_int
1802		cat >config.log <<_ACEOF
1803		This file contains any messages produced by compilers while
1804		running configure, to aid debugging if configure makes a mistake.
1805
1806	<	It was created by hopm $as_me 1.0.0beta1, which was
1806	>	It was created by hopm $as_me TRUNK, which was
1807		generated by GNU Autoconf 2.69.  Invocation command line was
1808
1809		$ $0 $@
#	Line 2461 | Line 2151 | ac_link='$CC -o conftest$ac_exeext $CFLA
2151		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2152
2153
2154	<
2465	<	ac_config_headers="$ac_config_headers src/setup.h"
2466	<
2467	<	am__api_version='1.14'
2154	>	am__api_version='1.16'
2155
2156		ac_aux_dir=
2157		for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
#	Line 2665 | Line 2352 | test "$program_suffix" != NONE &&
2352		ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2353		program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2354
2355	<	# expand $ac_aux_dir to an absolute path
2356	<	am_aux_dir=`cd $ac_aux_dir && pwd`
2355	>	# Expand $ac_aux_dir to an absolute path.
2356	>	am_aux_dir=`cd "$ac_aux_dir" && pwd`
2357
2358		if test x"${MISSING+set}" != xset; then
2359		case $am_aux_dir in
#	Line 2685 | Line 2372 | else
2372		$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2373		fi
2374
2375	<	if test x"${install_sh}" != xset; then
2375	>	if test x"${install_sh+set}" != xset; then
2376		case $am_aux_dir in
2377		*\ * | *\     *)
2378		install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
#	Line 2979 | Line 2666 | fi
2666
2667		# Define the identity of the package.
2668		PACKAGE='hopm'
2669	<	VERSION='1.0.0beta1'
2669	>	VERSION='TRUNK'
2670
2671
2672		cat >>confdefs.h <<_ACEOF
#	Line 3009 | 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.  The system "awk" is bad on
2704	<	# some platforms.
2703	>	# We need awk for the "check" target (and possibly the TAP driver).  The
2704	>	# system "awk" is bad on some platforms.
2705		# Always define AMTAR for backward compatibility.  Yes, it's still used
2706		# in the wild :-(  We should find a proper way to deprecate it ...
2707		AMTAR='$${TAR-tar}'
#	Line 3061 | 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 3096 | Line 2783 | fi
2783
2784
2785
2786	<
3100	<	# Check whether --with-extra-fascism was given.
3101	<	if test "${with_extra_fascism+set}" = set; then :
3102	<	withval=$with_extra_fascism; CFLAGS="$CFLAGS -g -O0 -W -Wall -Wfloat-equal -Wbad-function-cast -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls -Wnested-externs"
3103	<	fi
3104	<
2786	>	ac_config_headers="$ac_config_headers src/setup.h"
2787
2788
2789
#	Line 3110 | 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
3120	–	# If we don't find an include directive, just comment out the code.
3121	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
3122	–	$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 4333 | Line 4015 | esac
4015
4016
4017
4018	<	macro_version='2.4.4'
4019	<	macro_revision='2.4.4'
4018	>	macro_version='2.4.6'
4019	>	macro_revision='2.4.6'
4020
4021
4022
#	Line 6757 | Line 6439 | $as_echo "$lt_cv_truncate_bin" >&6; }
6439
6440
6441
6442	+
6443	+	# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6444	+	func_cc_basename ()
6445	+	{
6446	+	for cc_temp in $*""; do
6447	+	case $cc_temp in
6448	+	compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6449	+	distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6450	+	\-*) ;;
6451	+	*) break;;
6452	+	esac
6453	+	done
6454	+	func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6455	+	}
6456	+
6457		# Check whether --enable-libtool-lock was given.
6458		if test "${enable_libtool_lock+set}" = set; then :
6459		enableval=$enable_libtool_lock;
#	Line 7764 | Line 7461 | $as_echo "$lt_cv_ld_force_load" >&6; }
7461		;;
7462		esac
7463
7464	+	# func_munge_path_list VARIABLE PATH
7465	+	# -----------------------------------
7466	+	# VARIABLE is name of variable containing _space_ separated list of
7467	+	# directories to be munged by the contents of PATH, which is string
7468	+	# having a format:
7469	+	# "DIR[:DIR]:"
7470	+	#       string "DIR[ DIR]" will be prepended to VARIABLE
7471	+	# ":DIR[:DIR]"
7472	+	#       string "DIR[ DIR]" will be appended to VARIABLE
7473	+	# "DIRP[:DIRP]::[DIRA:]DIRA"
7474	+	#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7475	+	#       "DIRA[ DIRA]" will be appended to VARIABLE
7476	+	# "DIR[:DIR]"
7477	+	#       VARIABLE will be replaced by "DIR[ DIR]"
7478	+	func_munge_path_list ()
7479	+	{
7480	+	case x$2 in
7481	+	x)
7482	+	;;
7483	+	*:)
7484	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7485	+	;;
7486	+	x:*)
7487	+	eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7488	+	;;
7489	+	*::*)
7490	+	eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7491	+	eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7492	+	;;
7493	+	*)
7494	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7495	+	;;
7496	+	esac
7497	+	}
7498	+
7499		ac_ext=c
7500		ac_cpp='$CPP $CPPFLAGS'
7501		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 8351 | Line 8083 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8083		test -z "$LD" && LD=ld
8084		test -z "$ac_objext" && ac_objext=o
8085
8086	<	for cc_temp in $compiler""; do
8087	<	case $cc_temp in
8356	<	compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
8357	<	distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
8358	<	\-*) ;;
8359	<	*) break;;
8360	<	esac
8361	<	done
8362	<	cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
8086	>	func_cc_basename $compiler
8087	>	cc_basename=$func_cc_basename_result
8088
8089
8090		# Only perform the check for file, if the check method requires it
#	Line 8559 | Line 8284 | _lt_linker_boilerplate=`cat conftest.err
8284		$RM -r conftest*
8285
8286
8287	+	## CAVEAT EMPTOR:
8288	+	## There is no encapsulation within the following macros, do not change
8289	+	## the running order or otherwise move them around unless you know exactly
8290	+	## what you are doing...
8291		if test -n "$compiler"; then
8292
8293		lt_prog_compiler_no_builtin_flag=
#	Line 10814 | Line 10543 | hardcode_into_libs=no
10543		# flags to be left without arguments
10544		need_version=unknown
10545
10546	+
10547	+
10548		case $host_os in
10549		aix3*)
10550		version_type=linux # correct to gnu/linux during the next big refactor
#	Line 11102 | Line 10833 | freebsd* | dragonfly*)
10833		case $version_type in
10834		freebsd-elf*)
10835		library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10836	+	soname_spec='$libname$release$shared_ext$major'
10837		need_version=no
10838		need_lib_prefix=no
10839		;;
#	Line 11161 | Line 10893 | hpux9* | hpux10* | hpux11*)
10893		soname_spec='$libname$release$shared_ext$major'
10894		if test 32 = "$HPUX_IA64_MODE"; then
10895		sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10896	+	sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10897		else
10898		sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10899	+	sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10900		fi
11167	–	sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10901		;;
10902		hppa*64*)
10903		shrext_cmds='.sl'
#	Line 11316 | Line 11049 | fi
11049		# before this can be enabled.
11050		hardcode_into_libs=yes
11051
11052	<	# Append ld.so.conf contents to the search path
11052	>	# Ideally, we could use ldconfig to report *all* directores which are
11053	>	# searched for libraries, however this is still not possible.  Aside from not
11054	>	# being certain /sbin/ldconfig is available, command
11055	>	# 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11056	>	# even though it is searched at run-time.  Try to do the best guess by
11057	>	# appending ld.so.conf contents (and includes) to the search path.
11058		if test -f /etc/ld.so.conf; then
11059		lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[       ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
11060		sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
#	Line 11541 | Line 11279 | fi
11279		if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11280		sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11281		fi
11282	+
11283		if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11284		sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11285		fi
11286
11287	+	# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11288	+	configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11289	+
11290	+	# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11291	+	func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11292	+
11293	+	# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11294	+	configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11295	+
11296	+
11297	+
11298	+
11299	+
11300	+
11301
11302
11303
#	Line 12325 | Line 12078 | CC=$lt_save_CC
12078
12079
12080
12328	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
12329	–	$as_echo_n "checking for ANSI C header files... " >&6; }
12330	–	if ${ac_cv_header_stdc+:} false; then :
12331	–	$as_echo_n "(cached) " >&6
12332	–	else
12333	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12334	–	/* end confdefs.h.  */
12335	–	#include <stdlib.h>
12336	–	#include <stdarg.h>
12337	–	#include <string.h>
12338	–	#include <float.h>
12339	–
12340	–	int
12341	–	main ()
12342	–	{
12343	–
12344	–	;
12345	–	return 0;
12346	–	}
12347	–	_ACEOF
12348	–	if ac_fn_c_try_compile "$LINENO"; then :
12349	–	ac_cv_header_stdc=yes
12350	–	else
12351	–	ac_cv_header_stdc=no
12352	–	fi
12353	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12354	–
12355	–	if test $ac_cv_header_stdc = yes; then
12356	–	# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
12357	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12358	–	/* end confdefs.h.  */
12359	–	#include <string.h>
12360	–
12361	–	_ACEOF
12362	–	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12363	–	$EGREP "memchr" >/dev/null 2>&1; then :
12364	–
12365	–	else
12366	–	ac_cv_header_stdc=no
12367	–	fi
12368	–	rm -f conftest*
12369	–
12370	–	fi
12371	–
12372	–	if test $ac_cv_header_stdc = yes; then
12373	–	# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
12374	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12375	–	/* end confdefs.h.  */
12376	–	#include <stdlib.h>
12377	–
12378	–	_ACEOF
12379	–	if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12380	–	$EGREP "free" >/dev/null 2>&1; then :
12381	–
12382	–	else
12383	–	ac_cv_header_stdc=no
12384	–	fi
12385	–	rm -f conftest*
12386	–
12387	–	fi
12388	–
12389	–	if test $ac_cv_header_stdc = yes; then
12390	–	# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
12391	–	if test "$cross_compiling" = yes; then :
12392	–	:
12393	–	else
12394	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12395	–	/* end confdefs.h.  */
12396	–	#include <ctype.h>
12397	–	#include <stdlib.h>
12398	–	#if ((' ' & 0x0FF) == 0x020)
12399	–	# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
12400	–	# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
12401	–	#else
12402	–	# define ISLOWER(c) \
12403	–	(('a' <= (c) && (c) <= 'i') \
12404	–	|| ('j' <= (c) && (c) <= 'r') \
12405	–	|| ('s' <= (c) && (c) <= 'z'))
12406	–	# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
12407	–	#endif
12408	–
12409	–	#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
12410	–	int
12411	–	main ()
12412	–	{
12413	–	int i;
12414	–	for (i = 0; i < 256; i++)
12415	–	if (XOR (islower (i), ISLOWER (i))
12416	–	|| toupper (i) != TOUPPER (i))
12417	–	return 2;
12418	–	return 0;
12419	–	}
12420	–	_ACEOF
12421	–	if ac_fn_c_try_run "$LINENO"; then :
12422	–
12423	–	else
12424	–	ac_cv_header_stdc=no
12425	–	fi
12426	–	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12427	–	conftest.$ac_objext conftest.beam conftest.$ac_ext
12428	–	fi
12429	–
12430	–	fi
12431	–	fi
12432	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
12433	–	$as_echo "$ac_cv_header_stdc" >&6; }
12434	–	if test $ac_cv_header_stdc = yes; then
12435	–
12436	–	$as_echo "#define STDC_HEADERS 1" >>confdefs.h
12437	–
12438	–	fi
12439	–
12440	–
12441	–	for ac_header in sys/poll.h
12442	–	do :
12443	–	ac_fn_c_check_header_mongrel "$LINENO" "sys/poll.h" "ac_cv_header_sys_poll_h" "$ac_includes_default"
12444	–	if test "x$ac_cv_header_sys_poll_h" = xyes; then :
12445	–	cat >>confdefs.h <<_ACEOF
12446	–	#define HAVE_SYS_POLL_H 1
12447	–	_ACEOF
12448	–	have_poll_sys_h=yes
12449	–	else
12450	–	have_sys_poll_h=no
12451	–	fi
12452	–
12453	–	done
12454	–
12455	–
12456	–	for ac_header in fcntl.h sys/time.h unistd.h strings.h
12457	–	do :
12458	–	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
12459	–	ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
12460	–	if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
12461	–	cat >>confdefs.h <<_ACEOF
12462	–	#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
12463	–	_ACEOF
12464	–
12465	–	fi
12466	–
12467	–	done
12468	–
12469	–
12470	–	ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
12471	–	if test "x$ac_cv_type_size_t" = xyes; then :
12472	–
12473	–	else
12474	–
12475	–	cat >>confdefs.h <<_ACEOF
12476	–	#define size_t unsigned int
12477	–	_ACEOF
12478	–
12479	–	fi
12480	–
12481	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12482	–	$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12483	–	if ${ac_cv_header_time+:} false; then :
12484	–	$as_echo_n "(cached) " >&6
12485	–	else
12486	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12487	–	/* end confdefs.h.  */
12488	–	#include <sys/types.h>
12489	–	#include <sys/time.h>
12490	–	#include <time.h>
12491	–
12492	–	int
12493	–	main ()
12494	–	{
12495	–	if ((struct tm *) 0)
12496	–	return 0;
12497	–	;
12498	–	return 0;
12499	–	}
12500	–	_ACEOF
12501	–	if ac_fn_c_try_compile "$LINENO"; then :
12502	–	ac_cv_header_time=yes
12503	–	else
12504	–	ac_cv_header_time=no
12505	–	fi
12506	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12507	–	fi
12508	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12509	–	$as_echo "$ac_cv_header_time" >&6; }
12510	–	if test $ac_cv_header_time = yes; then
12511	–
12512	–	$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
12513	–
12514	–	fi
12515	–
12516	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
12517	–	$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
12518	–	if ${ac_cv_struct_tm+:} false; then :
12519	–	$as_echo_n "(cached) " >&6
12520	–	else
12521	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12522	–	/* end confdefs.h.  */
12523	–	#include <sys/types.h>
12524	–	#include <time.h>
12525	–
12526	–	int
12527	–	main ()
12528	–	{
12529	–	struct tm tm;
12530	–	int *p = &tm.tm_sec;
12531	–	return !p;
12532	–	;
12533	–	return 0;
12534	–	}
12535	–	_ACEOF
12536	–	if ac_fn_c_try_compile "$LINENO"; then :
12537	–	ac_cv_struct_tm=time.h
12538	–	else
12539	–	ac_cv_struct_tm=sys/time.h
12540	–	fi
12541	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12542	–	fi
12543	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
12544	–	$as_echo "$ac_cv_struct_tm" >&6; }
12545	–	if test $ac_cv_struct_tm = sys/time.h; then
12546	–
12547	–	$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
12548	–
12549	–	fi
12550	–
12551	–
12552	–	for ac_func in strftime
12553	–	do :
12554	–	ac_fn_c_check_func "$LINENO" "strftime" "ac_cv_func_strftime"
12555	–	if test "x$ac_cv_func_strftime" = xyes; then :
12556	–	cat >>confdefs.h <<_ACEOF
12557	–	#define HAVE_STRFTIME 1
12558	–	_ACEOF
12559	–
12560	–	else
12561	–	# strftime is in -lintl on SCO UNIX.
12562	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for strftime in -lintl" >&5
12563	–	$as_echo_n "checking for strftime in -lintl... " >&6; }
12564	–	if ${ac_cv_lib_intl_strftime+:} false; then :
12565	–	$as_echo_n "(cached) " >&6
12566	–	else
12567	–	ac_check_lib_save_LIBS=$LIBS
12568	–	LIBS="-lintl  $LIBS"
12569	–	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12570	–	/* end confdefs.h.  */
12571	–
12572	–	/* Override any GCC internal prototype to avoid an error.
12573	–	Use char because int might match the return type of a GCC
12574	–	builtin and then its argument prototype would still apply.  */
12575	–	#ifdef __cplusplus
12576	–	extern "C"
12577	–	#endif
12578	–	char strftime ();
12579	–	int
12580	–	main ()
12581	–	{
12582	–	return strftime ();
12583	–	;
12584	–	return 0;
12585	–	}
12586	–	_ACEOF
12587	–	if ac_fn_c_try_link "$LINENO"; then :
12588	–	ac_cv_lib_intl_strftime=yes
12589	–	else
12590	–	ac_cv_lib_intl_strftime=no
12591	–	fi
12592	–	rm -f core conftest.err conftest.$ac_objext \
12593	–	conftest$ac_exeext conftest.$ac_ext
12594	–	LIBS=$ac_check_lib_save_LIBS
12595	–	fi
12596	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_intl_strftime" >&5
12597	–	$as_echo "$ac_cv_lib_intl_strftime" >&6; }
12598	–	if test "x$ac_cv_lib_intl_strftime" = xyes; then :
12599	–	$as_echo "#define HAVE_STRFTIME 1" >>confdefs.h
12600	–
12601	–	LIBS="-lintl $LIBS"
12602	–	fi
12603	–
12604	–	fi
12605	–	done
12606	–
12607	–
12608	–
12081		for ac_prog in 'bison -y' byacc
12082		do
12083		# Extract the first word of "$ac_prog", so it can be a program name with args.
#	Line 12813 | Line 12285 | if test "$LEX" = :; then
12285		LEX=${am_missing_run}flex
12286		fi
12287
12288	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12289	<	$as_echo_n "checking for library containing socket... " >&6; }
12290	<	if ${ac_cv_search_socket+:} false; then :
12288	>
12289	>
12290	>	if test "X$CC" != "X"; then
12291	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12292	>	$as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12293	>	if ${ssp_cv_cc+:} false; then :
12294		$as_echo_n "(cached) " >&6
12295		else
12296	<	ac_func_search_save_LIBS=$LIBS
12297	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12296	>	ssp_old_cflags="$CFLAGS"
12297	>	CFLAGS="$CFLAGS -fstack-protector-strong"
12298	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12299		/* end confdefs.h.  */
12300
12825	–	/* Override any GCC internal prototype to avoid an error.
12826	–	Use char because int might match the return type of a GCC
12827	–	builtin and then its argument prototype would still apply.  */
12828	–	#ifdef __cplusplus
12829	–	extern "C"
12830	–	#endif
12831	–	char socket ();
12301		int
12302		main ()
12303		{
12304	<	return socket ();
12304	>
12305		;
12306		return 0;
12307		}
12308		_ACEOF
12309	<	for ac_lib in '' socket; do
12310	<	if test -z "$ac_lib"; then
12311	<	ac_res="none required"
12312	<	else
12844	<	ac_res=-l$ac_lib
12845	<	LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12846	<	fi
12847	<	if ac_fn_c_try_link "$LINENO"; then :
12848	<	ac_cv_search_socket=$ac_res
12309	>	if ac_fn_c_try_compile "$LINENO"; then :
12310	>	ssp_cv_cc=yes
12311	>	else
12312	>	ssp_cv_cc=no
12313		fi
12314	<	rm -f core conftest.err conftest.$ac_objext \
12315	<	conftest$ac_exeext
12316	<	if ${ac_cv_search_socket+:} false; then :
12853	<	break
12314	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12315	>	CFLAGS="$ssp_old_cflags"
12316	>
12317		fi
12318	<	done
12319	<	if ${ac_cv_search_socket+:} false; then :
12318	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12319	>	$as_echo "$ssp_cv_cc" >&6; }
12320	>	if test $ssp_cv_cc = yes; then
12321	>	CFLAGS="$CFLAGS -fstack-protector-strong"
12322	>
12323	>	$as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12324	>
12325	>	else
12326	>	unset ssp_cv_cc
12327	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12328	>	$as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12329	>	if ${ssp_cv_cc+:} false; then :
12330	>	$as_echo_n "(cached) " >&6
12331	>	else
12332	>	ssp_old_cflags="$CFLAGS"
12333	>	CFLAGS="$CFLAGS -fstack-protector"
12334	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12335	>	/* end confdefs.h.  */
12336
12337	+	int
12338	+	main ()
12339	+	{
12340	+
12341	+	;
12342	+	return 0;
12343	+	}
12344	+	_ACEOF
12345	+	if ac_fn_c_try_compile "$LINENO"; then :
12346	+	ssp_cv_cc=yes
12347		else
12348	<	ac_cv_search_socket=no
12348	>	ssp_cv_cc=no
12349		fi
12350	<	rm conftest.$ac_ext
12351	<	LIBS=$ac_func_search_save_LIBS
12350	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12351	>	CFLAGS="$ssp_old_cflags"
12352	>
12353		fi
12354	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12355	<	$as_echo "$ac_cv_search_socket" >&6; }
12356	<	ac_res=$ac_cv_search_socket
12357	<	if test "$ac_res" != no; then :
12868	<	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12354	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12355	>	$as_echo "$ssp_cv_cc" >&6; }
12356	>	if test $ssp_cv_cc = yes; then
12357	>	CFLAGS="$CFLAGS -fstack-protector"
12358
12359	+	$as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12360	+
12361	+	fi
12362	+	fi
12363	+	fi
12364	+
12365	+
12366	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12367	+	$as_echo_n "checking whether libssp exists... " >&6; }
12368	+	if ${ssp_cv_lib+:} false; then :
12369	+	$as_echo_n "(cached) " >&6
12370		else
12371	<	as_fn_error $? "socket library not found" "$LINENO" 5
12371	>	ssp_old_libs="$LIBS"
12372	>	LIBS="$LIBS -lssp"
12373	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12374	>	/* end confdefs.h.  */
12375	>
12376	>	int
12377	>	main ()
12378	>	{
12379	>
12380	>	;
12381	>	return 0;
12382	>	}
12383	>	_ACEOF
12384	>	if ac_fn_c_try_link "$LINENO"; then :
12385	>	ssp_cv_lib=yes
12386	>	else
12387	>	ssp_cv_lib=no
12388		fi
12389	+	rm -f core conftest.err conftest.$ac_objext \
12390	+	conftest$ac_exeext conftest.$ac_ext
12391	+	LIBS="$ssp_old_libs"
12392	+
12393	+	fi
12394	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12395	+	$as_echo "$ssp_cv_lib" >&6; }
12396	+	if test $ssp_cv_lib = yes; then
12397	+	LIBS="$LIBS -lssp"
12398	+	fi
12399
12400	<	ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12400	>
12401	>
12402	>	ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12403		if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12404
12405		else
#	Line 12933 | Line 12461 | fi
12461
12462		fi
12463
12464	<	ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12464	>	ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12465		if test "x$ac_cv_func_getnameinfo" = xyes; then :
12466
12467		else
#	Line 12995 | Line 12523 | fi
12523
12524		fi
12525
12526	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12527	+	$as_echo_n "checking for library containing socket... " >&6; }
12528	+	if ${ac_cv_search_socket+:} false; then :
12529	+	$as_echo_n "(cached) " >&6
12530	+	else
12531	+	ac_func_search_save_LIBS=$LIBS
12532	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12533	+	/* end confdefs.h.  */
12534
12535	<	for ac_func in strlcpy strlcat inet_aton inet_pton socket strdup strstr
12536	<	do :
12537	<	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12538	<	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12539	<	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12535	>	/* Override any GCC internal prototype to avoid an error.
12536	>	Use char because int might match the return type of a GCC
12537	>	builtin and then its argument prototype would still apply.  */
12538	>	#ifdef __cplusplus
12539	>	extern "C"
12540	>	#endif
12541	>	char socket ();
12542	>	int
12543	>	main ()
12544	>	{
12545	>	return socket ();
12546	>	;
12547	>	return 0;
12548	>	}
12549	>	_ACEOF
12550	>	for ac_lib in '' socket; do
12551	>	if test -z "$ac_lib"; then
12552	>	ac_res="none required"
12553	>	else
12554	>	ac_res=-l$ac_lib
12555	>	LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12556	>	fi
12557	>	if ac_fn_c_try_link "$LINENO"; then :
12558	>	ac_cv_search_socket=$ac_res
12559	>	fi
12560	>	rm -f core conftest.err conftest.$ac_objext \
12561	>	conftest$ac_exeext
12562	>	if ${ac_cv_search_socket+:} false; then :
12563	>	break
12564	>	fi
12565	>	done
12566	>	if ${ac_cv_search_socket+:} false; then :
12567	>
12568	>	else
12569	>	ac_cv_search_socket=no
12570	>	fi
12571	>	rm conftest.$ac_ext
12572	>	LIBS=$ac_func_search_save_LIBS
12573	>	fi
12574	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12575	>	$as_echo "$ac_cv_search_socket" >&6; }
12576	>	ac_res=$ac_cv_search_socket
12577	>	if test "$ac_res" != no; then :
12578	>	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12579	>
12580	>	else
12581	>	as_fn_error $? "socket library not found" "$LINENO" 5
12582	>	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.1f and above" >&5
12641	>	$as_echo_n "checking for LibreSSL or OpenSSL 1.0.1f 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 >= 0x1000106fL));
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 `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12711	>	#define HAVE_LIBCRYPTO 1
12712		_ACEOF
12713
12714	+	LIBS="-lcrypto $LIBS"
12715	+
12716		fi
13009	–	done
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	<	for ac_func in gethostbyname
12730	<	do :
12731	<	ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
12732	<	if test "x$ac_cv_func_gethostbyname" = xyes; then :
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_GETHOSTBYNAME 1
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
12777	+	else
12778	+	assert=no
12779	+	fi
12780	+
12781	+
12782	+	if test "$assert" = "no"; then :
12783	+
12784	+	$as_echo "#define NDEBUG 1" >>confdefs.h
12785	+
12786	+	fi
12787	+
12788	+
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.  */
13033	–	#ifndef __APPLE_CC__
13034	–	not a universal capable compiler
13035	–	#endif
13036	–	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-function-type; 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.  */
13068	–	#include <sys/types.h>
13069	–	#include <sys/param.h>
13040
13041		int
13042		main ()
13043		{
13074	–	#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
13075	–	&& defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
13076	–	&& LITTLE_ENDIAN)
13077	–	bogus endian macros
13078	–	#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 -Wcast-qual; 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.  */
13088	–	#include <sys/types.h>
13089	–	#include <sys/param.h>
13115
13116		int
13117		main ()
13118		{
13094	–	#if BYTE_ORDER != BIG_ENDIAN
13095	–	not big endian
13096	–	#endif
13119
13120		;
13121		return 0;
13122		}
13123		_ACEOF
13124		if ac_fn_c_try_compile "$LINENO"; then :
13125	<	ac_cv_c_bigendian=yes
13125	>	eval "$as_CACHEVAR=yes"
13126		else
13127	<	ac_cv_c_bigendian=no
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 -Wclobbered; 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.  */
13190	+
13191	+	int
13192	+	main ()
13193	+	{
13194	+
13195	+	;
13196	+	return 0;
13197	+	}
13198	+	_ACEOF
13199	+	if ac_fn_c_try_compile "$LINENO"; then :
13200	+	eval "$as_CACHEVAR=yes"
13201	+	else
13202	+	eval "$as_CACHEVAR=no"
13203		fi
13204		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13205	<	fi
13206	<	if test $ac_cv_c_bigendian = unknown; then
13207	<	# See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13208	<	cat confdefs.h - <<_ACEOF >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 -Wduplicated-cond; 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.  */
13115	–	#include <limits.h>
13265
13266		int
13267		main ()
13268		{
13120	–	#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13121	–	bogus endian macros
13122	–	#endif
13269
13270		;
13271		return 0;
13272		}
13273		_ACEOF
13274		if ac_fn_c_try_compile "$LINENO"; then :
13275	<	# It does; now see whether it defined to _BIG_ENDIAN or not.
13276	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
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	>	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 -Wempty-body; 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.  */
13340	>
13341	>	int
13342	>	main ()
13343	>	{
13344	>
13345	>	;
13346	>	return 0;
13347	>	}
13348	>	_ACEOF
13349	>	if ac_fn_c_try_compile "$LINENO"; then :
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 -Wignored-qualifiers; 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.  */
13132	–	#include <limits.h>
13415
13416		int
13417		main ()
13418		{
13137	–	#ifndef _BIG_ENDIAN
13138	–	not big endian
13139	–	#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 -Wlogical-op; 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-declarations; 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.  */
13160	–	short int ascii_mm[] =
13161	–	{ 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
13162	–	short int ascii_ii[] =
13163	–	{ 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
13164	–	int use_ascii (int i) {
13165	–	return ascii_mm[i] + ascii_ii[i];
13166	–	}
13167	–	short int ebcdic_ii[] =
13168	–	{ 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
13169	–	short int ebcdic_mm[] =
13170	–	{ 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
13171	–	int use_ebcdic (int i) {
13172	–	return ebcdic_mm[i] + ebcdic_ii[i];
13173	–	}
13174	–	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
13188	<	if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
13189	<	if test "$ac_cv_c_bigendian" = unknown; then
13190	<	ac_cv_c_bigendian=no
13191	<	else
13192	<	# finding both strings is unlikely to happen, but who knows?
13193	<	ac_cv_c_bigendian=unknown
13194	<	fi
13195	<	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-field-initializers; 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-include-dirs; 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
13228	–	fi
13766		fi
13230	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
13231	–	$as_echo "$ac_cv_c_bigendian" >&6; }
13232	–	case $ac_cv_c_bigendian in #(
13233	–	yes)
13234	–	$as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
13235	–	;; #(
13236	–	no)
13237	–	;; #(
13238	–	universal)
13767
13768	<	$as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13768	>	else
13769	>	:
13770	>	fi
13771	>
13772	>	done
13773	>
13774
13242	–	;; #(
13243	–	*)
13244	–	as_fn_error $? "unknown endianness
13245	–	presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13246	–	esac
13775
13776
13777	<	# The cast to long int works around a bug in the HP C Compiler
13778	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13779	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13780	<	# This bug is HP SR number 8606223364.
13781	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
13782	<	$as_echo_n "checking size of int... " >&6; }
13255	<	if ${ac_cv_sizeof_int+:} false; then :
13777	>
13778	>	for flag in -Wmissing-parameter-type; 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
13258	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
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	<	if test "$ac_cv_type_int" = yes; then
13803	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13804	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13805	<	as_fn_error 77 "cannot compute sizeof (int)
13806	<	See \`config.log' for more details" "$LINENO" 5; }
13807	<	else
13808	<	ac_cv_sizeof_int=0
13809	<	fi
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
13272	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
13273	–	$as_echo "$ac_cv_sizeof_int" >&6; }
13846
13847	+	done
13848
13849
13850	<	cat >>confdefs.h <<_ACEOF
13851	<	#define SIZEOF_INT $ac_cv_sizeof_int
13850	>
13851	>
13852	>
13853	>	for flag in -Wmissing-prototypes; 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	<	# The cast to long int works around a bug in the HP C Compiler
13890	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13891	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13892	<	# This bug is HP SR number 8606223364.
13893	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13894	<	$as_echo_n "checking size of short... " >&6; }
13895	<	if ${ac_cv_sizeof_short+:} false; then :
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 -Wnested-externs; 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
13291	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
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	<	if test "$ac_cv_type_short" = yes; then
13953	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13954	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13955	<	as_fn_error 77 "cannot compute sizeof (short)
13956	<	See \`config.log' for more details" "$LINENO" 5; }
13957	<	else
13958	<	ac_cv_sizeof_short=0
13959	<	fi
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
13305	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13306	–	$as_echo "$ac_cv_sizeof_short" >&6; }
13996
13997	+	done
13998
13999
14000	<	cat >>confdefs.h <<_ACEOF
14001	<	#define SIZEOF_SHORT $ac_cv_sizeof_short
14000	>
14001	>
14002	>
14003	>	for flag in -Wold-style-declaration; 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	<	# The cast to long int works around a bug in the HP C Compiler
14060	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14061	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14062	<	# This bug is HP SR number 8606223364.
14063	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
14064	<	$as_echo_n "checking size of long... " >&6; }
14065	<	if ${ac_cv_sizeof_long+:} false; then :
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 -Woverride-init; 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
13324	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
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	<	if test "$ac_cv_type_long" = yes; then
14103	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14104	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14105	<	as_fn_error 77 "cannot compute sizeof (long)
13331	<	See \`config.log' for more details" "$LINENO" 5; }
13332	<	else
13333	<	ac_cv_sizeof_long=0
13334	<	fi
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
13338	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13339	–	$as_echo "$ac_cv_sizeof_long" >&6; }
14142
14143	+	else
14144	+	:
14145	+	fi
14146	+
14147	+	done
14148
14149
14150	<	cat >>confdefs.h <<_ACEOF
14151	<	#define SIZEOF_LONG $ac_cv_sizeof_long
14150	>
14151	>
14152	>
14153	>	for flag in -Wpointer-arith; 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 -Wredundant-decls; 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	<	subdirs="$subdirs src/libopm"
14291	>	fi
14292
14293	+	else
14294	+	:
14295	+	fi
14296
14297	<	ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile"
14297	>	done
14298	>
14299	>
14300	>
14301	>
14302	>
14303	>	for flag in -Wshadow; 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	>	for flag in -Wshift-negative-value; 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 -Wsign-compare; 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 -Wtype-limits; 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 -Wundef; 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 -Wuninitialized; 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	>
14751	>
14752	>
14753	>	for flag in -Wwrite-strings; do
14754	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14755	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14756	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14757	>	if eval \${$as_CACHEVAR+:} false; then :
14758	>	$as_echo_n "(cached) " >&6
14759	>	else
14760	>
14761	>	ax_check_save_flags=$CFLAGS
14762	>	CFLAGS="$CFLAGS  $flag"
14763	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14764	>	/* end confdefs.h.  */
14765	>
14766	>	int
14767	>	main ()
14768	>	{
14769	>
14770	>	;
14771	>	return 0;
14772	>	}
14773	>	_ACEOF
14774	>	if ac_fn_c_try_compile "$LINENO"; then :
14775	>	eval "$as_CACHEVAR=yes"
14776	>	else
14777	>	eval "$as_CACHEVAR=no"
14778	>	fi
14779	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14780	>	CFLAGS=$ax_check_save_flags
14781	>	fi
14782	>	eval ac_res=\$$as_CACHEVAR
14783	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14784	>	$as_echo "$ac_res" >&6; }
14785	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14786	>
14787	>	if ${CFLAGS+:} false; then :
14788	>
14789	>	case " $CFLAGS " in #(
14790	>	*" $flag "*) :
14791	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14792	>	(: CFLAGS already contains $flag) 2>&5
14793	>	ac_status=$?
14794	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14795	>	test $ac_status = 0; } ;; #(
14796	>	*) :
14797	>
14798	>	as_fn_append CFLAGS " $flag"
14799	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14800	>	(: CFLAGS="$CFLAGS") 2>&5
14801	>	ac_status=$?
14802	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14803	>	test $ac_status = 0; }
14804	>	;;
14805	>	esac
14806	>
14807	>	else
14808	>
14809	>	CFLAGS=$flag
14810	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14811	>	(: CFLAGS="$CFLAGS") 2>&5
14812	>	ac_status=$?
14813	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14814	>	test $ac_status = 0; }
14815	>
14816	>	fi
14817	>
14818	>	else
14819	>	:
14820	>	fi
14821	>
14822	>	done
14823	>
14824	>
14825	>	fi
14826	>
14827	>
14828	>	# Check whether --enable-efence was given.
14829	>	if test "${enable_efence+set}" = set; then :
14830	>	enableval=$enable_efence; efence="$enableval"
14831	>	else
14832	>	efence="no"
14833	>	fi
14834	>
14835	>
14836	>	if test "$efence" = "yes"; then :
14837	>
14838	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14839	>	$as_echo_n "checking for library containing EF_Print... " >&6; }
14840	>	if ${ac_cv_search_EF_Print+:} false; then :
14841	>	$as_echo_n "(cached) " >&6
14842	>	else
14843	>	ac_func_search_save_LIBS=$LIBS
14844	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14845	>	/* end confdefs.h.  */
14846	>
14847	>	/* Override any GCC internal prototype to avoid an error.
14848	>	Use char because int might match the return type of a GCC
14849	>	builtin and then its argument prototype would still apply.  */
14850	>	#ifdef __cplusplus
14851	>	extern "C"
14852	>	#endif
14853	>	char EF_Print ();
14854	>	int
14855	>	main ()
14856	>	{
14857	>	return EF_Print ();
14858	>	;
14859	>	return 0;
14860	>	}
14861	>	_ACEOF
14862	>	for ac_lib in '' efence; do
14863	>	if test -z "$ac_lib"; then
14864	>	ac_res="none required"
14865	>	else
14866	>	ac_res=-l$ac_lib
14867	>	LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14868	>	fi
14869	>	if ac_fn_c_try_link "$LINENO"; then :
14870	>	ac_cv_search_EF_Print=$ac_res
14871	>	fi
14872	>	rm -f core conftest.err conftest.$ac_objext \
14873	>	conftest$ac_exeext
14874	>	if ${ac_cv_search_EF_Print+:} false; then :
14875	>	break
14876	>	fi
14877	>	done
14878	>	if ${ac_cv_search_EF_Print+:} false; then :
14879	>
14880	>	else
14881	>	ac_cv_search_EF_Print=no
14882	>	fi
14883	>	rm conftest.$ac_ext
14884	>	LIBS=$ac_func_search_save_LIBS
14885	>	fi
14886	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14887	>	$as_echo "$ac_cv_search_EF_Print" >&6; }
14888	>	ac_res=$ac_cv_search_EF_Print
14889	>	if test "$ac_res" != no; then :
14890	>	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14891	>
14892	>	else
14893	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14894	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14895	>	as_fn_error $? "Electric Fence 'efence' library not found
14896	>	See \`config.log' for more details" "$LINENO" 5; }
14897	>	fi
14898	>
14899	>
14900	>	fi
14901	>
14902	>
14903	>	for ac_func in strlcpy strlcat
14904	>	do :
14905	>	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14906	>	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14907	>	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14908	>	cat >>confdefs.h <<_ACEOF
14909	>	#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14910	>	_ACEOF
14911	>
14912	>	fi
14913	>	done
14914	>
14915	>
14916	>	ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14917
14918		cat >confcache <<\_ACEOF
14919		# This file is a shell script that caches the results of configure
#	Line 13450 | Line 15009 | DEFS=-DHAVE_CONFIG_H
15009
15010		ac_libobjs=
15011		ac_ltlibobjs=
15012	+	U=
15013		for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
15014		# 1. Remove the extension, and $U if already installed.
15015		ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
#	Line 13493 | Line 15053 | if test -z "${am__fastdepCC_TRUE}" && te
15053		Usually this means the macro was only invoked conditionally." "$LINENO" 5
15054		fi
15055
13496	–
15056		: "${CONFIG_STATUS=./config.status}"
15057		ac_write_fail=0
15058		ac_clean_files_save=$ac_clean_files
#	Line 13890 | Line 15449 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15449		# report actual input values of CONFIG_FILES etc. instead of their
15450		# values after options handling.
15451		ac_log="
15452	<	This file was extended by hopm $as_me 1.0.0beta1, which was
15452	>	This file was extended by hopm $as_me TRUNK, which was
15453		generated by GNU Autoconf 2.69.  Invocation command line was
15454
15455		CONFIG_FILES    = $CONFIG_FILES
#	Line 13950 | Line 15509 | $config_headers
15509		Configuration commands:
15510		$config_commands
15511
15512	<	Report bugs to the package provider."
15512	>	Report bugs to <bugs@ircd-hybrid.org>."
15513
15514		_ACEOF
15515		cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15516		ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15517		ac_cs_version="\\
15518	<	hopm config.status 1.0.0beta1
15518	>	hopm config.status TRUNK
15519		configured by $0, generated by GNU Autoconf 2.69,
15520		with options \\"\$ac_cs_config\\"
15521
#	Line 14075 | Line 15634 | cat >>$CONFIG_STATUS <<_ACEOF || ac_writ
15634		#
15635		# INIT-COMMANDS
15636		#
15637	<	AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
15637	>	AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
15638
15639
15640		# The HP-UX ksh and POSIX shell print the target directory to stdout
#	Line 14212 | Line 15771 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15771		finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15772		hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15773		sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15774	<	sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15774	>	configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15775	>	configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15776		hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15777		enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15778		enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
#	Line 14330 | Line 15890 | postinstall_cmds \
15890		postuninstall_cmds \
15891		finish_cmds \
15892		sys_lib_search_path_spec \
15893	<	sys_lib_dlsearch_path_spec; do
15893	>	configure_time_dlsearch_path \
15894	>	configure_time_lt_sys_library_path; do
15895		case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15896		*[\\\\\\\`\\"\\\$]*)
15897		eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
#	Line 14372 | Line 15933 | do
15933		"Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15934		"doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15935		"src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15936	+	"src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15937	+	"src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15938
15939		*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15940		esac
#	Line 14971 | Line 16534 | $as_echo "$as_me: executing $ac_file com
16534		# Older Autoconf quotes --file arguments for eval, but not when files
16535		# are listed without --file.  Let's play safe and only enable the eval
16536		# if we detect the quoting.
16537	<	case $CONFIG_FILES in
16538	<	*\'*) eval set x "$CONFIG_FILES" ;;
16539	<	*)   set x $CONFIG_FILES ;;
16540	<	esac
16537	>	# TODO: see whether this extra hack can be removed once we start
16538	>	# requiring Autoconf 2.70 or later.
16539	>	case $CONFIG_FILES in #(
16540	>	*\'*) :
16541	>	eval set x "$CONFIG_FILES" ;; #(
16542	>	*) :
16543	>	set x $CONFIG_FILES ;; #(
16544	>	*) :
16545	>	;;
16546	>	esac
16547		shift
16548	<	for mf
16548	>	# Used to flag and report bootstrapping failures.
16549	>	am_rc=0
16550	>	for am_mf
16551		do
16552		# Strip MF so we end up with the name of the file.
16553	<	mf=`echo "$mf" | sed -e 's/:.*$//'`
16554	<	# Check whether this is an Automake generated Makefile or not.
16555	<	# We used to match only the files named 'Makefile.in', but
16556	<	# some people rename them; so instead we look at the file content.
14986	<	# Grep'ing the first line is not enough: some people post-process
14987	<	# each Makefile.in and add a new line on top of each file to say so.
14988	<	# Grep'ing the whole file is not good either: AIX grep has a line
16553	>	am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
16554	>	# Check whether this is an Automake generated Makefile which includes
16555	>	# dependency-tracking related rules and includes.
16556	>	# Grep'ing the whole file directly is not great: AIX grep has a line
16557		# limit of 2048, but all sed's we know have understand at least 4000.
16558	<	if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
16559	<	dirpart=`$as_dirname -- "$mf" ||
16560	<	$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16561	<	X"$mf" : 'X\(//\)[^/]' \| \
16562	<	X"$mf" : 'X\(//\)$' \| \
16563	<	X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
16564	<	$as_echo X"$mf" |
16558	>	sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
16559	>	|| continue
16560	>	am_dirpart=`$as_dirname -- "$am_mf" ||
16561	>	$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16562	>	X"$am_mf" : 'X\(//\)[^/]' \| \
16563	>	X"$am_mf" : 'X\(//\)$' \| \
16564	>	X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16565	>	$as_echo X"$am_mf" |
16566		sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
16567		s//\1/
16568		q
#	Line 15011 | Line 16580 | $as_echo X"$mf" |
16580		q
16581		}
16582		s/.*/./; q'`
16583	<	else
16584	<	continue
16585	<	fi
16586	<	# Extract the definition of DEPDIR, am__include, and am__quote
16587	<	# from the Makefile without running 'make'.
16588	<	DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
15020	<	test -z "$DEPDIR" && continue
15021	<	am__include=`sed -n 's/^am__include = //p' < "$mf"`
15022	<	test -z "$am__include" && continue
15023	<	am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
15024	<	# Find all dependency output files, they are included files with
15025	<	# $(DEPDIR) in their names.  We invoke sed twice because it is the
15026	<	# simplest approach to changing $(DEPDIR) to its actual value in the
15027	<	# expansion.
15028	<	for file in `sed -n "
15029	<	s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
15030	<	sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
15031	<	# Make sure the directory exists.
15032	<	test -f "$dirpart/$file" && continue
15033	<	fdir=`$as_dirname -- "$file" ||
15034	<	$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15035	<	X"$file" : 'X\(//\)[^/]' \| \
15036	<	X"$file" : 'X\(//\)$' \| \
15037	<	X"$file" : 'X\(/\)' \| . 2>/dev/null ||
15038	<	$as_echo X"$file" |
15039	<	sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
15040	<	s//\1/
15041	<	q
15042	<	}
15043	<	/^X\(\/\/\)[^/].*/{
16583	>	am_filepart=`$as_basename -- "$am_mf" ||
16584	>	$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
16585	>	X"$am_mf" : 'X\(//\)$' \| \
16586	>	X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16587	>	$as_echo X/"$am_mf" |
16588	>	sed '/^.*\/\([^/][^/]*\)\/*$/{
16589		s//\1/
16590		q
16591		}
16592	<	/^X\(\/\/\)$/{
16592	>	/^X\/\(\/\/\)$/{
16593		s//\1/
16594		q
16595		}
16596	<	/^X\(\/\).*/{
16596	>	/^X\/\(\/\).*/{
16597		s//\1/
16598		q
16599		}
16600		s/.*/./; q'`
16601	<	as_dir=$dirpart/$fdir; as_fn_mkdir_p
16602	<	# echo "creating $dirpart/$file"
16603	<	echo '# dummy' > "$dirpart/$file"
16604	<	done
16601	>	{ echo "$as_me:$LINENO: cd "$am_dirpart" \
16602	>	&& sed -e '/# am--include-marker/d' "$am_filepart" \
16603	>	| $MAKE -f - am--depfiles" >&5
16604	>	(cd "$am_dirpart" \
16605	>	&& sed -e '/# am--include-marker/d' "$am_filepart" \
16606	>	| $MAKE -f - am--depfiles) >&5 2>&5
16607	>	ac_status=$?
16608	>	echo "$as_me:$LINENO: \$? = $ac_status" >&5
16609	>	(exit $ac_status); } || am_rc=$?
16610		done
16611	+	if test $am_rc -ne 0; then
16612	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
16613	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
16614	+	as_fn_error $? "Something went wrong bootstrapping makefile fragments
16615	+	for automatic dependency tracking.  Try re-running configure with the
16616	+	'--disable-dependency-tracking' option to at least be able to build
16617	+	the package (albeit without support for automatic dependency tracking).
16618	+	See \`config.log' for more details" "$LINENO" 5; }
16619	+	fi
16620	+	{ am_dirpart=; unset am_dirpart;}
16621	+	{ am_filepart=; unset am_filepart;}
16622	+	{ am_mf=; unset am_mf;}
16623	+	{ am_rc=; unset am_rc;}
16624	+	rm -f conftest-deps.mk
16625		}
16626		;;
16627		"libtool":C)
#	Line 15107 | Line 16671 | $as_echo X"$file" |
16671		# The names of the tagged configurations supported by this script.
16672		available_tags=''
16673
16674	+	# Configured defaults for sys_lib_dlsearch_path munging.
16675	+	: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16676	+
16677		# ### BEGIN LIBTOOL CONFIG
16678
16679		# Which release of libtool.m4 was used?
#	Line 15356 | Line 16923 | hardcode_into_libs=$hardcode_into_libs
16923		# Compile-time system search path for libraries.
16924		sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16925
16926	<	# Run-time system search path for libraries.
16927	<	sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16926	>	# Detected run-time system search path for libraries.
16927	>	sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16928	>
16929	>	# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16930	>	configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16931
16932		# Whether dlopen is supported.
16933		dlopen_support=$enable_dlopen
#	Line 15508 | Line 17078 | hardcode_action=$hardcode_action
17078
17079		_LT_EOF
17080
17081	+	cat <<'_LT_EOF' >> "$cfgfile"
17082	+
17083	+	# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17084	+
17085	+	# func_munge_path_list VARIABLE PATH
17086	+	# -----------------------------------
17087	+	# VARIABLE is name of variable containing _space_ separated list of
17088	+	# directories to be munged by the contents of PATH, which is string
17089	+	# having a format:
17090	+	# "DIR[:DIR]:"
17091	+	#       string "DIR[ DIR]" will be prepended to VARIABLE
17092	+	# ":DIR[:DIR]"
17093	+	#       string "DIR[ DIR]" will be appended to VARIABLE
17094	+	# "DIRP[:DIRP]::[DIRA:]DIRA"
17095	+	#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17096	+	#       "DIRA[ DIRA]" will be appended to VARIABLE
17097	+	# "DIR[:DIR]"
17098	+	#       VARIABLE will be replaced by "DIR[ DIR]"
17099	+	func_munge_path_list ()
17100	+	{
17101	+	case x$2 in
17102	+	x)
17103	+	;;
17104	+	*:)
17105	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17106	+	;;
17107	+	x:*)
17108	+	eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17109	+	;;
17110	+	*::*)
17111	+	eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17112	+	eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17113	+	;;
17114	+	*)
17115	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17116	+	;;
17117	+	esac
17118	+	}
17119	+
17120	+
17121	+	# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17122	+	func_cc_basename ()
17123	+	{
17124	+	for cc_temp in $*""; do
17125	+	case $cc_temp in
17126	+	compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17127	+	distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17128	+	\-*) ;;
17129	+	*) break;;
17130	+	esac
17131	+	done
17132	+	func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17133	+	}
17134	+
17135	+
17136	+	# ### END FUNCTIONS SHARED WITH CONFIGURE
17137	+
17138	+	_LT_EOF
17139	+
17140		case $host_os in
17141		aix3*)
17142		cat <<\_LT_EOF >> "$cfgfile"
#	Line 15571 | Line 17200 | if test "$no_create" != yes; then
17200		# would make configure fail if this is the last instruction.
17201		$ac_cs_success || as_fn_exit 1
17202		fi
15574	–
15575	–	#
15576	–	# CONFIG_SUBDIRS section.
15577	–	#
15578	–	if test "$no_recursion" != yes; then
15579	–
15580	–	# Remove --cache-file, --srcdir, and --disable-option-checking arguments
15581	–	# so they do not pile up.
15582	–	ac_sub_configure_args=
15583	–	ac_prev=
15584	–	eval "set x $ac_configure_args"
15585	–	shift
15586	–	for ac_arg
15587	–	do
15588	–	if test -n "$ac_prev"; then
15589	–	ac_prev=
15590	–	continue
15591	–	fi
15592	–	case $ac_arg in
15593	–	-cache-file | --cache-file | --cache-fil | --cache-fi \
15594	–	| --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
15595	–	ac_prev=cache_file ;;
15596	–	-cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
15597	–	| --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
15598	–	| --c=*)
15599	–	;;
15600	–	--config-cache | -C)
15601	–	;;
15602	–	-srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
15603	–	ac_prev=srcdir ;;
15604	–	-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
15605	–	;;
15606	–	-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
15607	–	ac_prev=prefix ;;
15608	–	-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
15609	–	;;
15610	–	--disable-option-checking)
15611	–	;;
15612	–	*)
15613	–	case $ac_arg in
15614	–	*\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15615	–	esac
15616	–	as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
15617	–	esac
15618	–	done
15619	–
15620	–	# Always prepend --prefix to ensure using the same prefix
15621	–	# in subdir configurations.
15622	–	ac_arg="--prefix=$prefix"
15623	–	case $ac_arg in
15624	–	*\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15625	–	esac
15626	–	ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
15627	–
15628	–	# Pass --silent
15629	–	if test "$silent" = yes; then
15630	–	ac_sub_configure_args="--silent $ac_sub_configure_args"
15631	–	fi
15632	–
15633	–	# Always prepend --disable-option-checking to silence warnings, since
15634	–	# different subdirs can have different --enable and --with options.
15635	–	ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
15636	–
15637	–	ac_popdir=`pwd`
15638	–	for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
15639	–
15640	–	# Do not complain, so a configure script can configure whichever
15641	–	# parts of a large source tree are present.
15642	–	test -d "$srcdir/$ac_dir" || continue
15643	–
15644	–	ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
15645	–	$as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
15646	–	$as_echo "$ac_msg" >&6
15647	–	as_dir="$ac_dir"; as_fn_mkdir_p
15648	–	ac_builddir=.
15649	–
15650	–	case "$ac_dir" in
15651	–	.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
15652	–	*)
15653	–	ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
15654	–	# A ".." for each directory in $ac_dir_suffix.
15655	–	ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
15656	–	case $ac_top_builddir_sub in
15657	–	"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
15658	–	*)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
15659	–	esac ;;
15660	–	esac
15661	–	ac_abs_top_builddir=$ac_pwd
15662	–	ac_abs_builddir=$ac_pwd$ac_dir_suffix
15663	–	# for backward compatibility:
15664	–	ac_top_builddir=$ac_top_build_prefix
15665	–
15666	–	case $srcdir in
15667	–	.)  # We are building in place.
15668	–	ac_srcdir=.
15669	–	ac_top_srcdir=$ac_top_builddir_sub
15670	–	ac_abs_top_srcdir=$ac_pwd ;;
15671	–	[\\/]* | ?:[\\/]* )  # Absolute name.
15672	–	ac_srcdir=$srcdir$ac_dir_suffix;
15673	–	ac_top_srcdir=$srcdir
15674	–	ac_abs_top_srcdir=$srcdir ;;
15675	–	*) # Relative name.
15676	–	ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
15677	–	ac_top_srcdir=$ac_top_build_prefix$srcdir
15678	–	ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
15679	–	esac
15680	–	ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
15681	–
15682	–
15683	–	cd "$ac_dir"
15684	–
15685	–	# Check for guested configure; otherwise get Cygnus style configure.
15686	–	if test -f "$ac_srcdir/configure.gnu"; then
15687	–	ac_sub_configure=$ac_srcdir/configure.gnu
15688	–	elif test -f "$ac_srcdir/configure"; then
15689	–	ac_sub_configure=$ac_srcdir/configure
15690	–	elif test -f "$ac_srcdir/configure.in"; then
15691	–	# This should be Cygnus configure.
15692	–	ac_sub_configure=$ac_aux_dir/configure
15693	–	else
15694	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
15695	–	$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
15696	–	ac_sub_configure=
15697	–	fi
15698	–
15699	–	# The recursion is here.
15700	–	if test -n "$ac_sub_configure"; then
15701	–	# Make the cache file name correct relative to the subdirectory.
15702	–	case $cache_file in
15703	–	[\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
15704	–	*) # Relative name.
15705	–	ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
15706	–	esac
15707	–
15708	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
15709	–	$as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
15710	–	# The eval makes quoting arguments work.
15711	–	eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
15712	–	--cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
15713	–	as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
15714	–	fi
15715	–
15716	–	cd "$ac_popdir"
15717	–	done
15718	–	fi
17203		if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17204		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17205		$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}

Comparing hopm/trunk/configure (property svn:eol-style):
Revision 5122 by michael, Thu Dec 25 16:50:00 2014 UTC vs.
Revision 8857 by michael, Sat Feb 9 18:53:54 2019 UTC

#	Line 0 | Line 1
1	+	native

Comparing hopm/trunk/configure (property svn:keywords):
Revision 5122 by michael, Thu Dec 25 16:50:00 2014 UTC vs.
Revision 8857 by michael, Sat Feb 9 18:53:54 2019 UTC

#	Line 0 | Line 1
1	+	Id

Diff Legend

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