ViewVC Help

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

root/svn/hopm/branches/1.1.x/configure

Comparing:
hopm/trunk/configure (file contents), Revision 5122 by michael, Thu Dec 25 16:50:00 2014 UTC vs.
hopm/branches/1.1.x/configure (file contents), Revision 8552 by michael, Sat Sep 22 20:56:36 2018 UTC

#	Line 1 | Line 1
1		#! /bin/sh
2	+	# From configure.ac Id: configure.ac 8549 2018-09-22 20:55:30Z 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 1.1.5.
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='1.1.5'
595	>	PACKAGE_STRING='hopm 1.1.5'
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
641	<	subdirs
641	>	ENABLE_SSL_FALSE
642	>	ENABLE_SSL_TRUE
643		LEXLIB
644		LEX_OUTPUT_ROOT
645		LEX
646		YFLAGS
647		YACC
648		CPP
649	+	LT_SYS_LIBRARY_PATH
650		OTOOL64
651		OTOOL
652		LIPO
#	Line 761 | Line 766 | ac_user_opts='
766		enable_option_checking
767		enable_silent_rules
768		enable_maintainer_mode
764	–	with_extra_fascism
769		enable_dependency_tracking
770		enable_shared
771		enable_static
#	Line 771 | Line 775 | with_aix_soname
775		with_gnu_ld
776		with_sysroot
777		enable_libtool_lock
778	+	enable_openssl
779	+	enable_assert
780	+	enable_warnings
781		'
782		ac_precious_vars='build_alias
783		host_alias
#	Line 780 | Line 787 | CFLAGS
787		LDFLAGS
788		LIBS
789		CPPFLAGS
790	+	LT_SYS_LIBRARY_PATH
791		CPP
792		YACC
793		YFLAGS'
794	<	ac_subdirs_all='src/libopm'
794	>
795
796		# Initialize some variables set by options.
797		ac_init_help=
#	Line 1323 | Line 1331 | if test "$ac_init_help" = "long"; then
1331		# Omit some internal or obsolete options to make the list less imposing.
1332		# This message is too long to be a string in the A/UX 3.1 sh.
1333		cat <<_ACEOF
1334	<	\`configure' configures hopm 1.0.0beta1 to adapt to many kinds of systems.
1334	>	\`configure' configures hopm 1.1.5 to adapt to many kinds of systems.
1335
1336		Usage: $0 [OPTION]... [VAR=VALUE]...
1337
#	Line 1393 | Line 1401 | fi
1401
1402		if test -n "$ac_init_help"; then
1403		case $ac_init_help in
1404	<	short | recursive ) echo "Configuration of hopm 1.0.0beta1:";;
1404	>	short | recursive ) echo "Configuration of hopm 1.1.5:";;
1405		esac
1406		cat <<\_ACEOF
1407
#	Line 1415 | Line 1423 | Optional Features:
1423		--enable-fast-install[=PKGS]
1424		optimize for fast installation [default=yes]
1425		--disable-libtool-lock  avoid locking (might break parallel builds)
1426	+	--enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1427	+	--disable-openssl            Disable LibreSSL/OpenSSL support.
1428	+	--enable-assert         Enable assert() statements
1429	+	--enable-warnings       Enable compiler warnings.
1430
1431		Optional Packages:
1432		--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1433		--without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1422	–	--with-extra-fascism    Add extra gcc3-specific warning flags
1434		--with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1435		both]
1436		--with-aix-soname=aix|svr4|both
#	Line 1437 | Line 1448 | Some influential environment variables:
1448		LIBS        libraries to pass to the linker, e.g. -l<library>
1449		CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1450		you have headers in a nonstandard directory <include dir>
1451	+	LT_SYS_LIBRARY_PATH
1452	+	User-defined run-time library search path.
1453		CPP         C preprocessor
1454		YACC        The `Yet Another Compiler Compiler' implementation to use.
1455		Defaults to the first program found out of: `bison -y', `byacc',
#	Line 1448 | Line 1461 | Some influential environment variables:
1461		Use these variables to override the choices made by `configure' or to help
1462		it to find libraries and programs with nonstandard names/locations.
1463
1464	<	Report bugs to the package provider.
1464	>	Report bugs to <bugs@ircd-hybrid.org>.
1465		_ACEOF
1466		ac_status=$?
1467		fi
#	Line 1511 | Line 1524 | fi
1524		test -n "$ac_init_help" && exit $ac_status
1525		if $ac_init_version; then
1526		cat <<\_ACEOF
1527	<	hopm configure 1.0.0beta1
1527	>	hopm configure 1.1.5
1528		generated by GNU Autoconf 2.69
1529
1530		Copyright (C) 2012 Free Software Foundation, Inc.
#	Line 1785 | Line 1798 | $as_echo "$ac_res" >&6; }
1798		eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1799
1800		} # 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
1801		cat >config.log <<_ACEOF
1802		This file contains any messages produced by compilers while
1803		running configure, to aid debugging if configure makes a mistake.
1804
1805	<	It was created by hopm $as_me 1.0.0beta1, which was
1805	>	It was created by hopm $as_me 1.1.5, which was
1806		generated by GNU Autoconf 2.69.  Invocation command line was
1807
1808		$ $0 $@
#	Line 2461 | Line 2150 | ac_link='$CC -o conftest$ac_exeext $CFLA
2150		ac_compiler_gnu=$ac_cv_c_compiler_gnu
2151
2152
2153	<
2465	<	ac_config_headers="$ac_config_headers src/setup.h"
2466	<
2467	<	am__api_version='1.14'
2153	>	am__api_version='1.15'
2154
2155		ac_aux_dir=
2156		for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
#	Line 2665 | Line 2351 | test "$program_suffix" != NONE &&
2351		ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2352		program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2353
2354	<	# expand $ac_aux_dir to an absolute path
2355	<	am_aux_dir=`cd $ac_aux_dir && pwd`
2354	>	# Expand $ac_aux_dir to an absolute path.
2355	>	am_aux_dir=`cd "$ac_aux_dir" && pwd`
2356
2357		if test x"${MISSING+set}" != xset; then
2358		case $am_aux_dir in
#	Line 2685 | Line 2371 | else
2371		$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2372		fi
2373
2374	<	if test x"${install_sh}" != xset; then
2374	>	if test x"${install_sh+set}" != xset; then
2375		case $am_aux_dir in
2376		*\ * | *\     *)
2377		install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
#	Line 2979 | Line 2665 | fi
2665
2666		# Define the identity of the package.
2667		PACKAGE='hopm'
2668	<	VERSION='1.0.0beta1'
2668	>	VERSION='1.1.5'
2669
2670
2671		cat >>confdefs.h <<_ACEOF
#	Line 3013 | Line 2699 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2699		# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2700		mkdir_p='$(MKDIR_P)'
2701
2702	<	# We need awk for the "check" target.  The system "awk" is bad on
2703	<	# some platforms.
2702	>	# We need awk for the "check" target (and possibly the TAP driver).  The
2703	>	# system "awk" is bad on some platforms.
2704		# Always define AMTAR for backward compatibility.  Yes, it's still used
2705		# in the wild :-(  We should find a proper way to deprecate it ...
2706		AMTAR='$${TAR-tar}'
#	Line 3096 | Line 2782 | fi
2782
2783
2784
2785	<
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	<
2785	>	ac_config_headers="$ac_config_headers src/setup.h"
2786
2787
2788
#	Line 4333 | Line 4014 | esac
4014
4015
4016
4017	<	macro_version='2.4.4'
4018	<	macro_revision='2.4.4'
4017	>	macro_version='2.4.6'
4018	>	macro_revision='2.4.6'
4019
4020
4021
#	Line 6757 | Line 6438 | $as_echo "$lt_cv_truncate_bin" >&6; }
6438
6439
6440
6441	+
6442	+	# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6443	+	func_cc_basename ()
6444	+	{
6445	+	for cc_temp in $*""; do
6446	+	case $cc_temp in
6447	+	compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6448	+	distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6449	+	\-*) ;;
6450	+	*) break;;
6451	+	esac
6452	+	done
6453	+	func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6454	+	}
6455	+
6456		# Check whether --enable-libtool-lock was given.
6457		if test "${enable_libtool_lock+set}" = set; then :
6458		enableval=$enable_libtool_lock;
#	Line 7764 | Line 7460 | $as_echo "$lt_cv_ld_force_load" >&6; }
7460		;;
7461		esac
7462
7463	+	# func_munge_path_list VARIABLE PATH
7464	+	# -----------------------------------
7465	+	# VARIABLE is name of variable containing _space_ separated list of
7466	+	# directories to be munged by the contents of PATH, which is string
7467	+	# having a format:
7468	+	# "DIR[:DIR]:"
7469	+	#       string "DIR[ DIR]" will be prepended to VARIABLE
7470	+	# ":DIR[:DIR]"
7471	+	#       string "DIR[ DIR]" will be appended to VARIABLE
7472	+	# "DIRP[:DIRP]::[DIRA:]DIRA"
7473	+	#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7474	+	#       "DIRA[ DIRA]" will be appended to VARIABLE
7475	+	# "DIR[:DIR]"
7476	+	#       VARIABLE will be replaced by "DIR[ DIR]"
7477	+	func_munge_path_list ()
7478	+	{
7479	+	case x$2 in
7480	+	x)
7481	+	;;
7482	+	*:)
7483	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7484	+	;;
7485	+	x:*)
7486	+	eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7487	+	;;
7488	+	*::*)
7489	+	eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7490	+	eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7491	+	;;
7492	+	*)
7493	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7494	+	;;
7495	+	esac
7496	+	}
7497	+
7498		ac_ext=c
7499		ac_cpp='$CPP $CPPFLAGS'
7500		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 8351 | Line 8082 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8082		test -z "$LD" && LD=ld
8083		test -z "$ac_objext" && ac_objext=o
8084
8085	<	for cc_temp in $compiler""; do
8086	<	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-%%"`
8085	>	func_cc_basename $compiler
8086	>	cc_basename=$func_cc_basename_result
8087
8088
8089		# Only perform the check for file, if the check method requires it
#	Line 8559 | Line 8283 | _lt_linker_boilerplate=`cat conftest.err
8283		$RM -r conftest*
8284
8285
8286	+	## CAVEAT EMPTOR:
8287	+	## There is no encapsulation within the following macros, do not change
8288	+	## the running order or otherwise move them around unless you know exactly
8289	+	## what you are doing...
8290		if test -n "$compiler"; then
8291
8292		lt_prog_compiler_no_builtin_flag=
#	Line 10814 | Line 10542 | hardcode_into_libs=no
10542		# flags to be left without arguments
10543		need_version=unknown
10544
10545	+
10546	+
10547		case $host_os in
10548		aix3*)
10549		version_type=linux # correct to gnu/linux during the next big refactor
#	Line 11102 | Line 10832 | freebsd* | dragonfly*)
10832		case $version_type in
10833		freebsd-elf*)
10834		library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10835	+	soname_spec='$libname$release$shared_ext$major'
10836		need_version=no
10837		need_lib_prefix=no
10838		;;
#	Line 11161 | Line 10892 | hpux9* | hpux10* | hpux11*)
10892		soname_spec='$libname$release$shared_ext$major'
10893		if test 32 = "$HPUX_IA64_MODE"; then
10894		sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10895	+	sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10896		else
10897		sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10898	+	sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10899		fi
11167	–	sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10900		;;
10901		hppa*64*)
10902		shrext_cmds='.sl'
#	Line 11316 | Line 11048 | fi
11048		# before this can be enabled.
11049		hardcode_into_libs=yes
11050
11051	<	# Append ld.so.conf contents to the search path
11051	>	# Ideally, we could use ldconfig to report *all* directores which are
11052	>	# searched for libraries, however this is still not possible.  Aside from not
11053	>	# being certain /sbin/ldconfig is available, command
11054	>	# 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11055	>	# even though it is searched at run-time.  Try to do the best guess by
11056	>	# appending ld.so.conf contents (and includes) to the search path.
11057		if test -f /etc/ld.so.conf; then
11058		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' ' '`
11059		sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
#	Line 11541 | Line 11278 | fi
11278		if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11279		sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11280		fi
11281	+
11282		if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11283		sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11284		fi
11285
11286	+	# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11287	+	configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11288	+
11289	+	# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11290	+	func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11291	+
11292	+	# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11293	+	configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11294	+
11295	+
11296	+
11297	+
11298	+
11299	+
11300
11301
11302
#	Line 12325 | Line 12077 | CC=$lt_save_CC
12077
12078
12079
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	–
12080		for ac_prog in 'bison -y' byacc
12081		do
12082		# Extract the first word of "$ac_prog", so it can be a program name with args.
#	Line 12813 | Line 12284 | if test "$LEX" = :; then
12284		LEX=${am_missing_run}flex
12285		fi
12286
12287	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12288	<	$as_echo_n "checking for library containing socket... " >&6; }
12289	<	if ${ac_cv_search_socket+:} false; then :
12287	>
12288	>
12289	>	if test "X$CC" != "X"; then
12290	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12291	>	$as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12292	>	if ${ssp_cv_cc+:} false; then :
12293		$as_echo_n "(cached) " >&6
12294		else
12295	<	ac_func_search_save_LIBS=$LIBS
12296	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12295	>	ssp_old_cflags="$CFLAGS"
12296	>	CFLAGS="$CFLAGS -fstack-protector-strong"
12297	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12298		/* end confdefs.h.  */
12299
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 ();
12300		int
12301		main ()
12302		{
12303	<	return socket ();
12303	>
12304		;
12305		return 0;
12306		}
12307		_ACEOF
12308	<	for ac_lib in '' socket; do
12309	<	if test -z "$ac_lib"; then
12310	<	ac_res="none required"
12311	<	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
12308	>	if ac_fn_c_try_compile "$LINENO"; then :
12309	>	ssp_cv_cc=yes
12310	>	else
12311	>	ssp_cv_cc=no
12312		fi
12313	<	rm -f core conftest.err conftest.$ac_objext \
12314	<	conftest$ac_exeext
12315	<	if ${ac_cv_search_socket+:} false; then :
12853	<	break
12313	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12314	>	CFLAGS="$ssp_old_cflags"
12315	>
12316		fi
12317	<	done
12318	<	if ${ac_cv_search_socket+:} false; then :
12317	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12318	>	$as_echo "$ssp_cv_cc" >&6; }
12319	>	if test $ssp_cv_cc = yes; then
12320	>	CFLAGS="$CFLAGS -fstack-protector-strong"
12321
12322	+	$as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12323	+
12324	+	else
12325	+	unset ssp_cv_cc
12326	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12327	+	$as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12328	+	if ${ssp_cv_cc+:} false; then :
12329	+	$as_echo_n "(cached) " >&6
12330		else
12331	<	ac_cv_search_socket=no
12331	>	ssp_old_cflags="$CFLAGS"
12332	>	CFLAGS="$CFLAGS -fstack-protector"
12333	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12334	>	/* end confdefs.h.  */
12335	>
12336	>	int
12337	>	main ()
12338	>	{
12339	>
12340	>	;
12341	>	return 0;
12342	>	}
12343	>	_ACEOF
12344	>	if ac_fn_c_try_compile "$LINENO"; then :
12345	>	ssp_cv_cc=yes
12346	>	else
12347	>	ssp_cv_cc=no
12348		fi
12349	<	rm conftest.$ac_ext
12350	<	LIBS=$ac_func_search_save_LIBS
12349	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12350	>	CFLAGS="$ssp_old_cflags"
12351	>
12352		fi
12353	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12354	<	$as_echo "$ac_cv_search_socket" >&6; }
12355	<	ac_res=$ac_cv_search_socket
12356	<	if test "$ac_res" != no; then :
12868	<	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12353	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12354	>	$as_echo "$ssp_cv_cc" >&6; }
12355	>	if test $ssp_cv_cc = yes; then
12356	>	CFLAGS="$CFLAGS -fstack-protector"
12357
12358	+	$as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12359	+
12360	+	fi
12361	+	fi
12362	+	fi
12363	+
12364	+
12365	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12366	+	$as_echo_n "checking whether libssp exists... " >&6; }
12367	+	if ${ssp_cv_lib+:} false; then :
12368	+	$as_echo_n "(cached) " >&6
12369		else
12370	<	as_fn_error $? "socket library not found" "$LINENO" 5
12370	>	ssp_old_libs="$LIBS"
12371	>	LIBS="$LIBS -lssp"
12372	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12373	>	/* end confdefs.h.  */
12374	>
12375	>	int
12376	>	main ()
12377	>	{
12378	>
12379	>	;
12380	>	return 0;
12381	>	}
12382	>	_ACEOF
12383	>	if ac_fn_c_try_link "$LINENO"; then :
12384	>	ssp_cv_lib=yes
12385	>	else
12386	>	ssp_cv_lib=no
12387		fi
12388	+	rm -f core conftest.err conftest.$ac_objext \
12389	+	conftest$ac_exeext conftest.$ac_ext
12390	+	LIBS="$ssp_old_libs"
12391
12392	<	ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12392	>	fi
12393	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12394	>	$as_echo "$ssp_cv_lib" >&6; }
12395	>	if test $ssp_cv_lib = yes; then
12396	>	LIBS="$LIBS -lssp"
12397	>	fi
12398	>
12399	>
12400	>
12401	>	ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12402		if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12403
12404		else
#	Line 12933 | Line 12460 | fi
12460
12461		fi
12462
12463	<	ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12463	>	ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12464		if test "x$ac_cv_func_getnameinfo" = xyes; then :
12465
12466		else
#	Line 12995 | Line 12522 | fi
12522
12523		fi
12524
12525	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12526	+	$as_echo_n "checking for library containing socket... " >&6; }
12527	+	if ${ac_cv_search_socket+:} false; then :
12528	+	$as_echo_n "(cached) " >&6
12529	+	else
12530	+	ac_func_search_save_LIBS=$LIBS
12531	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12532	+	/* end confdefs.h.  */
12533
12534	<	for ac_func in strlcpy strlcat inet_aton inet_pton socket strdup strstr
12535	<	do :
12536	<	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12537	<	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12538	<	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12534	>	/* Override any GCC internal prototype to avoid an error.
12535	>	Use char because int might match the return type of a GCC
12536	>	builtin and then its argument prototype would still apply.  */
12537	>	#ifdef __cplusplus
12538	>	extern "C"
12539	>	#endif
12540	>	char socket ();
12541	>	int
12542	>	main ()
12543	>	{
12544	>	return socket ();
12545	>	;
12546	>	return 0;
12547	>	}
12548	>	_ACEOF
12549	>	for ac_lib in '' socket; do
12550	>	if test -z "$ac_lib"; then
12551	>	ac_res="none required"
12552	>	else
12553	>	ac_res=-l$ac_lib
12554	>	LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12555	>	fi
12556	>	if ac_fn_c_try_link "$LINENO"; then :
12557	>	ac_cv_search_socket=$ac_res
12558	>	fi
12559	>	rm -f core conftest.err conftest.$ac_objext \
12560	>	conftest$ac_exeext
12561	>	if ${ac_cv_search_socket+:} false; then :
12562	>	break
12563	>	fi
12564	>	done
12565	>	if ${ac_cv_search_socket+:} false; then :
12566	>
12567	>	else
12568	>	ac_cv_search_socket=no
12569	>	fi
12570	>	rm conftest.$ac_ext
12571	>	LIBS=$ac_func_search_save_LIBS
12572	>	fi
12573	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12574	>	$as_echo "$ac_cv_search_socket" >&6; }
12575	>	ac_res=$ac_cv_search_socket
12576	>	if test "$ac_res" != no; then :
12577	>	test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12578	>
12579	>	else
12580	>	as_fn_error $? "socket library not found" "$LINENO" 5
12581	>	fi
12582	>
12583	>
12584	>
12585	>	# Check whether --enable-openssl was given.
12586	>	if test "${enable_openssl+set}" = set; then :
12587	>	enableval=$enable_openssl;  cf_enable_openssl=$enableval
12588	>	else
12589	>	cf_enable_openssl="auto"
12590	>	fi
12591	>
12592	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12593	>	$as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12594	>	if test "$cf_enable_openssl" != "no"; then
12595	>	cf_openssl_basedir=""
12596	>	if test "$cf_enable_openssl" != "auto" &&
12597	>	test "$cf_enable_openssl" != "yes"; then
12598	>	cf_openssl_basedir="${cf_enable_openssl}"
12599	>	else
12600	>	for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12601	>	/opt /opt/openssl /usr/local/openssl; do
12602	>	if test -f "${dirs}/include/openssl/opensslv.h"; then
12603	>	cf_openssl_basedir="${dirs}"
12604	>	break
12605	>	fi
12606	>	done
12607	>	unset dirs
12608	>	fi
12609	>
12610	>	if test ! -z "$cf_openssl_basedir"; then
12611	>	if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12612	>	CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12613	>	LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12614	>	else
12615	>	cf_openssl_basedir=""
12616	>	fi
12617	>	else
12618	>	if test -f "/usr/include/openssl/opensslv.h"; then
12619	>	cf_openssl_basedir="/usr"
12620	>	fi
12621	>	fi
12622	>
12623	>	if test ! -z "$cf_openssl_basedir"; then
12624	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12625	>	$as_echo "$cf_openssl_basedir" >&6; }
12626	>	cf_enable_openssl="yes"
12627	>	else
12628	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12629	>	$as_echo "not found. Please check your path." >&6; }
12630	>	cf_enable_openssl="no"
12631	>	fi
12632	>	unset cf_openssl_basedir
12633	>	else
12634	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12635	>	$as_echo "disabled" >&6; }
12636	>	fi
12637	>
12638	>	if test "$cf_enable_openssl" != "no"; then :
12639	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 0.9.8o and above" >&5
12640	>	$as_echo_n "checking for LibreSSL or OpenSSL 0.9.8o and above... " >&6; }
12641	>	if test "$cross_compiling" = yes; then :
12642	>	cf_openssl_version_ok=no
12643	>	else
12644	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12645	>	/* end confdefs.h.  */
12646	>
12647	>
12648	>	#include <openssl/opensslv.h>
12649	>	#include <stdlib.h>
12650	>	int
12651	>	main ()
12652	>	{
12653	>	exit(!(OPENSSL_VERSION_NUMBER >= 0x009080ffL));
12654	>	;
12655	>	return 0;
12656	>	}
12657	>	_ACEOF
12658	>	if ac_fn_c_try_run "$LINENO"; then :
12659	>	cf_openssl_version_ok=yes
12660	>	else
12661	>	cf_openssl_version_ok=no
12662	>	fi
12663	>	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12664	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
12665	>	fi
12666	>
12667	>
12668	>	if test "$cf_openssl_version_ok" = "yes"; then :
12669	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12670	>	$as_echo "found" >&6; }
12671	>
12672	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12673	>	$as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12674	>	if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12675	>	$as_echo_n "(cached) " >&6
12676	>	else
12677	>	ac_check_lib_save_LIBS=$LIBS
12678	>	LIBS="-lcrypto  $LIBS"
12679	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12680	>	/* end confdefs.h.  */
12681	>
12682	>	/* Override any GCC internal prototype to avoid an error.
12683	>	Use char because int might match the return type of a GCC
12684	>	builtin and then its argument prototype would still apply.  */
12685	>	#ifdef __cplusplus
12686	>	extern "C"
12687	>	#endif
12688	>	char RSA_free ();
12689	>	int
12690	>	main ()
12691	>	{
12692	>	return RSA_free ();
12693	>	;
12694	>	return 0;
12695	>	}
12696	>	_ACEOF
12697	>	if ac_fn_c_try_link "$LINENO"; then :
12698	>	ac_cv_lib_crypto_RSA_free=yes
12699	>	else
12700	>	ac_cv_lib_crypto_RSA_free=no
12701	>	fi
12702	>	rm -f core conftest.err conftest.$ac_objext \
12703	>	conftest$ac_exeext conftest.$ac_ext
12704	>	LIBS=$ac_check_lib_save_LIBS
12705	>	fi
12706	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12707	>	$as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12708	>	if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12709		cat >>confdefs.h <<_ACEOF
12710	<	#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12710	>	#define HAVE_LIBCRYPTO 1
12711		_ACEOF
12712
12713	+	LIBS="-lcrypto $LIBS"
12714	+
12715		fi
13009	–	done
12716
12717	+	if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12718	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12719	+	$as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12720	+	if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12721	+	$as_echo_n "(cached) " >&6
12722	+	else
12723	+	ac_check_lib_save_LIBS=$LIBS
12724	+	LIBS="-lssl  $LIBS"
12725	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12726	+	/* end confdefs.h.  */
12727
12728	<	for ac_func in gethostbyname
12729	<	do :
12730	<	ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
12731	<	if test "x$ac_cv_func_gethostbyname" = xyes; then :
12728	>	/* Override any GCC internal prototype to avoid an error.
12729	>	Use char because int might match the return type of a GCC
12730	>	builtin and then its argument prototype would still apply.  */
12731	>	#ifdef __cplusplus
12732	>	extern "C"
12733	>	#endif
12734	>	char SSL_connect ();
12735	>	int
12736	>	main ()
12737	>	{
12738	>	return SSL_connect ();
12739	>	;
12740	>	return 0;
12741	>	}
12742	>	_ACEOF
12743	>	if ac_fn_c_try_link "$LINENO"; then :
12744	>	ac_cv_lib_ssl_SSL_connect=yes
12745	>	else
12746	>	ac_cv_lib_ssl_SSL_connect=no
12747	>	fi
12748	>	rm -f core conftest.err conftest.$ac_objext \
12749	>	conftest$ac_exeext conftest.$ac_ext
12750	>	LIBS=$ac_check_lib_save_LIBS
12751	>	fi
12752	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12753	>	$as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12754	>	if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12755		cat >>confdefs.h <<_ACEOF
12756	<	#define HAVE_GETHOSTBYNAME 1
12756	>	#define HAVE_LIBSSL 1
12757		_ACEOF
12758
12759	+	LIBS="-lssl $LIBS"
12760	+
12761	+	fi
12762	+
12763	+	fi
12764	+
12765	+	else
12766	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12767	+	$as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12768	+	cf_enable_openssl="no"
12769	+	fi
12770	+	fi
12771	+
12772	+	if test "$ac_cv_lib_ssl_SSL_connect" = yes; then
12773	+	ENABLE_SSL_TRUE=
12774	+	ENABLE_SSL_FALSE='#'
12775	+	else
12776	+	ENABLE_SSL_TRUE='#'
12777	+	ENABLE_SSL_FALSE=
12778	+	fi
12779	+
12780	+
12781	+
12782	+	# Check whether --enable-assert was given.
12783	+	if test "${enable_assert+set}" = set; then :
12784	+	enableval=$enable_assert; assert=$enableval
12785	+	else
12786	+	assert=no
12787	+	fi
12788	+
12789	+
12790	+	if test "$assert" = "no"; then :
12791	+
12792	+	$as_echo "#define NDEBUG 1" >>confdefs.h
12793	+
12794	+	fi
12795	+
12796	+
12797	+	# Check whether --enable-warnings was given.
12798	+	if test "${enable_warnings+set}" = set; then :
12799	+	enableval=$enable_warnings; warnings="$enableval"
12800	+	else
12801	+	warnings="no"
12802	+	fi
12803	+
12804	+
12805	+	if test "$warnings" = "yes"; then :
12806	+
12807	+
12808	+
12809	+
12810	+
12811	+	for flag in -Wall; do
12812	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12813	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12814	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12815	+	if eval \${$as_CACHEVAR+:} false; then :
12816	+	$as_echo_n "(cached) " >&6
12817	+	else
12818	+
12819	+	ax_check_save_flags=$CFLAGS
12820	+	CFLAGS="$CFLAGS  $flag"
12821	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12822	+	/* end confdefs.h.  */
12823	+
12824	+	int
12825	+	main ()
12826	+	{
12827	+
12828	+	;
12829	+	return 0;
12830	+	}
12831	+	_ACEOF
12832	+	if ac_fn_c_try_compile "$LINENO"; then :
12833	+	eval "$as_CACHEVAR=yes"
12834	+	else
12835	+	eval "$as_CACHEVAR=no"
12836	+	fi
12837	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12838	+	CFLAGS=$ax_check_save_flags
12839	+	fi
12840	+	eval ac_res=\$$as_CACHEVAR
12841	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12842	+	$as_echo "$ac_res" >&6; }
12843	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12844	+
12845	+	if ${CFLAGS+:} false; then :
12846	+
12847	+	case " $CFLAGS " in #(
12848	+	*" $flag "*) :
12849	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12850	+	(: CFLAGS already contains $flag) 2>&5
12851	+	ac_status=$?
12852	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12853	+	test $ac_status = 0; } ;; #(
12854	+	*) :
12855	+
12856	+	as_fn_append CFLAGS " $flag"
12857	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12858	+	(: CFLAGS="$CFLAGS") 2>&5
12859	+	ac_status=$?
12860	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12861	+	test $ac_status = 0; }
12862	+	;;
12863	+	esac
12864	+
12865	+	else
12866	+
12867	+	CFLAGS=$flag
12868	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12869	+	(: CFLAGS="$CFLAGS") 2>&5
12870	+	ac_status=$?
12871	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12872	+	test $ac_status = 0; }
12873	+
12874		fi
12875	+
12876	+	else
12877	+	:
12878	+	fi
12879	+
12880		done
12881
12882
12883	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
12884	<	$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
12885	<	if ${ac_cv_c_bigendian+:} false; then :
12883	>
12884	>
12885	>
12886	>	for flag in -Wbad-function-cast; do
12887	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12888	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12889	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12890	>	if eval \${$as_CACHEVAR+:} false; then :
12891		$as_echo_n "(cached) " >&6
12892		else
12893	<	ac_cv_c_bigendian=unknown
12894	<	# See if we're dealing with a universal compiler.
12895	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12893	>
12894	>	ax_check_save_flags=$CFLAGS
12895	>	CFLAGS="$CFLAGS  $flag"
12896	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12897		/* end confdefs.h.  */
13033	–	#ifndef __APPLE_CC__
13034	–	not a universal capable compiler
13035	–	#endif
13036	–	typedef int dummy;
12898
12899	+	int
12900	+	main ()
12901	+	{
12902	+
12903	+	;
12904	+	return 0;
12905	+	}
12906		_ACEOF
12907		if ac_fn_c_try_compile "$LINENO"; then :
12908	+	eval "$as_CACHEVAR=yes"
12909	+	else
12910	+	eval "$as_CACHEVAR=no"
12911	+	fi
12912	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12913	+	CFLAGS=$ax_check_save_flags
12914	+	fi
12915	+	eval ac_res=\$$as_CACHEVAR
12916	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12917	+	$as_echo "$ac_res" >&6; }
12918	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12919
12920	<	# Check for potential -arch flags.  It is not universal unless
12921	<	# there are at least two -arch flags with different values.
12922	<	ac_arch=
12923	<	ac_prev=
12924	<	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12925	<	if test -n "$ac_prev"; then
12926	<	case $ac_word in
12927	<	i?86 | x86_64 | ppc | ppc64)
12928	<	if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12929	<	ac_arch=$ac_word
12930	<	else
12931	<	ac_cv_c_bigendian=universal
12932	<	break
12933	<	fi
12934	<	;;
12935	<	esac
12936	<	ac_prev=
12937	<	elif test "x$ac_word" = "x-arch"; then
12938	<	ac_prev=arch
12939	<	fi
12940	<	done
12920	>	if ${CFLAGS+:} false; then :
12921	>
12922	>	case " $CFLAGS " in #(
12923	>	*" $flag "*) :
12924	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12925	>	(: CFLAGS already contains $flag) 2>&5
12926	>	ac_status=$?
12927	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12928	>	test $ac_status = 0; } ;; #(
12929	>	*) :
12930	>
12931	>	as_fn_append CFLAGS " $flag"
12932	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12933	>	(: CFLAGS="$CFLAGS") 2>&5
12934	>	ac_status=$?
12935	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12936	>	test $ac_status = 0; }
12937	>	;;
12938	>	esac
12939	>
12940	>	else
12941	>
12942	>	CFLAGS=$flag
12943	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12944	>	(: CFLAGS="$CFLAGS") 2>&5
12945	>	ac_status=$?
12946	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12947	>	test $ac_status = 0; }
12948	>
12949	>	fi
12950	>
12951	>	else
12952	>	:
12953	>	fi
12954	>
12955	>	done
12956	>
12957	>
12958	>
12959	>
12960	>
12961	>	for flag in -Wcast-align; do
12962	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12963	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12964	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12965	>	if eval \${$as_CACHEVAR+:} false; then :
12966	>	$as_echo_n "(cached) " >&6
12967	>	else
12968	>
12969	>	ax_check_save_flags=$CFLAGS
12970	>	CFLAGS="$CFLAGS  $flag"
12971	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12972	>	/* end confdefs.h.  */
12973	>
12974	>	int
12975	>	main ()
12976	>	{
12977	>
12978	>	;
12979	>	return 0;
12980	>	}
12981	>	_ACEOF
12982	>	if ac_fn_c_try_compile "$LINENO"; then :
12983	>	eval "$as_CACHEVAR=yes"
12984	>	else
12985	>	eval "$as_CACHEVAR=no"
12986		fi
12987		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12988	<	if test $ac_cv_c_bigendian = unknown; then
12989	<	# See if sys/param.h defines the BYTE_ORDER macro.
12990	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12988	>	CFLAGS=$ax_check_save_flags
12989	>	fi
12990	>	eval ac_res=\$$as_CACHEVAR
12991	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12992	>	$as_echo "$ac_res" >&6; }
12993	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12994	>
12995	>	if ${CFLAGS+:} false; then :
12996	>
12997	>	case " $CFLAGS " in #(
12998	>	*" $flag "*) :
12999	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13000	>	(: CFLAGS already contains $flag) 2>&5
13001	>	ac_status=$?
13002	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13003	>	test $ac_status = 0; } ;; #(
13004	>	*) :
13005	>
13006	>	as_fn_append CFLAGS " $flag"
13007	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13008	>	(: CFLAGS="$CFLAGS") 2>&5
13009	>	ac_status=$?
13010	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13011	>	test $ac_status = 0; }
13012	>	;;
13013	>	esac
13014	>
13015	>	else
13016	>
13017	>	CFLAGS=$flag
13018	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13019	>	(: CFLAGS="$CFLAGS") 2>&5
13020	>	ac_status=$?
13021	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13022	>	test $ac_status = 0; }
13023	>
13024	>	fi
13025	>
13026	>	else
13027	>	:
13028	>	fi
13029	>
13030	>	done
13031	>
13032	>
13033	>
13034	>
13035	>
13036	>	for flag in -Wcast-qual; do
13037	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13038	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13039	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13040	>	if eval \${$as_CACHEVAR+:} false; then :
13041	>	$as_echo_n "(cached) " >&6
13042	>	else
13043	>
13044	>	ax_check_save_flags=$CFLAGS
13045	>	CFLAGS="$CFLAGS  $flag"
13046	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13047		/* end confdefs.h.  */
13068	–	#include <sys/types.h>
13069	–	#include <sys/param.h>
13048
13049		int
13050		main ()
13051		{
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
13052
13053		;
13054		return 0;
13055		}
13056		_ACEOF
13057		if ac_fn_c_try_compile "$LINENO"; then :
13058	<	# It does; now see whether it defined to BIG_ENDIAN or not.
13059	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13058	>	eval "$as_CACHEVAR=yes"
13059	>	else
13060	>	eval "$as_CACHEVAR=no"
13061	>	fi
13062	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13063	>	CFLAGS=$ax_check_save_flags
13064	>	fi
13065	>	eval ac_res=\$$as_CACHEVAR
13066	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13067	>	$as_echo "$ac_res" >&6; }
13068	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13069	>
13070	>	if ${CFLAGS+:} false; then :
13071	>
13072	>	case " $CFLAGS " in #(
13073	>	*" $flag "*) :
13074	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13075	>	(: CFLAGS already contains $flag) 2>&5
13076	>	ac_status=$?
13077	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13078	>	test $ac_status = 0; } ;; #(
13079	>	*) :
13080	>
13081	>	as_fn_append CFLAGS " $flag"
13082	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13083	>	(: CFLAGS="$CFLAGS") 2>&5
13084	>	ac_status=$?
13085	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13086	>	test $ac_status = 0; }
13087	>	;;
13088	>	esac
13089	>
13090	>	else
13091	>
13092	>	CFLAGS=$flag
13093	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13094	>	(: CFLAGS="$CFLAGS") 2>&5
13095	>	ac_status=$?
13096	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13097	>	test $ac_status = 0; }
13098	>
13099	>	fi
13100	>
13101	>	else
13102	>	:
13103	>	fi
13104	>
13105	>	done
13106	>
13107	>
13108	>
13109	>
13110	>
13111	>	for flag in -Wclobbered; do
13112	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13113	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13114	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13115	>	if eval \${$as_CACHEVAR+:} false; then :
13116	>	$as_echo_n "(cached) " >&6
13117	>	else
13118	>
13119	>	ax_check_save_flags=$CFLAGS
13120	>	CFLAGS="$CFLAGS  $flag"
13121	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13122		/* end confdefs.h.  */
13088	–	#include <sys/types.h>
13089	–	#include <sys/param.h>
13123
13124		int
13125		main ()
13126		{
13094	–	#if BYTE_ORDER != BIG_ENDIAN
13095	–	not big endian
13096	–	#endif
13127
13128		;
13129		return 0;
13130		}
13131		_ACEOF
13132		if ac_fn_c_try_compile "$LINENO"; then :
13133	<	ac_cv_c_bigendian=yes
13133	>	eval "$as_CACHEVAR=yes"
13134		else
13135	<	ac_cv_c_bigendian=no
13135	>	eval "$as_CACHEVAR=no"
13136		fi
13137		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13138	+	CFLAGS=$ax_check_save_flags
13139	+	fi
13140	+	eval ac_res=\$$as_CACHEVAR
13141	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13142	+	$as_echo "$ac_res" >&6; }
13143	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13144	+
13145	+	if ${CFLAGS+:} false; then :
13146	+
13147	+	case " $CFLAGS " in #(
13148	+	*" $flag "*) :
13149	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13150	+	(: CFLAGS already contains $flag) 2>&5
13151	+	ac_status=$?
13152	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13153	+	test $ac_status = 0; } ;; #(
13154	+	*) :
13155	+
13156	+	as_fn_append CFLAGS " $flag"
13157	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13158	+	(: CFLAGS="$CFLAGS") 2>&5
13159	+	ac_status=$?
13160	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13161	+	test $ac_status = 0; }
13162	+	;;
13163	+	esac
13164	+
13165	+	else
13166	+
13167	+	CFLAGS=$flag
13168	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13169	+	(: CFLAGS="$CFLAGS") 2>&5
13170	+	ac_status=$?
13171	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13172	+	test $ac_status = 0; }
13173	+
13174	+	fi
13175	+
13176	+	else
13177	+	:
13178	+	fi
13179	+
13180	+	done
13181	+
13182	+
13183	+
13184	+
13185	+
13186	+	for flag in -Wduplicated-cond; do
13187	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13188	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13189	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13190	+	if eval \${$as_CACHEVAR+:} false; then :
13191	+	$as_echo_n "(cached) " >&6
13192	+	else
13193	+
13194	+	ax_check_save_flags=$CFLAGS
13195	+	CFLAGS="$CFLAGS  $flag"
13196	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13197	+	/* end confdefs.h.  */
13198	+
13199	+	int
13200	+	main ()
13201	+	{
13202	+
13203	+	;
13204	+	return 0;
13205	+	}
13206	+	_ACEOF
13207	+	if ac_fn_c_try_compile "$LINENO"; then :
13208	+	eval "$as_CACHEVAR=yes"
13209	+	else
13210	+	eval "$as_CACHEVAR=no"
13211		fi
13212		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13213	<	fi
13214	<	if test $ac_cv_c_bigendian = unknown; then
13215	<	# See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13216	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13213	>	CFLAGS=$ax_check_save_flags
13214	>	fi
13215	>	eval ac_res=\$$as_CACHEVAR
13216	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13217	>	$as_echo "$ac_res" >&6; }
13218	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13219	>
13220	>	if ${CFLAGS+:} false; then :
13221	>
13222	>	case " $CFLAGS " in #(
13223	>	*" $flag "*) :
13224	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13225	>	(: CFLAGS already contains $flag) 2>&5
13226	>	ac_status=$?
13227	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13228	>	test $ac_status = 0; } ;; #(
13229	>	*) :
13230	>
13231	>	as_fn_append CFLAGS " $flag"
13232	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13233	>	(: CFLAGS="$CFLAGS") 2>&5
13234	>	ac_status=$?
13235	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13236	>	test $ac_status = 0; }
13237	>	;;
13238	>	esac
13239	>
13240	>	else
13241	>
13242	>	CFLAGS=$flag
13243	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13244	>	(: CFLAGS="$CFLAGS") 2>&5
13245	>	ac_status=$?
13246	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13247	>	test $ac_status = 0; }
13248	>
13249	>	fi
13250	>
13251	>	else
13252	>	:
13253	>	fi
13254	>
13255	>	done
13256	>
13257	>
13258	>
13259	>
13260	>
13261	>	for flag in -Wempty-body; do
13262	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13263	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13264	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13265	>	if eval \${$as_CACHEVAR+:} false; then :
13266	>	$as_echo_n "(cached) " >&6
13267	>	else
13268	>
13269	>	ax_check_save_flags=$CFLAGS
13270	>	CFLAGS="$CFLAGS  $flag"
13271	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13272		/* end confdefs.h.  */
13115	–	#include <limits.h>
13273
13274		int
13275		main ()
13276		{
13120	–	#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13121	–	bogus endian macros
13122	–	#endif
13277
13278		;
13279		return 0;
13280		}
13281		_ACEOF
13282		if ac_fn_c_try_compile "$LINENO"; then :
13283	<	# It does; now see whether it defined to _BIG_ENDIAN or not.
13284	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13283	>	eval "$as_CACHEVAR=yes"
13284	>	else
13285	>	eval "$as_CACHEVAR=no"
13286	>	fi
13287	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13288	>	CFLAGS=$ax_check_save_flags
13289	>	fi
13290	>	eval ac_res=\$$as_CACHEVAR
13291	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13292	>	$as_echo "$ac_res" >&6; }
13293	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13294	>
13295	>	if ${CFLAGS+:} false; then :
13296	>
13297	>	case " $CFLAGS " in #(
13298	>	*" $flag "*) :
13299	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13300	>	(: CFLAGS already contains $flag) 2>&5
13301	>	ac_status=$?
13302	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13303	>	test $ac_status = 0; } ;; #(
13304	>	*) :
13305	>
13306	>	as_fn_append CFLAGS " $flag"
13307	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13308	>	(: CFLAGS="$CFLAGS") 2>&5
13309	>	ac_status=$?
13310	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13311	>	test $ac_status = 0; }
13312	>	;;
13313	>	esac
13314	>
13315	>	else
13316	>
13317	>	CFLAGS=$flag
13318	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13319	>	(: CFLAGS="$CFLAGS") 2>&5
13320	>	ac_status=$?
13321	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13322	>	test $ac_status = 0; }
13323	>
13324	>	fi
13325	>
13326	>	else
13327	>	:
13328	>	fi
13329	>
13330	>	done
13331	>
13332	>
13333	>
13334	>
13335	>
13336	>	for flag in -Wignored-qualifiers; do
13337	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13338	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13339	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13340	>	if eval \${$as_CACHEVAR+:} false; then :
13341	>	$as_echo_n "(cached) " >&6
13342	>	else
13343	>
13344	>	ax_check_save_flags=$CFLAGS
13345	>	CFLAGS="$CFLAGS  $flag"
13346	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13347		/* end confdefs.h.  */
13132	–	#include <limits.h>
13348
13349		int
13350		main ()
13351		{
13137	–	#ifndef _BIG_ENDIAN
13138	–	not big endian
13139	–	#endif
13352
13353		;
13354		return 0;
13355		}
13356		_ACEOF
13357		if ac_fn_c_try_compile "$LINENO"; then :
13358	<	ac_cv_c_bigendian=yes
13358	>	eval "$as_CACHEVAR=yes"
13359		else
13360	<	ac_cv_c_bigendian=no
13360	>	eval "$as_CACHEVAR=no"
13361		fi
13362		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13363	+	CFLAGS=$ax_check_save_flags
13364	+	fi
13365	+	eval ac_res=\$$as_CACHEVAR
13366	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13367	+	$as_echo "$ac_res" >&6; }
13368	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13369	+
13370	+	if ${CFLAGS+:} false; then :
13371	+
13372	+	case " $CFLAGS " in #(
13373	+	*" $flag "*) :
13374	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13375	+	(: CFLAGS already contains $flag) 2>&5
13376	+	ac_status=$?
13377	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13378	+	test $ac_status = 0; } ;; #(
13379	+	*) :
13380	+
13381	+	as_fn_append CFLAGS " $flag"
13382	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13383	+	(: CFLAGS="$CFLAGS") 2>&5
13384	+	ac_status=$?
13385	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13386	+	test $ac_status = 0; }
13387	+	;;
13388	+	esac
13389	+
13390	+	else
13391	+
13392	+	CFLAGS=$flag
13393	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13394	+	(: CFLAGS="$CFLAGS") 2>&5
13395	+	ac_status=$?
13396	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13397	+	test $ac_status = 0; }
13398	+
13399	+	fi
13400	+
13401	+	else
13402	+	:
13403	+	fi
13404	+
13405	+	done
13406	+
13407	+
13408	+
13409	+
13410	+
13411	+	for flag in -Wlogical-op; do
13412	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13413	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13414	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13415	+	if eval \${$as_CACHEVAR+:} false; then :
13416	+	$as_echo_n "(cached) " >&6
13417	+	else
13418	+
13419	+	ax_check_save_flags=$CFLAGS
13420	+	CFLAGS="$CFLAGS  $flag"
13421	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13422	+	/* end confdefs.h.  */
13423	+
13424	+	int
13425	+	main ()
13426	+	{
13427	+
13428	+	;
13429	+	return 0;
13430	+	}
13431	+	_ACEOF
13432	+	if ac_fn_c_try_compile "$LINENO"; then :
13433	+	eval "$as_CACHEVAR=yes"
13434	+	else
13435	+	eval "$as_CACHEVAR=no"
13436		fi
13437		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13438	<	fi
13439	<	if test $ac_cv_c_bigendian = unknown; then
13440	<	# Compile a test program.
13441	<	if test "$cross_compiling" = yes; then :
13442	<	# Try to guess by grepping values from an object file.
13443	<	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13438	>	CFLAGS=$ax_check_save_flags
13439	>	fi
13440	>	eval ac_res=\$$as_CACHEVAR
13441	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13442	>	$as_echo "$ac_res" >&6; }
13443	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13444	>
13445	>	if ${CFLAGS+:} false; then :
13446	>
13447	>	case " $CFLAGS " in #(
13448	>	*" $flag "*) :
13449	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13450	>	(: CFLAGS already contains $flag) 2>&5
13451	>	ac_status=$?
13452	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13453	>	test $ac_status = 0; } ;; #(
13454	>	*) :
13455	>
13456	>	as_fn_append CFLAGS " $flag"
13457	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13458	>	(: CFLAGS="$CFLAGS") 2>&5
13459	>	ac_status=$?
13460	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13461	>	test $ac_status = 0; }
13462	>	;;
13463	>	esac
13464	>
13465	>	else
13466	>
13467	>	CFLAGS=$flag
13468	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13469	>	(: CFLAGS="$CFLAGS") 2>&5
13470	>	ac_status=$?
13471	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13472	>	test $ac_status = 0; }
13473	>
13474	>	fi
13475	>
13476	>	else
13477	>	:
13478	>	fi
13479	>
13480	>	done
13481	>
13482	>
13483	>
13484	>
13485	>
13486	>	for flag in -Wmissing-declarations; do
13487	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13488	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13489	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13490	>	if eval \${$as_CACHEVAR+:} false; then :
13491	>	$as_echo_n "(cached) " >&6
13492	>	else
13493	>
13494	>	ax_check_save_flags=$CFLAGS
13495	>	CFLAGS="$CFLAGS  $flag"
13496	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13497		/* 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;
13498
13499		int
13500		main ()
13501		{
13502	<	return use_ascii (foo) == use_ebcdic (foo);
13502	>
13503		;
13504		return 0;
13505		}
13506		_ACEOF
13507		if ac_fn_c_try_compile "$LINENO"; then :
13508	<	if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
13509	<	ac_cv_c_bigendian=yes
13510	<	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
13508	>	eval "$as_CACHEVAR=yes"
13509	>	else
13510	>	eval "$as_CACHEVAR=no"
13511		fi
13512		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13513	+	CFLAGS=$ax_check_save_flags
13514	+	fi
13515	+	eval ac_res=\$$as_CACHEVAR
13516	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13517	+	$as_echo "$ac_res" >&6; }
13518	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13519	+
13520	+	if ${CFLAGS+:} false; then :
13521	+
13522	+	case " $CFLAGS " in #(
13523	+	*" $flag "*) :
13524	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13525	+	(: CFLAGS already contains $flag) 2>&5
13526	+	ac_status=$?
13527	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13528	+	test $ac_status = 0; } ;; #(
13529	+	*) :
13530	+
13531	+	as_fn_append CFLAGS " $flag"
13532	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13533	+	(: CFLAGS="$CFLAGS") 2>&5
13534	+	ac_status=$?
13535	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13536	+	test $ac_status = 0; }
13537	+	;;
13538	+	esac
13539	+
13540		else
13541	+
13542	+	CFLAGS=$flag
13543	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13544	+	(: CFLAGS="$CFLAGS") 2>&5
13545	+	ac_status=$?
13546	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13547	+	test $ac_status = 0; }
13548	+
13549	+	fi
13550	+
13551	+	else
13552	+	:
13553	+	fi
13554	+
13555	+	done
13556	+
13557	+
13558	+
13559	+
13560	+
13561	+	for flag in -Wmissing-field-initializers; do
13562	+	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13563	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13564	+	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13565	+	if eval \${$as_CACHEVAR+:} false; then :
13566	+	$as_echo_n "(cached) " >&6
13567	+	else
13568	+
13569	+	ax_check_save_flags=$CFLAGS
13570	+	CFLAGS="$CFLAGS  $flag"
13571		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13572		/* end confdefs.h.  */
13573	<	$ac_includes_default
13573	>
13574		int
13575		main ()
13576		{
13577
13578	<	/* Are we little or big endian?  From Harbison&Steele.  */
13579	<	union
13580	<	{
13581	<	long int l;
13582	<	char c[sizeof (long int)];
13583	<	} u;
13584	<	u.l = 1;
13585	<	return u.c[sizeof (long int) - 1] == 1;
13578	>	;
13579	>	return 0;
13580	>	}
13581	>	_ACEOF
13582	>	if ac_fn_c_try_compile "$LINENO"; then :
13583	>	eval "$as_CACHEVAR=yes"
13584	>	else
13585	>	eval "$as_CACHEVAR=no"
13586	>	fi
13587	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13588	>	CFLAGS=$ax_check_save_flags
13589	>	fi
13590	>	eval ac_res=\$$as_CACHEVAR
13591	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13592	>	$as_echo "$ac_res" >&6; }
13593	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13594	>
13595	>	if ${CFLAGS+:} false; then :
13596	>
13597	>	case " $CFLAGS " in #(
13598	>	*" $flag "*) :
13599	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13600	>	(: CFLAGS already contains $flag) 2>&5
13601	>	ac_status=$?
13602	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13603	>	test $ac_status = 0; } ;; #(
13604	>	*) :
13605	>
13606	>	as_fn_append CFLAGS " $flag"
13607	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13608	>	(: CFLAGS="$CFLAGS") 2>&5
13609	>	ac_status=$?
13610	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13611	>	test $ac_status = 0; }
13612	>	;;
13613	>	esac
13614	>
13615	>	else
13616	>
13617	>	CFLAGS=$flag
13618	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13619	>	(: CFLAGS="$CFLAGS") 2>&5
13620	>	ac_status=$?
13621	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13622	>	test $ac_status = 0; }
13623	>
13624	>	fi
13625	>
13626	>	else
13627	>	:
13628	>	fi
13629	>
13630	>	done
13631	>
13632	>
13633	>
13634	>
13635	>
13636	>	for flag in -Wmissing-include-dirs; do
13637	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13638	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13639	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13640	>	if eval \${$as_CACHEVAR+:} false; then :
13641	>	$as_echo_n "(cached) " >&6
13642	>	else
13643	>
13644	>	ax_check_save_flags=$CFLAGS
13645	>	CFLAGS="$CFLAGS  $flag"
13646	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13647	>	/* end confdefs.h.  */
13648	>
13649	>	int
13650	>	main ()
13651	>	{
13652
13653		;
13654		return 0;
13655		}
13656		_ACEOF
13657	<	if ac_fn_c_try_run "$LINENO"; then :
13658	<	ac_cv_c_bigendian=no
13657	>	if ac_fn_c_try_compile "$LINENO"; then :
13658	>	eval "$as_CACHEVAR=yes"
13659		else
13660	<	ac_cv_c_bigendian=yes
13660	>	eval "$as_CACHEVAR=no"
13661		fi
13662	<	rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
13663	<	conftest.$ac_objext conftest.beam conftest.$ac_ext
13662	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13663	>	CFLAGS=$ax_check_save_flags
13664		fi
13665	+	eval ac_res=\$$as_CACHEVAR
13666	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13667	+	$as_echo "$ac_res" >&6; }
13668	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13669	+
13670	+	if ${CFLAGS+:} false; then :
13671	+
13672	+	case " $CFLAGS " in #(
13673	+	*" $flag "*) :
13674	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13675	+	(: CFLAGS already contains $flag) 2>&5
13676	+	ac_status=$?
13677	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13678	+	test $ac_status = 0; } ;; #(
13679	+	*) :
13680	+
13681	+	as_fn_append CFLAGS " $flag"
13682	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13683	+	(: CFLAGS="$CFLAGS") 2>&5
13684	+	ac_status=$?
13685	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13686	+	test $ac_status = 0; }
13687	+	;;
13688	+	esac
13689	+
13690	+	else
13691	+
13692	+	CFLAGS=$flag
13693	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13694	+	(: CFLAGS="$CFLAGS") 2>&5
13695	+	ac_status=$?
13696	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13697	+	test $ac_status = 0; }
13698
13228	–	fi
13699		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)
13700
13701	<	$as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13701	>	else
13702	>	:
13703	>	fi
13704	>
13705	>	done
13706	>
13707
13242	–	;; #(
13243	–	*)
13244	–	as_fn_error $? "unknown endianness
13245	–	presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13246	–	esac
13708
13709
13710	<	# The cast to long int works around a bug in the HP C Compiler
13711	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13712	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13713	<	# This bug is HP SR number 8606223364.
13714	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
13715	<	$as_echo_n "checking size of int... " >&6; }
13255	<	if ${ac_cv_sizeof_int+:} false; then :
13710	>
13711	>	for flag in -Wmissing-parameter-type; do
13712	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13713	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13714	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13715	>	if eval \${$as_CACHEVAR+:} false; then :
13716		$as_echo_n "(cached) " >&6
13717		else
13258	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
13718
13719	+	ax_check_save_flags=$CFLAGS
13720	+	CFLAGS="$CFLAGS  $flag"
13721	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13722	+	/* end confdefs.h.  */
13723	+
13724	+	int
13725	+	main ()
13726	+	{
13727	+
13728	+	;
13729	+	return 0;
13730	+	}
13731	+	_ACEOF
13732	+	if ac_fn_c_try_compile "$LINENO"; then :
13733	+	eval "$as_CACHEVAR=yes"
13734		else
13735	<	if test "$ac_cv_type_int" = yes; then
13736	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13737	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13738	<	as_fn_error 77 "cannot compute sizeof (int)
13739	<	See \`config.log' for more details" "$LINENO" 5; }
13740	<	else
13741	<	ac_cv_sizeof_int=0
13742	<	fi
13735	>	eval "$as_CACHEVAR=no"
13736	>	fi
13737	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13738	>	CFLAGS=$ax_check_save_flags
13739	>	fi
13740	>	eval ac_res=\$$as_CACHEVAR
13741	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13742	>	$as_echo "$ac_res" >&6; }
13743	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13744	>
13745	>	if ${CFLAGS+:} false; then :
13746	>
13747	>	case " $CFLAGS " in #(
13748	>	*" $flag "*) :
13749	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13750	>	(: CFLAGS already contains $flag) 2>&5
13751	>	ac_status=$?
13752	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13753	>	test $ac_status = 0; } ;; #(
13754	>	*) :
13755	>
13756	>	as_fn_append CFLAGS " $flag"
13757	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13758	>	(: CFLAGS="$CFLAGS") 2>&5
13759	>	ac_status=$?
13760	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13761	>	test $ac_status = 0; }
13762	>	;;
13763	>	esac
13764	>
13765	>	else
13766	>
13767	>	CFLAGS=$flag
13768	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13769	>	(: CFLAGS="$CFLAGS") 2>&5
13770	>	ac_status=$?
13771	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13772	>	test $ac_status = 0; }
13773	>
13774		fi
13775
13776	+	else
13777	+	:
13778		fi
13779	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
13780	<	$as_echo "$ac_cv_sizeof_int" >&6; }
13779	>
13780	>	done
13781
13782
13783
13784	<	cat >>confdefs.h <<_ACEOF
13785	<	#define SIZEOF_INT $ac_cv_sizeof_int
13784	>
13785	>
13786	>	for flag in -Wmissing-prototypes; do
13787	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13788	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13789	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13790	>	if eval \${$as_CACHEVAR+:} false; then :
13791	>	$as_echo_n "(cached) " >&6
13792	>	else
13793	>
13794	>	ax_check_save_flags=$CFLAGS
13795	>	CFLAGS="$CFLAGS  $flag"
13796	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13797	>	/* end confdefs.h.  */
13798	>
13799	>	int
13800	>	main ()
13801	>	{
13802	>
13803	>	;
13804	>	return 0;
13805	>	}
13806		_ACEOF
13807	+	if ac_fn_c_try_compile "$LINENO"; then :
13808	+	eval "$as_CACHEVAR=yes"
13809	+	else
13810	+	eval "$as_CACHEVAR=no"
13811	+	fi
13812	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13813	+	CFLAGS=$ax_check_save_flags
13814	+	fi
13815	+	eval ac_res=\$$as_CACHEVAR
13816	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13817	+	$as_echo "$ac_res" >&6; }
13818	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13819	+
13820	+	if ${CFLAGS+:} false; then :
13821	+
13822	+	case " $CFLAGS " in #(
13823	+	*" $flag "*) :
13824	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13825	+	(: CFLAGS already contains $flag) 2>&5
13826	+	ac_status=$?
13827	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13828	+	test $ac_status = 0; } ;; #(
13829	+	*) :
13830	+
13831	+	as_fn_append CFLAGS " $flag"
13832	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13833	+	(: CFLAGS="$CFLAGS") 2>&5
13834	+	ac_status=$?
13835	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13836	+	test $ac_status = 0; }
13837	+	;;
13838	+	esac
13839	+
13840	+	else
13841	+
13842	+	CFLAGS=$flag
13843	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13844	+	(: CFLAGS="$CFLAGS") 2>&5
13845	+	ac_status=$?
13846	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13847	+	test $ac_status = 0; }
13848
13849	+	fi
13850
13851	<	# The cast to long int works around a bug in the HP C Compiler
13852	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13853	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13854	<	# This bug is HP SR number 8606223364.
13855	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13856	<	$as_echo_n "checking size of short... " >&6; }
13857	<	if ${ac_cv_sizeof_short+:} false; then :
13851	>	else
13852	>	:
13853	>	fi
13854	>
13855	>	done
13856	>
13857	>
13858	>
13859	>
13860	>
13861	>	for flag in -Wnested-externs; do
13862	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13863	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13864	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13865	>	if eval \${$as_CACHEVAR+:} false; then :
13866		$as_echo_n "(cached) " >&6
13867		else
13291	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
13868
13869	+	ax_check_save_flags=$CFLAGS
13870	+	CFLAGS="$CFLAGS  $flag"
13871	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13872	+	/* end confdefs.h.  */
13873	+
13874	+	int
13875	+	main ()
13876	+	{
13877	+
13878	+	;
13879	+	return 0;
13880	+	}
13881	+	_ACEOF
13882	+	if ac_fn_c_try_compile "$LINENO"; then :
13883	+	eval "$as_CACHEVAR=yes"
13884		else
13885	<	if test "$ac_cv_type_short" = yes; then
13886	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13887	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13888	<	as_fn_error 77 "cannot compute sizeof (short)
13889	<	See \`config.log' for more details" "$LINENO" 5; }
13890	<	else
13891	<	ac_cv_sizeof_short=0
13892	<	fi
13885	>	eval "$as_CACHEVAR=no"
13886	>	fi
13887	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13888	>	CFLAGS=$ax_check_save_flags
13889	>	fi
13890	>	eval ac_res=\$$as_CACHEVAR
13891	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13892	>	$as_echo "$ac_res" >&6; }
13893	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13894	>
13895	>	if ${CFLAGS+:} false; then :
13896	>
13897	>	case " $CFLAGS " in #(
13898	>	*" $flag "*) :
13899	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13900	>	(: CFLAGS already contains $flag) 2>&5
13901	>	ac_status=$?
13902	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13903	>	test $ac_status = 0; } ;; #(
13904	>	*) :
13905	>
13906	>	as_fn_append CFLAGS " $flag"
13907	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13908	>	(: CFLAGS="$CFLAGS") 2>&5
13909	>	ac_status=$?
13910	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13911	>	test $ac_status = 0; }
13912	>	;;
13913	>	esac
13914	>
13915	>	else
13916	>
13917	>	CFLAGS=$flag
13918	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13919	>	(: CFLAGS="$CFLAGS") 2>&5
13920	>	ac_status=$?
13921	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13922	>	test $ac_status = 0; }
13923	>
13924		fi
13925
13926	+	else
13927	+	:
13928		fi
13929	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13930	<	$as_echo "$ac_cv_sizeof_short" >&6; }
13929	>
13930	>	done
13931
13932
13933
13934	<	cat >>confdefs.h <<_ACEOF
13935	<	#define SIZEOF_SHORT $ac_cv_sizeof_short
13934	>
13935	>
13936	>	for flag in -Wold-style-declaration; do
13937	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13938	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13939	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13940	>	if eval \${$as_CACHEVAR+:} false; then :
13941	>	$as_echo_n "(cached) " >&6
13942	>	else
13943	>
13944	>	ax_check_save_flags=$CFLAGS
13945	>	CFLAGS="$CFLAGS  $flag"
13946	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13947	>	/* end confdefs.h.  */
13948	>
13949	>	int
13950	>	main ()
13951	>	{
13952	>
13953	>	;
13954	>	return 0;
13955	>	}
13956		_ACEOF
13957	+	if ac_fn_c_try_compile "$LINENO"; then :
13958	+	eval "$as_CACHEVAR=yes"
13959	+	else
13960	+	eval "$as_CACHEVAR=no"
13961	+	fi
13962	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13963	+	CFLAGS=$ax_check_save_flags
13964	+	fi
13965	+	eval ac_res=\$$as_CACHEVAR
13966	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13967	+	$as_echo "$ac_res" >&6; }
13968	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13969	+
13970	+	if ${CFLAGS+:} false; then :
13971
13972	+	case " $CFLAGS " in #(
13973	+	*" $flag "*) :
13974	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13975	+	(: CFLAGS already contains $flag) 2>&5
13976	+	ac_status=$?
13977	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13978	+	test $ac_status = 0; } ;; #(
13979	+	*) :
13980
13981	<	# The cast to long int works around a bug in the HP C Compiler
13982	<	# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13983	<	# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13984	<	# This bug is HP SR number 8606223364.
13985	<	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
13986	<	$as_echo_n "checking size of long... " >&6; }
13987	<	if ${ac_cv_sizeof_long+:} false; then :
13981	>	as_fn_append CFLAGS " $flag"
13982	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13983	>	(: CFLAGS="$CFLAGS") 2>&5
13984	>	ac_status=$?
13985	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13986	>	test $ac_status = 0; }
13987	>	;;
13988	>	esac
13989	>
13990	>	else
13991	>
13992	>	CFLAGS=$flag
13993	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13994	>	(: CFLAGS="$CFLAGS") 2>&5
13995	>	ac_status=$?
13996	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13997	>	test $ac_status = 0; }
13998	>
13999	>	fi
14000	>
14001	>	else
14002	>	:
14003	>	fi
14004	>
14005	>	done
14006	>
14007	>
14008	>
14009	>
14010	>
14011	>	for flag in -Woverride-init; do
14012	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14013	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14014	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14015	>	if eval \${$as_CACHEVAR+:} false; then :
14016		$as_echo_n "(cached) " >&6
14017		else
13324	–	if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
14018
14019	+	ax_check_save_flags=$CFLAGS
14020	+	CFLAGS="$CFLAGS  $flag"
14021	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14022	+	/* end confdefs.h.  */
14023	+
14024	+	int
14025	+	main ()
14026	+	{
14027	+
14028	+	;
14029	+	return 0;
14030	+	}
14031	+	_ACEOF
14032	+	if ac_fn_c_try_compile "$LINENO"; then :
14033	+	eval "$as_CACHEVAR=yes"
14034		else
14035	<	if test "$ac_cv_type_long" = yes; then
14036	<	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14037	<	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14038	<	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
14035	>	eval "$as_CACHEVAR=no"
14036	>	fi
14037	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14038	>	CFLAGS=$ax_check_save_flags
14039		fi
14040	+	eval ac_res=\$$as_CACHEVAR
14041	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14042	+	$as_echo "$ac_res" >&6; }
14043	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14044	+
14045	+	if ${CFLAGS+:} false; then :
14046	+
14047	+	case " $CFLAGS " in #(
14048	+	*" $flag "*) :
14049	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14050	+	(: CFLAGS already contains $flag) 2>&5
14051	+	ac_status=$?
14052	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14053	+	test $ac_status = 0; } ;; #(
14054	+	*) :
14055
14056	+	as_fn_append CFLAGS " $flag"
14057	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14058	+	(: CFLAGS="$CFLAGS") 2>&5
14059	+	ac_status=$?
14060	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14061	+	test $ac_status = 0; }
14062	+	;;
14063	+	esac
14064	+
14065	+	else
14066	+
14067	+	CFLAGS=$flag
14068	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14069	+	(: CFLAGS="$CFLAGS") 2>&5
14070	+	ac_status=$?
14071	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14072	+	test $ac_status = 0; }
14073	+
14074	+	fi
14075	+
14076	+	else
14077	+	:
14078		fi
13338	–	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13339	–	$as_echo "$ac_cv_sizeof_long" >&6; }
14079
14080	+	done
14081
14082
14083	<	cat >>confdefs.h <<_ACEOF
14084	<	#define SIZEOF_LONG $ac_cv_sizeof_long
14083	>
14084	>
14085	>
14086	>	for flag in -Wpointer-arith; do
14087	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14088	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14089	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14090	>	if eval \${$as_CACHEVAR+:} false; then :
14091	>	$as_echo_n "(cached) " >&6
14092	>	else
14093	>
14094	>	ax_check_save_flags=$CFLAGS
14095	>	CFLAGS="$CFLAGS  $flag"
14096	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14097	>	/* end confdefs.h.  */
14098	>
14099	>	int
14100	>	main ()
14101	>	{
14102	>
14103	>	;
14104	>	return 0;
14105	>	}
14106		_ACEOF
14107	+	if ac_fn_c_try_compile "$LINENO"; then :
14108	+	eval "$as_CACHEVAR=yes"
14109	+	else
14110	+	eval "$as_CACHEVAR=no"
14111	+	fi
14112	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14113	+	CFLAGS=$ax_check_save_flags
14114	+	fi
14115	+	eval ac_res=\$$as_CACHEVAR
14116	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14117	+	$as_echo "$ac_res" >&6; }
14118	+	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14119	+
14120	+	if ${CFLAGS+:} false; then :
14121	+
14122	+	case " $CFLAGS " in #(
14123	+	*" $flag "*) :
14124	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14125	+	(: CFLAGS already contains $flag) 2>&5
14126	+	ac_status=$?
14127	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14128	+	test $ac_status = 0; } ;; #(
14129	+	*) :
14130	+
14131	+	as_fn_append CFLAGS " $flag"
14132	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14133	+	(: CFLAGS="$CFLAGS") 2>&5
14134	+	ac_status=$?
14135	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14136	+	test $ac_status = 0; }
14137	+	;;
14138	+	esac
14139
14140	+	else
14141
14142	+	CFLAGS=$flag
14143	+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14144	+	(: CFLAGS="$CFLAGS") 2>&5
14145	+	ac_status=$?
14146	+	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14147	+	test $ac_status = 0; }
14148
14149	+	fi
14150
14151	+	else
14152	+	:
14153	+	fi
14154
14155	+	done
14156
14157
14158
13354	–	subdirs="$subdirs src/libopm"
14159
14160
14161	<	ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile"
14161	>	for flag in -Wredundant-decls; do
14162	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14163	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14164	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14165	>	if eval \${$as_CACHEVAR+:} false; then :
14166	>	$as_echo_n "(cached) " >&6
14167	>	else
14168	>
14169	>	ax_check_save_flags=$CFLAGS
14170	>	CFLAGS="$CFLAGS  $flag"
14171	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14172	>	/* end confdefs.h.  */
14173	>
14174	>	int
14175	>	main ()
14176	>	{
14177	>
14178	>	;
14179	>	return 0;
14180	>	}
14181	>	_ACEOF
14182	>	if ac_fn_c_try_compile "$LINENO"; then :
14183	>	eval "$as_CACHEVAR=yes"
14184	>	else
14185	>	eval "$as_CACHEVAR=no"
14186	>	fi
14187	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14188	>	CFLAGS=$ax_check_save_flags
14189	>	fi
14190	>	eval ac_res=\$$as_CACHEVAR
14191	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14192	>	$as_echo "$ac_res" >&6; }
14193	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14194	>
14195	>	if ${CFLAGS+:} false; then :
14196	>
14197	>	case " $CFLAGS " in #(
14198	>	*" $flag "*) :
14199	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14200	>	(: CFLAGS already contains $flag) 2>&5
14201	>	ac_status=$?
14202	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14203	>	test $ac_status = 0; } ;; #(
14204	>	*) :
14205	>
14206	>	as_fn_append CFLAGS " $flag"
14207	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14208	>	(: CFLAGS="$CFLAGS") 2>&5
14209	>	ac_status=$?
14210	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14211	>	test $ac_status = 0; }
14212	>	;;
14213	>	esac
14214	>
14215	>	else
14216	>
14217	>	CFLAGS=$flag
14218	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14219	>	(: CFLAGS="$CFLAGS") 2>&5
14220	>	ac_status=$?
14221	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14222	>	test $ac_status = 0; }
14223	>
14224	>	fi
14225	>
14226	>	else
14227	>	:
14228	>	fi
14229	>
14230	>	done
14231	>
14232	>
14233	>
14234	>
14235	>
14236	>	for flag in -Wshadow; do
14237	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14238	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14239	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14240	>	if eval \${$as_CACHEVAR+:} false; then :
14241	>	$as_echo_n "(cached) " >&6
14242	>	else
14243	>
14244	>	ax_check_save_flags=$CFLAGS
14245	>	CFLAGS="$CFLAGS  $flag"
14246	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14247	>	/* end confdefs.h.  */
14248	>
14249	>	int
14250	>	main ()
14251	>	{
14252	>
14253	>	;
14254	>	return 0;
14255	>	}
14256	>	_ACEOF
14257	>	if ac_fn_c_try_compile "$LINENO"; then :
14258	>	eval "$as_CACHEVAR=yes"
14259	>	else
14260	>	eval "$as_CACHEVAR=no"
14261	>	fi
14262	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14263	>	CFLAGS=$ax_check_save_flags
14264	>	fi
14265	>	eval ac_res=\$$as_CACHEVAR
14266	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14267	>	$as_echo "$ac_res" >&6; }
14268	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14269	>
14270	>	if ${CFLAGS+:} false; then :
14271	>
14272	>	case " $CFLAGS " in #(
14273	>	*" $flag "*) :
14274	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14275	>	(: CFLAGS already contains $flag) 2>&5
14276	>	ac_status=$?
14277	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14278	>	test $ac_status = 0; } ;; #(
14279	>	*) :
14280	>
14281	>	as_fn_append CFLAGS " $flag"
14282	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14283	>	(: CFLAGS="$CFLAGS") 2>&5
14284	>	ac_status=$?
14285	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14286	>	test $ac_status = 0; }
14287	>	;;
14288	>	esac
14289	>
14290	>	else
14291	>
14292	>	CFLAGS=$flag
14293	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14294	>	(: CFLAGS="$CFLAGS") 2>&5
14295	>	ac_status=$?
14296	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14297	>	test $ac_status = 0; }
14298	>
14299	>	fi
14300	>
14301	>	else
14302	>	:
14303	>	fi
14304	>
14305	>	done
14306	>
14307	>
14308	>
14309	>
14310	>
14311	>	for flag in -Wshift-negative-value; do
14312	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14313	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14314	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14315	>	if eval \${$as_CACHEVAR+:} false; then :
14316	>	$as_echo_n "(cached) " >&6
14317	>	else
14318	>
14319	>	ax_check_save_flags=$CFLAGS
14320	>	CFLAGS="$CFLAGS  $flag"
14321	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14322	>	/* end confdefs.h.  */
14323	>
14324	>	int
14325	>	main ()
14326	>	{
14327	>
14328	>	;
14329	>	return 0;
14330	>	}
14331	>	_ACEOF
14332	>	if ac_fn_c_try_compile "$LINENO"; then :
14333	>	eval "$as_CACHEVAR=yes"
14334	>	else
14335	>	eval "$as_CACHEVAR=no"
14336	>	fi
14337	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14338	>	CFLAGS=$ax_check_save_flags
14339	>	fi
14340	>	eval ac_res=\$$as_CACHEVAR
14341	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14342	>	$as_echo "$ac_res" >&6; }
14343	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14344	>
14345	>	if ${CFLAGS+:} false; then :
14346	>
14347	>	case " $CFLAGS " in #(
14348	>	*" $flag "*) :
14349	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14350	>	(: CFLAGS already contains $flag) 2>&5
14351	>	ac_status=$?
14352	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14353	>	test $ac_status = 0; } ;; #(
14354	>	*) :
14355	>
14356	>	as_fn_append CFLAGS " $flag"
14357	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14358	>	(: CFLAGS="$CFLAGS") 2>&5
14359	>	ac_status=$?
14360	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14361	>	test $ac_status = 0; }
14362	>	;;
14363	>	esac
14364	>
14365	>	else
14366	>
14367	>	CFLAGS=$flag
14368	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14369	>	(: CFLAGS="$CFLAGS") 2>&5
14370	>	ac_status=$?
14371	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14372	>	test $ac_status = 0; }
14373	>
14374	>	fi
14375	>
14376	>	else
14377	>	:
14378	>	fi
14379	>
14380	>	done
14381	>
14382	>
14383	>
14384	>
14385	>
14386	>	for flag in -Wsign-compare; do
14387	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14388	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14389	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14390	>	if eval \${$as_CACHEVAR+:} false; then :
14391	>	$as_echo_n "(cached) " >&6
14392	>	else
14393	>
14394	>	ax_check_save_flags=$CFLAGS
14395	>	CFLAGS="$CFLAGS  $flag"
14396	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14397	>	/* end confdefs.h.  */
14398	>
14399	>	int
14400	>	main ()
14401	>	{
14402	>
14403	>	;
14404	>	return 0;
14405	>	}
14406	>	_ACEOF
14407	>	if ac_fn_c_try_compile "$LINENO"; then :
14408	>	eval "$as_CACHEVAR=yes"
14409	>	else
14410	>	eval "$as_CACHEVAR=no"
14411	>	fi
14412	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14413	>	CFLAGS=$ax_check_save_flags
14414	>	fi
14415	>	eval ac_res=\$$as_CACHEVAR
14416	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14417	>	$as_echo "$ac_res" >&6; }
14418	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14419	>
14420	>	if ${CFLAGS+:} false; then :
14421	>
14422	>	case " $CFLAGS " in #(
14423	>	*" $flag "*) :
14424	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14425	>	(: CFLAGS already contains $flag) 2>&5
14426	>	ac_status=$?
14427	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14428	>	test $ac_status = 0; } ;; #(
14429	>	*) :
14430	>
14431	>	as_fn_append CFLAGS " $flag"
14432	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14433	>	(: CFLAGS="$CFLAGS") 2>&5
14434	>	ac_status=$?
14435	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14436	>	test $ac_status = 0; }
14437	>	;;
14438	>	esac
14439	>
14440	>	else
14441	>
14442	>	CFLAGS=$flag
14443	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14444	>	(: CFLAGS="$CFLAGS") 2>&5
14445	>	ac_status=$?
14446	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14447	>	test $ac_status = 0; }
14448	>
14449	>	fi
14450	>
14451	>	else
14452	>	:
14453	>	fi
14454	>
14455	>	done
14456	>
14457	>
14458	>
14459	>
14460	>
14461	>	for flag in -Wtype-limits; do
14462	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14463	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14464	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14465	>	if eval \${$as_CACHEVAR+:} false; then :
14466	>	$as_echo_n "(cached) " >&6
14467	>	else
14468	>
14469	>	ax_check_save_flags=$CFLAGS
14470	>	CFLAGS="$CFLAGS  $flag"
14471	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14472	>	/* end confdefs.h.  */
14473	>
14474	>	int
14475	>	main ()
14476	>	{
14477	>
14478	>	;
14479	>	return 0;
14480	>	}
14481	>	_ACEOF
14482	>	if ac_fn_c_try_compile "$LINENO"; then :
14483	>	eval "$as_CACHEVAR=yes"
14484	>	else
14485	>	eval "$as_CACHEVAR=no"
14486	>	fi
14487	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14488	>	CFLAGS=$ax_check_save_flags
14489	>	fi
14490	>	eval ac_res=\$$as_CACHEVAR
14491	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14492	>	$as_echo "$ac_res" >&6; }
14493	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14494	>
14495	>	if ${CFLAGS+:} false; then :
14496	>
14497	>	case " $CFLAGS " in #(
14498	>	*" $flag "*) :
14499	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14500	>	(: CFLAGS already contains $flag) 2>&5
14501	>	ac_status=$?
14502	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14503	>	test $ac_status = 0; } ;; #(
14504	>	*) :
14505	>
14506	>	as_fn_append CFLAGS " $flag"
14507	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14508	>	(: CFLAGS="$CFLAGS") 2>&5
14509	>	ac_status=$?
14510	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14511	>	test $ac_status = 0; }
14512	>	;;
14513	>	esac
14514	>
14515	>	else
14516	>
14517	>	CFLAGS=$flag
14518	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14519	>	(: CFLAGS="$CFLAGS") 2>&5
14520	>	ac_status=$?
14521	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14522	>	test $ac_status = 0; }
14523	>
14524	>	fi
14525	>
14526	>	else
14527	>	:
14528	>	fi
14529	>
14530	>	done
14531	>
14532	>
14533	>
14534	>
14535	>
14536	>	for flag in -Wundef; do
14537	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14538	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14539	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14540	>	if eval \${$as_CACHEVAR+:} false; then :
14541	>	$as_echo_n "(cached) " >&6
14542	>	else
14543	>
14544	>	ax_check_save_flags=$CFLAGS
14545	>	CFLAGS="$CFLAGS  $flag"
14546	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14547	>	/* end confdefs.h.  */
14548	>
14549	>	int
14550	>	main ()
14551	>	{
14552	>
14553	>	;
14554	>	return 0;
14555	>	}
14556	>	_ACEOF
14557	>	if ac_fn_c_try_compile "$LINENO"; then :
14558	>	eval "$as_CACHEVAR=yes"
14559	>	else
14560	>	eval "$as_CACHEVAR=no"
14561	>	fi
14562	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14563	>	CFLAGS=$ax_check_save_flags
14564	>	fi
14565	>	eval ac_res=\$$as_CACHEVAR
14566	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14567	>	$as_echo "$ac_res" >&6; }
14568	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14569	>
14570	>	if ${CFLAGS+:} false; then :
14571	>
14572	>	case " $CFLAGS " in #(
14573	>	*" $flag "*) :
14574	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14575	>	(: CFLAGS already contains $flag) 2>&5
14576	>	ac_status=$?
14577	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14578	>	test $ac_status = 0; } ;; #(
14579	>	*) :
14580	>
14581	>	as_fn_append CFLAGS " $flag"
14582	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14583	>	(: CFLAGS="$CFLAGS") 2>&5
14584	>	ac_status=$?
14585	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14586	>	test $ac_status = 0; }
14587	>	;;
14588	>	esac
14589	>
14590	>	else
14591	>
14592	>	CFLAGS=$flag
14593	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14594	>	(: CFLAGS="$CFLAGS") 2>&5
14595	>	ac_status=$?
14596	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14597	>	test $ac_status = 0; }
14598	>
14599	>	fi
14600	>
14601	>	else
14602	>	:
14603	>	fi
14604	>
14605	>	done
14606	>
14607	>
14608	>
14609	>
14610	>
14611	>	for flag in -Wuninitialized; do
14612	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14613	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14614	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14615	>	if eval \${$as_CACHEVAR+:} false; then :
14616	>	$as_echo_n "(cached) " >&6
14617	>	else
14618	>
14619	>	ax_check_save_flags=$CFLAGS
14620	>	CFLAGS="$CFLAGS  $flag"
14621	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14622	>	/* end confdefs.h.  */
14623	>
14624	>	int
14625	>	main ()
14626	>	{
14627	>
14628	>	;
14629	>	return 0;
14630	>	}
14631	>	_ACEOF
14632	>	if ac_fn_c_try_compile "$LINENO"; then :
14633	>	eval "$as_CACHEVAR=yes"
14634	>	else
14635	>	eval "$as_CACHEVAR=no"
14636	>	fi
14637	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14638	>	CFLAGS=$ax_check_save_flags
14639	>	fi
14640	>	eval ac_res=\$$as_CACHEVAR
14641	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14642	>	$as_echo "$ac_res" >&6; }
14643	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14644	>
14645	>	if ${CFLAGS+:} false; then :
14646	>
14647	>	case " $CFLAGS " in #(
14648	>	*" $flag "*) :
14649	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14650	>	(: CFLAGS already contains $flag) 2>&5
14651	>	ac_status=$?
14652	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14653	>	test $ac_status = 0; } ;; #(
14654	>	*) :
14655	>
14656	>	as_fn_append CFLAGS " $flag"
14657	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14658	>	(: CFLAGS="$CFLAGS") 2>&5
14659	>	ac_status=$?
14660	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14661	>	test $ac_status = 0; }
14662	>	;;
14663	>	esac
14664	>
14665	>	else
14666	>
14667	>	CFLAGS=$flag
14668	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14669	>	(: CFLAGS="$CFLAGS") 2>&5
14670	>	ac_status=$?
14671	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14672	>	test $ac_status = 0; }
14673	>
14674	>	fi
14675	>
14676	>	else
14677	>	:
14678	>	fi
14679	>
14680	>	done
14681	>
14682	>
14683	>
14684	>
14685	>
14686	>	for flag in -Wwrite-strings; do
14687	>	as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14688	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14689	>	$as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14690	>	if eval \${$as_CACHEVAR+:} false; then :
14691	>	$as_echo_n "(cached) " >&6
14692	>	else
14693	>
14694	>	ax_check_save_flags=$CFLAGS
14695	>	CFLAGS="$CFLAGS  $flag"
14696	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14697	>	/* end confdefs.h.  */
14698	>
14699	>	int
14700	>	main ()
14701	>	{
14702	>
14703	>	;
14704	>	return 0;
14705	>	}
14706	>	_ACEOF
14707	>	if ac_fn_c_try_compile "$LINENO"; then :
14708	>	eval "$as_CACHEVAR=yes"
14709	>	else
14710	>	eval "$as_CACHEVAR=no"
14711	>	fi
14712	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14713	>	CFLAGS=$ax_check_save_flags
14714	>	fi
14715	>	eval ac_res=\$$as_CACHEVAR
14716	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14717	>	$as_echo "$ac_res" >&6; }
14718	>	if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14719	>
14720	>	if ${CFLAGS+:} false; then :
14721	>
14722	>	case " $CFLAGS " in #(
14723	>	*" $flag "*) :
14724	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14725	>	(: CFLAGS already contains $flag) 2>&5
14726	>	ac_status=$?
14727	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14728	>	test $ac_status = 0; } ;; #(
14729	>	*) :
14730	>
14731	>	as_fn_append CFLAGS " $flag"
14732	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14733	>	(: CFLAGS="$CFLAGS") 2>&5
14734	>	ac_status=$?
14735	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14736	>	test $ac_status = 0; }
14737	>	;;
14738	>	esac
14739	>
14740	>	else
14741	>
14742	>	CFLAGS=$flag
14743	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14744	>	(: CFLAGS="$CFLAGS") 2>&5
14745	>	ac_status=$?
14746	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14747	>	test $ac_status = 0; }
14748	>
14749	>	fi
14750	>
14751	>	else
14752	>	:
14753	>	fi
14754	>
14755	>	done
14756	>
14757	>
14758	>	fi
14759	>
14760	>
14761	>	for ac_func in strlcpy strlcat
14762	>	do :
14763	>	as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14764	>	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14765	>	if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14766	>	cat >>confdefs.h <<_ACEOF
14767	>	#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14768	>	_ACEOF
14769	>
14770	>	fi
14771	>	done
14772	>
14773	>
14774	>	ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14775
14776		cat >confcache <<\_ACEOF
14777		# This file is a shell script that caches the results of configure
#	Line 13450 | Line 14867 | DEFS=-DHAVE_CONFIG_H
14867
14868		ac_libobjs=
14869		ac_ltlibobjs=
14870	+	U=
14871		for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14872		# 1. Remove the extension, and $U if already installed.
14873		ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
#	Line 13492 | Line 14910 | if test -z "${am__fastdepCC_TRUE}" && te
14910		as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
14911		Usually this means the macro was only invoked conditionally." "$LINENO" 5
14912		fi
14913	<
14913	>	if test -z "${ENABLE_SSL_TRUE}" && test -z "${ENABLE_SSL_FALSE}"; then
14914	>	as_fn_error $? "conditional \"ENABLE_SSL\" was never defined.
14915	>	Usually this means the macro was only invoked conditionally." "$LINENO" 5
14916	>	fi
14917
14918		: "${CONFIG_STATUS=./config.status}"
14919		ac_write_fail=0
#	Line 13890 | Line 15311 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15311		# report actual input values of CONFIG_FILES etc. instead of their
15312		# values after options handling.
15313		ac_log="
15314	<	This file was extended by hopm $as_me 1.0.0beta1, which was
15314	>	This file was extended by hopm $as_me 1.1.5, which was
15315		generated by GNU Autoconf 2.69.  Invocation command line was
15316
15317		CONFIG_FILES    = $CONFIG_FILES
#	Line 13950 | Line 15371 | $config_headers
15371		Configuration commands:
15372		$config_commands
15373
15374	<	Report bugs to the package provider."
15374	>	Report bugs to <bugs@ircd-hybrid.org>."
15375
15376		_ACEOF
15377		cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15378		ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15379		ac_cs_version="\\
15380	<	hopm config.status 1.0.0beta1
15380	>	hopm config.status 1.1.5
15381		configured by $0, generated by GNU Autoconf 2.69,
15382		with options \\"\$ac_cs_config\\"
15383
#	Line 14212 | Line 15633 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15633		finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15634		hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15635		sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15636	<	sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15636	>	configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15637	>	configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15638		hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15639		enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15640		enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
#	Line 14330 | Line 15752 | postinstall_cmds \
15752		postuninstall_cmds \
15753		finish_cmds \
15754		sys_lib_search_path_spec \
15755	<	sys_lib_dlsearch_path_spec; do
15755	>	configure_time_dlsearch_path \
15756	>	configure_time_lt_sys_library_path; do
15757		case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15758		*[\\\\\\\`\\"\\\$]*)
15759		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 15795 | do
15795		"Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15796		"doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15797		"src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15798	+	"src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15799	+	"src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15800
15801		*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15802		esac
#	Line 15107 | Line 16532 | $as_echo X"$file" |
16532		# The names of the tagged configurations supported by this script.
16533		available_tags=''
16534
16535	+	# Configured defaults for sys_lib_dlsearch_path munging.
16536	+	: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16537	+
16538		# ### BEGIN LIBTOOL CONFIG
16539
16540		# Which release of libtool.m4 was used?
#	Line 15356 | Line 16784 | hardcode_into_libs=$hardcode_into_libs
16784		# Compile-time system search path for libraries.
16785		sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16786
16787	<	# Run-time system search path for libraries.
16788	<	sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16787	>	# Detected run-time system search path for libraries.
16788	>	sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16789	>
16790	>	# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16791	>	configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16792
16793		# Whether dlopen is supported.
16794		dlopen_support=$enable_dlopen
#	Line 15508 | Line 16939 | hardcode_action=$hardcode_action
16939
16940		_LT_EOF
16941
16942	+	cat <<'_LT_EOF' >> "$cfgfile"
16943	+
16944	+	# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
16945	+
16946	+	# func_munge_path_list VARIABLE PATH
16947	+	# -----------------------------------
16948	+	# VARIABLE is name of variable containing _space_ separated list of
16949	+	# directories to be munged by the contents of PATH, which is string
16950	+	# having a format:
16951	+	# "DIR[:DIR]:"
16952	+	#       string "DIR[ DIR]" will be prepended to VARIABLE
16953	+	# ":DIR[:DIR]"
16954	+	#       string "DIR[ DIR]" will be appended to VARIABLE
16955	+	# "DIRP[:DIRP]::[DIRA:]DIRA"
16956	+	#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
16957	+	#       "DIRA[ DIRA]" will be appended to VARIABLE
16958	+	# "DIR[:DIR]"
16959	+	#       VARIABLE will be replaced by "DIR[ DIR]"
16960	+	func_munge_path_list ()
16961	+	{
16962	+	case x$2 in
16963	+	x)
16964	+	;;
16965	+	*:)
16966	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
16967	+	;;
16968	+	x:*)
16969	+	eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
16970	+	;;
16971	+	*::*)
16972	+	eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
16973	+	eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
16974	+	;;
16975	+	*)
16976	+	eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
16977	+	;;
16978	+	esac
16979	+	}
16980	+
16981	+
16982	+	# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
16983	+	func_cc_basename ()
16984	+	{
16985	+	for cc_temp in $*""; do
16986	+	case $cc_temp in
16987	+	compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
16988	+	distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
16989	+	\-*) ;;
16990	+	*) break;;
16991	+	esac
16992	+	done
16993	+	func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
16994	+	}
16995	+
16996	+
16997	+	# ### END FUNCTIONS SHARED WITH CONFIGURE
16998	+
16999	+	_LT_EOF
17000	+
17001		case $host_os in
17002		aix3*)
17003		cat <<\_LT_EOF >> "$cfgfile"
#	Line 15571 | Line 17061 | if test "$no_create" != yes; then
17061		# would make configure fail if this is the last instruction.
17062		$ac_cs_success || as_fn_exit 1
17063		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
17064		if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17065		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17066		$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.
hopm/branches/1.1.x/configure (property svn:eol-style), Revision 8552 by michael, Sat Sep 22 20:56:36 2018 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.
hopm/branches/1.1.x/configure (property svn:keywords), Revision 8552 by michael, Sat Sep 22 20:56:36 2018 UTC

#	Line 0 | Line 1
1	+	Id

Diff Legend

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