Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

nexmon – Blame information for rev 1

Rev	Author	Line No.	Line
1	office	1	# Process this file with autoconf to produce a configure script.
		2	AC_PREREQ([2.62])
		3
		4	dnl ***********************************
		5	dnl *** include special GLib macros ***
		6	dnl ***********************************
		7
		8	m4_define(glib_configure_ac)
		9
		10	#
		11	# The following version number definitions apply to GLib, GModule, GObject,
		12	# GThread and GIO as a whole, so if changes occurred in any of them, they are
		13	# all treated with the same interface and binary age.
		14	#
		15	# Making releases:
		16	# glib_micro_version += 1;
		17	# glib_interface_age += 1;
		18	# glib_binary_age += 1;
		19	# if any functions have been added, set glib_interface_age to 0.
		20	# if backwards compatibility has been broken,
		21	# set glib_binary_age _and_ glib_interface_age to 0.
		22	#
		23	# remember to add a GLIB_VERSION_2_xx macro every time the minor version is
		24	# bumped, as well as the GLIB_DEPRECATED_IN and GLIB_AVAILABLE_IN macros
		25	# for that version - see gversion.h for further information.
		26	#
		27	# in easier to understand terms:
		28	#
		29	# <mclasen> on the stable branch, interface age == micro
		30	# <mclasen> on the unstable (ie master), interface age = 0
		31
		32	m4_define([glib_major_version], [2])
		33	m4_define([glib_minor_version], [48])
		34	m4_define([glib_micro_version], [1])
		35	m4_define([glib_interface_age], [1])
		36	m4_define([glib_binary_age],
		37	[m4_eval(100 * glib_minor_version + glib_micro_version)])
		38	m4_define([glib_version],
		39	[glib_major_version.glib_minor_version.glib_micro_version])
		40
		41	# libtool version related macros
		42	m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
		43	m4_define([glib_lt_current],
		44	[m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
		45	m4_define([glib_lt_revision], [glib_interface_age])
		46	m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
		47	m4_define([glib_lt_current_minus_age],
		48	[m4_eval(glib_lt_current - glib_lt_age)])
		49
		50	# if the minor version number is odd, then we want debugging. Otherwise
		51	# we only want minimal debugging support.
		52	m4_define([glib_debug_default],
		53	[m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
		54
		55
		56	AC_INIT(glib, [glib_version],
		57	[http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
		58
		59	AC_CONFIG_HEADERS([config.h])
		60	AC_CONFIG_SRCDIR([glib/glib.h])
		61	AC_CONFIG_MACRO_DIR([m4macros])
		62
		63	# Save this value here, since automake will set cflags later
		64	cflags_set=${CFLAGS:+set}
		65
		66	AM_INIT_AUTOMAKE([1.11 -Wno-portability no-define no-dist-gzip dist-xz tar-ustar])
		67	AM_MAINTAINER_MODE([enable])
		68
		69	# Support silent build rules. Disable
		70	# by either passing --disable-silent-rules to configure or passing V=1
		71	# to make
		72	AM_SILENT_RULES([yes])
		73
		74	GLIB_MAJOR_VERSION=glib_major_version
		75	GLIB_MINOR_VERSION=glib_minor_version
		76	GLIB_MICRO_VERSION=glib_micro_version
		77	GLIB_INTERFACE_AGE=glib_interface_age
		78	GLIB_BINARY_AGE=glib_binary_age
		79	GLIB_VERSION=glib_version
		80
		81	AC_SUBST(GLIB_MAJOR_VERSION)
		82	AC_SUBST(GLIB_MINOR_VERSION)
		83	AC_SUBST(GLIB_MICRO_VERSION)
		84	AC_SUBST(GLIB_VERSION)
		85	AC_SUBST(GLIB_INTERFACE_AGE)
		86	AC_SUBST(GLIB_BINARY_AGE)
		87
		88	AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
		89	[Define to the GLIB major version])
		90	AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
		91	[Define to the GLIB minor version])
		92	AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
		93	[Define to the GLIB micro version])
		94	AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
		95	[Define to the GLIB interface age])
		96	AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
		97	[Define to the GLIB binary age])
		98
		99	# libtool versioning
		100	LT_RELEASE=glib_lt_release
		101	LT_CURRENT=glib_lt_current
		102	LT_REVISION=glib_lt_revision
		103	LT_AGE=glib_lt_age
		104	LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
		105	AC_SUBST(LT_RELEASE)
		106	AC_SUBST(LT_CURRENT)
		107	AC_SUBST(LT_REVISION)
		108	AC_SUBST(LT_AGE)
		109	AC_SUBST(LT_CURRENT_MINUS_AGE)
		110
		111	dnl Checks for programs.
		112	AC_PROG_CC
		113	AC_PROG_CPP
		114	AC_USE_SYSTEM_EXTENSIONS
		115
		116	AM_CONDITIONAL(HAVE_GCC, [test "$GCC" = "yes"])
		117
		118	AC_CANONICAL_HOST
		119
		120	dnl
		121
		122	AC_MSG_CHECKING([for Win32])
		123	LIB_EXE_MACHINE_FLAG=X86
		124	case "$host" in
		125	*-*-mingw*)
		126	glib_native_win32=yes
		127	glib_pid_type='void *'
		128	glib_pollfd_format='%#x'
		129	glib_cv_stack_grows=no
		130	# Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
		131	# don't seem to be quite good enough, at least not in mingw-runtime-3.14.
		132	# (Sorry, I don't know exactly what is the problem, but it is related to
		133	# floating point formatting and decimal point vs. comma.)
		134	# The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
		135	# rigorous enough to notice, though.
		136	# So preset the autoconf cache variables.
		137	ac_cv_func_vsnprintf_c99=no
		138	ac_cv_func_snprintf_c99=no
		139	case "$host" in
		140	x86_64-*-*)
		141	LIB_EXE_MACHINE_FLAG=X64
		142	glib_pollfd_format='%#I64x'
		143	;;
		144	esac
		145
		146	AC_DEFINE([_WIN32_WINNT], [0x0501], [Target the Windows XP API])
		147	;;
		148	*)
		149	glib_native_win32=no
		150	glib_pid_type=int
		151	glib_pollfd_format='%d'
		152	;;
		153	esac
		154	case $host in
		155	*-*-linux*)
		156	glib_os_linux=yes
		157	;;
		158	esac
		159
		160	AC_MSG_RESULT([$glib_native_win32])
		161
		162	AC_MSG_CHECKING([for the Android])
		163	case $host in
		164	*android*)
		165	glib_native_android="yes"
		166	;;
		167	*)
		168	glib_native_android="no"
		169	;;
		170	esac
		171	AC_MSG_RESULT([$glib_native_android])
		172
		173	AC_SUBST(LIB_EXE_MACHINE_FLAG)
		174
		175	glib_have_carbon=no
		176	AC_MSG_CHECKING([for Mac OS X Carbon support])
		177	AC_TRY_CPP([
		178	#include <Carbon/Carbon.h>
		179	#include <CoreServices/CoreServices.h>
		180	], glib_have_carbon=yes)
		181
		182	AC_MSG_RESULT([$glib_have_carbon])
		183
		184	glib_have_cocoa=no
		185	AC_MSG_CHECKING([for Mac OS X Cocoa support])
		186	AC_TRY_CPP([
		187	#include <Cocoa/Cocoa.h>
		188	#ifdef GNUSTEP_BASE_VERSION
		189	#error "Detected GNUstep, not Cocoa"
		190	#endif
		191	], glib_have_cocoa=yes)
		192
		193	AC_MSG_RESULT([$glib_have_cocoa])
		194
		195	AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
		196	AM_CONDITIONAL(OS_WIN32_X64, [test "$LIB_EXE_MACHINE_FLAG" = "X64"])
		197	AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
		198	AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
		199	AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
		200	AM_CONDITIONAL(OS_COCOA, [test "$glib_have_cocoa" = "yes"])
		201
		202	AS_IF([test "$glib_native_win32" = "yes"], [
		203	AC_CHECK_TOOL(WINDRES, windres, no)
		204	if test "$WINDRES" = no; then
		205	AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
		206	fi
		207	AC_CHECK_TOOL(NM, nm, no)
		208	if test "$NM" = no; then
		209	AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
		210	fi
		211	AC_CHECK_TOOL(RANLIB, ranlib, :)
		212	AC_CHECK_TOOL(DLLTOOL, dlltool, :)
		213	AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
		214	])
		215	AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
		216
		217	AS_IF([test "x$glib_have_carbon" = "xyes"], [
		218	AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
		219	CARBON_LIBS="-Wl,-framework,Carbon"
		220	LDFLAGS="$LDFLAGS $CARBON_LIBS"
		221	], [CARBON_LIBS=""])
		222
		223	AC_SUBST([CARBON_LIBS])
		224
		225	AS_IF([test "x$glib_have_cocoa" = "xyes"], [
		226	AC_DEFINE(HAVE_COCOA, 1, [define to 1 if Cocoa is available])
		227	COCOA_LIBS="-Wl,-framework,Foundation"
		228	LDFLAGS="$LDFLAGS $COCOA_LIBS"
		229
		230	osx_version=`sw_vers -productVersion`
		231	osx_min_version="10.9.0"
		232	AC_MSG_CHECKING([OSX version >= $osx_min_version])
		233	AS_VERSION_COMPARE([$osx_version], [$osx_min_version], [
		234	AC_MSG_RESULT([no])
		235	AC_MSG_ERROR([OSX version is too old!])
		236	])
		237	AC_MSG_RESULT([yes])
		238	], [COCOA_LIBS=""])
		239
		240	AC_SUBST([COCOA_LIBS])
		241
		242	dnl declare --enable-* args and collect ac_help strings
		243	AC_ARG_ENABLE(debug,
		244	AS_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
		245	[turn on debugging @<:@default=glib_debug_default@:>@]),,
		246	enable_debug=glib_debug_default)
		247
		248	AC_ARG_ENABLE(gc_friendly,
		249	[AS_HELP_STRING([--enable-gc-friendly],
		250	[turn on garbage collector friendliness [default=no]])],,
		251	[enable_gc_friendly=no])
		252	AC_ARG_ENABLE(mem_pools,
		253	[AS_HELP_STRING([--disable-mem-pools],
		254	[disable all glib memory pools])],,
		255	[disable_mem_pools=no])
		256	AC_ARG_ENABLE(rebuilds,
		257	[AS_HELP_STRING([--disable-rebuilds],
		258	[disable all source autogeneration rules])],,
		259	[enable_rebuilds=yes])
		260
		261	GLIB_TESTS
		262
		263	AC_MSG_CHECKING([whether to enable garbage collector friendliness])
		264	AS_IF([test "x$enable_gc_friendly" = "xyes"], [
		265	AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
		266	AC_MSG_RESULT([yes])
		267	], [ AC_MSG_RESULT([no]) ])
		268
		269	AC_MSG_CHECKING([whether to disable memory pools])
		270	AS_IF([test "x$disable_mem_pools" = "xno"], [
		271	AC_MSG_RESULT([no])
		272	], [
		273	AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
		274	AC_MSG_RESULT([yes])
		275	])
		276
		277	dnl location to install runtime libraries, e.g. ../../lib to install
		278	dnl to /lib if libdir is /usr/lib
		279	AC_ARG_WITH(runtime-libdir,
		280	[AS_HELP_STRING([--with-runtime-libdir=RELPATH],
		281	[install runtime libraries relative to libdir])],
		282	[],
		283	[with_runtime_libdir=""])
		284	GLIB_RUNTIME_LIBDIR="$with_runtime_libdir"
		285	AC_SUBST(GLIB_RUNTIME_LIBDIR)
		286	AM_CONDITIONAL(HAVE_GLIB_RUNTIME_LIBDIR, [test "x$with_runtime_libdir" != "x"])
		287
		288	dnl Check for a working C++ compiler, but do not bail out, if none is found.
		289	AC_CHECK_TOOLS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
		290	AC_LANG_SAVE
		291	AC_LANG_CPLUSPLUS
		292	AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
		293	AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
		294	AC_LANG_RESTORE
		295
		296	AM_PROG_CC_C_O
		297	AC_PROG_INSTALL
		298
		299	AC_SYS_LARGEFILE
		300
		301	PKG_PROG_PKG_CONFIG(0.16)
		302
		303	if test "x$enable_debug" = "xyes"; then
		304	if test "x$cflags_set" != "x" ; then
		305	case " $CFLAGS " in
		306	*[[\ \ ]]-g[[\ \ ]]*) ;;
		307	*) CFLAGS="$CFLAGS -g" ;;
		308	esac
		309	fi
		310	GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
		311	else
		312	GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
		313
		314	if test "x$enable_debug" = "xno"; then
		315	GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
		316	fi
		317	fi
		318
		319	# Ensure MSVC-compatible struct packing convention is used when
		320	# compiling for Win32 with gcc.
		321	# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
		322	# gcc2 uses "-fnative-struct".
		323	if test x"$glib_native_win32" = xyes; then
		324	if test x"$GCC" = xyes; then
		325	msnative_struct=''
		326	AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
		327	if test -z "$ac_cv_prog_CC"; then
		328	our_gcc="$CC"
		329	else
		330	our_gcc="$ac_cv_prog_CC"
		331	fi
		332	case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
		333	2.)
		334	if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
		335	msnative_struct='-fnative-struct'
		336	fi
		337	;;
		338	*)
		339	if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
		340	msnative_struct='-mms-bitfields'
		341	fi
		342	;;
		343	esac
		344	if test x"$msnative_struct" = x ; then
		345	AC_MSG_RESULT([no way])
		346	AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
		347	else
		348	CFLAGS="$CFLAGS $msnative_struct"
		349	AC_MSG_RESULT([${msnative_struct}])
		350	fi
		351	fi
		352	fi
		353	GLIB_EXTRA_CFLAGS="${msnative_struct}"
		354	AC_SUBST(GLIB_EXTRA_CFLAGS)
		355
		356	AC_EXEEXT
		357
		358	# define a MAINT-like variable REBUILD which is set if Perl
		359	# and awk are found, so autogenerated sources can be rebuilt
		360	AC_PROG_AWK
		361	AC_CHECK_PROGS(PERL, [perl5 perl])
		362	# We would like indent, but don't require it.
		363	AC_CHECK_PROG(INDENT, indent, indent)
		364	REBUILD=\#
		365	if test "x$enable_rebuilds" = "xyes" && \
		366	test -n "$PERL" && \
		367	$PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
		368	test -n "$AWK" ; then
		369	REBUILD=
		370	fi
		371	AC_SUBST(REBUILD)
		372
		373	# Need full path to Perl for glib-mkenums
		374	#
		375	if test "x$PERL" != x ; then
		376	AC_PATH_PROG(PERL_PATH, [$PERL])
		377	fi
		378	if test "x$PERL_PATH" = x ; then
		379	PERL_PATH="/usr/bin/env perl"
		380	fi
		381	AC_SUBST(PERL_PATH)
		382
		383	# option to specify python interpreter to use; this just sets $PYTHON, so that
		384	# we will fallback to reading $PYTHON if --with-python is not given, and
		385	# python.m4 will get the expected input
		386	AC_ARG_WITH(python,
		387	AS_HELP_STRING([--with-python=PATH],
		388	[Path to Python interpreter; searches $PATH if only a program name is given; if not given, searches for a few standard names such as "python3" or "python2"]),
		389	[PYTHON="$withval"], [])
		390	if test x"$PYTHON" = xyes; then
		391	AC_MSG_ERROR([--with-python option requires a path or program argument])
		392	fi
		393	AM_PATH_PYTHON(2.5,,PYTHON="/usr/bin/env python2.5")
		394
		395
		396	dnl ***********************
		397	dnl *** Tests for iconv ***
		398	dnl ***********************
		399	dnl
		400	dnl We do this before the gettext checks, to avoid distortion
		401
		402	dnl On Windows we use a native implementation
		403
		404	AS_IF([ test x"$glib_native_win32" = xyes], [
		405	with_libiconv=native
		406	], [
		407	AC_ARG_WITH(libiconv,
		408	[AS_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
		409	[use the libiconv library])],,
		410	[with_libiconv=maybe])
		411
		412	found_iconv=no
		413	case $with_libiconv in
		414	maybe)
		415	# Check in the C library first
		416	AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
		417	# Check if we have GNU libiconv
		418	if test $found_iconv = "no"; then
		419	AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
		420	fi
		421	# Check if we have a iconv in -liconv, possibly from vendor
		422	if test $found_iconv = "no"; then
		423	AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
		424	fi
		425	;;
		426	no)
		427	AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
		428	;;
		429	gnu|yes)
		430	AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
		431	;;
		432	native)
		433	AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
		434	;;
		435	esac
		436
		437	if test "x$found_iconv" = "xno" ; then
		438	AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
		439	fi
		440	])
		441
		442	dnl
		443	dnl zlib support
		444	dnl
		445	PKG_CHECK_MODULES([ZLIB], [zlib], [found_zlib=yes], [found_zlib=no])
		446	AS_IF([test "x$found_zlib" = "xno"], [
		447	AC_CHECK_LIB(z, inflate, [AC_CHECK_HEADER(zlib.h, found_zlib=yes)])
		448	if test "x$found_zlib" = "xno" ; then
		449	AC_MSG_ERROR([*** Working zlib library and headers not found ***])
		450	fi
		451	ZLIB_LIBS='-lz'
		452	AC_SUBST(ZLIB_LIBS)
		453	])
		454
		455	PKG_CHECK_MODULES(LIBFFI, [libffi >= 3.0.0])
		456	AC_SUBST(LIBFFI_CFLAGS)
		457	AC_SUBST(LIBFFI_LIBS)
		458
		459	dnl
		460	dnl gettext support
		461	dnl
		462
		463	ALL_LINGUAS="`grep -v '^#' "$srcdir/po/LINGUAS" | tr '\n' ' '`"
		464	AC_SUBST([CONFIG_STATUS_DEPENDENCIES],['$(top_srcdir)/po/LINGUAS'])
		465	GLIB_GNU_GETTEXT
		466
		467	if test "$gt_cv_have_gettext" != "yes" ; then
		468	AC_MSG_ERROR([
		469	*** You must have either have gettext support in your C library, or use the
		470	*** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
		471	])
		472	fi
		473
		474	LIBS="$INTLLIBS $LIBS"
		475
		476	GETTEXT_PACKAGE=glib20
		477	AC_SUBST(GETTEXT_PACKAGE)
		478	AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
		479	[Define the gettext package to be used])
		480
		481	GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
		482
		483	dnl
		484	dnl Now we are done with gettext checks, figure out ICONV_LIBS
		485	dnl
		486
		487	AS_IF([test x"$glib_native_win32" != xyes], [
		488	if test x$with_libiconv != xno ; then
		489	case " $INTLLIBS " in
		490	*[[\ \ ]]-liconv[[\ \ ]]*) ;;
		491	*) ICONV_LIBS="-liconv" ;;
		492	esac
		493	fi
		494	])
		495	AC_SUBST(ICONV_LIBS)
		496
		497	case $with_libiconv in
		498	gnu)
		499	AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
		500	;;
		501	native)
		502	AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
		503	;;
		504	esac
		505
		506	dnl Initialize libtool
		507	LT_PREREQ([2.2])
		508	LT_INIT([disable-static win32-dll])
		509	dnl when using libtool 2.x create libtool early, because it's used in configure
		510	m4_ifdef([LT_OUTPUT], [LT_OUTPUT])
		511
		512
		513	AS_IF([test "$glib_native_win32" = "yes"], [
		514	if test x$enable_static = xyes -a x$enable_shared = xyes; then
		515	AC_MSG_ERROR([Can not build both shared and static at the same time on Windows.])
		516	fi
		517	if test x$enable_static = xyes; then
		518	glib_win32_static_compilation=yes
		519	GLIB_WIN32_STATIC_COMPILATION_DEFINE="#define GLIB_STATIC_COMPILATION 1
		520	#define GOBJECT_STATIC_COMPILATION 1"
		521	AC_SUBST(GLIB_WIN32_STATIC_COMPILATION_DEFINE)
		522	fi
		523	])
		524	AM_CONDITIONAL(OS_WIN32_AND_DLL_COMPILATION, [test x$glib_native_win32 = xyes -a x$glib_win32_static_compilation != xyes])
		525
		526	# Checks for library functions.
		527	AC_FUNC_ALLOCA
		528	AC_CHECK_FUNCS(mmap posix_memalign memalign valloc fsync pipe2 issetugid)
		529	AC_CHECK_FUNCS(timegm gmtime_r strerror_r)
		530
		531	AC_CACHE_CHECK([for __libc_enable_secure], glib_cv_have_libc_enable_secure,
		532	[AC_TRY_LINK([#include <unistd.h>
		533	extern int __libc_enable_secure;],
		534	[return __libc_enable_secure;],
		535	glib_cv_have_libc_enable_secure=yes,
		536	glib_cv_have_libc_enable_secure=no)])
		537	AS_IF([test x$glib_cv_have_libc_enable_secure = xyes], [
		538	AC_DEFINE(HAVE_LIBC_ENABLE_SECURE, 1,
		539	[Define if you have the __libc_enable_secure variable (GNU libc, eglibc)])
		540	])
		541
		542	AC_CHECK_SIZEOF(char)
		543	AC_CHECK_SIZEOF(short)
		544	AC_CHECK_SIZEOF(long)
		545	AC_CHECK_SIZEOF(int)
		546	AC_CHECK_SIZEOF(void *)
		547	AC_CHECK_SIZEOF(long long)
		548	AC_CHECK_SIZEOF(__int64)
		549
		550	AC_CACHE_CHECK([for sig_atomic_t], ac_cv_type_sig_atomic_t,
		551	[AC_TRY_LINK([#include <signal.h>
		552	#include <sys/types.h>
		553	sig_atomic_t val = 42;],
		554	[return val == 42 ? 0 : 1],
		555	ac_cv_type_sig_atomic_t=yes,
		556	ac_cv_type_sig_atomic_t=no)])
		557	if test x$ac_cv_type_sig_atomic_t = xyes; then
		558	AC_DEFINE(HAVE_SIG_ATOMIC_T, 1,
		559	[Define if you have the 'sig_atomic_t' type.])
		560	fi
		561
		562	if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
		563	:
		564	else
		565	AC_MSG_ERROR([
		566	*** GLib requires a 64 bit type. You might want to consider
		567	*** using the GNU C compiler.
		568	])
		569	fi
		570
		571	AS_IF([test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8], [
		572	# long long is a 64 bit integer.
		573	AC_MSG_CHECKING(for format to printf and scanf a guint64)
		574	AC_CACHE_VAL(glib_cv_long_long_format,[
		575	for format in ll q I64; do
		576	AC_TRY_RUN([#include <stdio.h>
		577	int main()
		578	{
		579	long long b, a = -0x3AFAFAFAFAFAFAFALL;
		580	char buffer[1000];
		581	sprintf (buffer, "%${format}u", a);
		582	sscanf (buffer, "%${format}u", &b);
		583	exit (b!=a);
		584	}
		585	],
		586	[glib_cv_long_long_format=${format}
		587	break],
		588	[],[:])
		589	done])
		590	AS_IF([ test -n "$glib_cv_long_long_format"], [
		591	AC_MSG_RESULT(%${glib_cv_long_long_format}u)
		592	AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
		593	if test x"$glib_cv_long_long_format" = xI64; then
		594	AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
		595	fi
		596	], [AC_MSG_RESULT(none)])
		597	],[ test x$ac_cv_sizeof___int64 = x8], [
		598	# __int64 is a 64 bit integer.
		599	AC_MSG_CHECKING(for format to printf and scanf a guint64)
		600	# We know this is MSVCRT.DLL, and what the formats are
		601	glib_cv_long_long_format=I64
		602	AC_MSG_RESULT(%${glib_cv_long_long_format}u)
		603	AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
		604	AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
		605	])
		606
		607	AC_C_CONST
		608
		609	dnl
		610	dnl check in which direction the stack grows
		611	dnl
		612	AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
		613	AC_TRY_RUN([
		614	volatile int *a = 0, *b = 0;
		615	void f (int i) { volatile int x = 5; if (i == 0) b = &x; else f (i - 1); }
		616	int main () { volatile int y = 7; a = &y; f (100); return b > a ? 0 : 1; }
		617	],
		618	glib_cv_stack_grows=yes
		619	,
		620	glib_cv_stack_grows=no
		621	,)
		622	])
		623
		624	# check for flavours of varargs macros
		625	AC_MSG_CHECKING(for ISO C99 varargs macros in C)
		626	AC_TRY_COMPILE([],[
		627	int a(int p1, int p2, int p3);
		628	#define call_a(...) a(1,__VA_ARGS__)
		629	call_a(2,3);
		630	],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
		631	AC_MSG_RESULT($g_have_iso_c_varargs)
		632
		633	AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
		634	AS_IF([test "$CXX" = ""], [
		635	dnl No C++ compiler
		636	g_have_iso_cxx_varargs=no
		637	else
		638	AC_LANG_CPLUSPLUS
		639	AC_TRY_COMPILE([],[
		640	int a(int p1, int p2, int p3);
		641	#define call_a(...) a(1,__VA_ARGS__)
		642	call_a(2,3);
		643	],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
		644	AC_LANG_C
		645	])
		646	AC_MSG_RESULT($g_have_iso_cxx_varargs)
		647
		648	AC_MSG_CHECKING(for GNUC varargs macros)
		649	AC_TRY_COMPILE([],[
		650	int a(int p1, int p2, int p3);
		651	#define call_a(params...) a(1,params)
		652	call_a(2,3);
		653	],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
		654	AC_MSG_RESULT($g_have_gnuc_varargs)
		655
		656	# check for GNUC visibility support
		657	AC_MSG_CHECKING(for GNUC visibility attribute)
		658	GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
		659	void
		660	__attribute__ ((visibility ("hidden")))
		661	f_hidden (void)
		662	{
		663	}
		664	void
		665	__attribute__ ((visibility ("internal")))
		666	f_internal (void)
		667	{
		668	}
		669	void
		670	__attribute__ ((visibility ("protected")))
		671	f_protected (void)
		672	{
		673	}
		674	void
		675	__attribute__ ((visibility ("default")))
		676	f_default (void)
		677	{
		678	}
		679	int main (void)
		680	{
		681	f_hidden();
		682	f_internal();
		683	f_protected();
		684	f_default();
		685	return 0;
		686	}
		687	]])],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
		688	AC_MSG_RESULT($g_have_gnuc_visibility)
		689	AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
		690
		691	AC_MSG_CHECKING([whether using Sun Studio C compiler])
		692	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
		693	#else
		694	# include "error: this is not Sun Studio."
		695	#endif
		696	]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
		697	AC_MSG_RESULT($g_have_sunstudio_visibility)
		698	AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
		699
		700	# check for bytesex stuff
		701	AC_C_BIGENDIAN
		702	if test x$ac_cv_c_bigendian = xuniversal ; then
		703	AC_MSG_ERROR([Universal builds not supported: see https://bugs.gnome.org/742548])
		704	fi
		705
		706
		707	# check for header files
		708	AC_CHECK_HEADERS([sys/param.h sys/resource.h mach/mach_time.h])
		709	AC_CHECK_HEADERS([sys/select.h stdint.h inttypes.h sched.h malloc.h])
		710	AC_CHECK_HEADERS([sys/vfs.h sys/vmount.h sys/statfs.h sys/statvfs.h sys/filio.h])
		711	AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h fstab.h])
		712	AC_CHECK_HEADERS([linux/magic.h])
		713
		714	# Some versions of MSC lack these
		715	AC_CHECK_HEADERS([dirent.h sys/time.h])
		716
		717	# We don't care about this, but we need to keep including it in
		718	# glibconfig.h for backward compatibility
		719	AC_CHECK_HEADERS([values.h])
		720
		721	AC_CHECK_HEADERS([sys/mount.h sys/sysctl.h], [], [],
		722	[#if HAVE_SYS_PARAM_H
		723	#include <sys/param.h>
		724	#endif
		725	])
		726	AC_CHECK_FUNCS(sysctlbyname)
		727
		728	AC_HEADER_MAJOR
		729	AC_CHECK_HEADERS([xlocale.h])
		730
		731	# check for structure fields
		732	AC_CHECK_MEMBERS([struct stat.st_mtimensec, struct stat.st_mtim.tv_nsec, struct stat.st_atimensec, struct stat.st_atim.tv_nsec, struct stat.st_ctimensec, struct stat.st_ctim.tv_nsec, struct stat.st_birthtime, struct stat.st_birthtimensec, struct stat.st_birthtim, struct stat.st_birthtim.tv_nsec])
		733	AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename, struct statfs.f_bavail],,, [#include <sys/types.h>
		734	#include <sys/stat.h>
		735	#ifdef G_OS_UNIX
		736	#include <unistd.h>
		737	#endif
		738	#ifdef HAVE_SYS_STATFS_H
		739	#include <sys/statfs.h>
		740	#endif
		741	#ifdef HAVE_SYS_PARAM_H
		742	#include <sys/param.h>
		743	#endif
		744	#ifdef HAVE_SYS_MOUNT_H
		745	#include <sys/mount.h>
		746	#endif])
		747	# struct statvfs.f_basetype is available on Solaris but not for Linux.
		748	AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
		749	AC_CHECK_MEMBERS([struct statvfs.f_fstypename],,, [#include <sys/statvfs.h>])
		750	AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[#include <time.h>])
		751
		752	AC_STRUCT_DIRENT_D_TYPE
		753
		754	# Checks for libcharset
		755	AM_LANGINFO_CODESET
		756	gl_GLIBC21
		757
		758	# check additional type sizes
		759	AC_CHECK_SIZEOF(size_t)
		760
		761	dnl Try to figure out whether gsize should be long or int
		762	AC_MSG_CHECKING([for the appropriate definition for size_t])
		763
		764	case $ac_cv_sizeof_size_t in
		765	$ac_cv_sizeof_short)
		766	glib_size_type=short
		767	;;
		768	$ac_cv_sizeof_int)
		769	glib_size_type=int
		770	;;
		771	$ac_cv_sizeof_long)
		772	glib_size_type=long
		773	;;
		774	$ac_cv_sizeof_long_long)
		775	glib_size_type='long long'
		776	;;
		777	$ac_cv_sizeof__int64)
		778	glib_size_type='__int64'
		779	;;
		780	*) AC_MSG_ERROR([No type matching size_t in size])
		781	;;
		782	esac
		783
		784	dnl If int/long are the same size, we see which one produces
		785	dnl warnings when used in the location as size_t. (This matters
		786	dnl on AIX with xlc)
		787	dnl
		788	AS_IF([test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
		789	test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long], [
		790	GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
		791	#if defined(_AIX) && !defined(__GNUC__)
		792	#pragma options langlvl=stdc89
		793	#endif
		794	#include <stddef.h>
		795	int main ()
		796	{
		797	size_t s = 1;
		798	unsigned int *size_int = &s;
		799	return (int)*size_int;
		800	}
		801	]])],glib_size_type=int,
		802	[GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
		803	#if defined(_AIX) && !defined(__GNUC__)
		804	#pragma options langlvl=stdc89
		805	#endif
		806	#include <stddef.h>
		807	int main ()
		808	{
		809	size_t s = 1;
		810	unsigned long *size_long = &s;
		811	return (int)*size_long;
		812	}
		813	]])],glib_size_type=long)])
		814	])
		815
		816	AC_MSG_RESULT(unsigned $glib_size_type)
		817
		818	AC_CHECK_SIZEOF(ssize_t)
		819
		820	dnl Try to figure out whether gssize should be long or int
		821	AC_MSG_CHECKING([for the appropriate definition for ssize_t])
		822
		823	case $ac_cv_sizeof_ssize_t in
		824	$ac_cv_sizeof_short)
		825	glib_ssize_type=short
		826	;;
		827	$ac_cv_sizeof_int)
		828	glib_ssize_type=int
		829	;;
		830	$ac_cv_sizeof_long)
		831	glib_ssize_type=long
		832	;;
		833	$ac_cv_sizeof_long_long)
		834	glib_ssize_type='long long'
		835	;;
		836	$ac_cv_sizeof__int64)
		837	glib_ssize_type='__int64'
		838	;;
		839	*) AC_MSG_ERROR([No type matching ssize_t in size])
		840	;;
		841	esac
		842
		843	dnl If int/long are the same size, we see which one produces
		844	dnl warnings when used in the location as ssize_t. (This matters
		845	dnl on Android where ssize_t is long and size_t is unsigned int)
		846	dnl
		847	AS_IF([test $ac_cv_sizeof_ssize_t = $ac_cv_sizeof_int &&
		848	test $ac_cv_sizeof_ssize_t = $ac_cv_sizeof_long], [
		849	GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
		850	#if defined(_AIX) && !defined(__GNUC__)
		851	#pragma options langlvl=stdc89
		852	#endif
		853	#include <stddef.h>
		854	#ifdef HAVE_INTTYPES_H
		855	# include <inttypes.h>
		856	#endif
		857	#ifdef HAVE_STDINT_H
		858	# include <stdint.h>
		859	#endif
		860	#include <sys/types.h>
		861	int main ()
		862	{
		863	ssize_t s = 1;
		864	int *size_int = &s;
		865	return (int)*size_int;
		866	}
		867	]])],glib_ssize_type=int,
		868	[GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
		869	#if defined(_AIX) && !defined(__GNUC__)
		870	#pragma options langlvl=stdc89
		871	#endif
		872	#include <stddef.h>
		873	#ifdef HAVE_INTTYPES_H
		874	# include <inttypes.h>
		875	#endif
		876	#ifdef HAVE_STDINT_H
		877	# include <stdint.h>
		878	#endif
		879	#include <sys/types.h>
		880	int main ()
		881	{
		882	ssize_t s = 1;
		883	long *size_long = &s;
		884	return (int)*size_long;
		885	}
		886	]])],glib_ssize_type=long)])
		887	])
		888
		889	AC_MSG_RESULT($glib_ssize_type)
		890
		891	# Check for some functions
		892	AC_CHECK_FUNCS(lstat strsignal vsnprintf stpcpy strcasecmp strncasecmp poll vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk memmem)
		893	AC_CHECK_FUNCS(lchmod lchown fchmod fchown utimes getresuid)
		894	AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getfsstat getvfsstat fallocate)
		895	case $host_os in aix*) ac_cv_func_splice=no ;; esac # AIX splice() is something else
		896	AC_CHECK_FUNCS(splice)
		897	AC_CHECK_FUNCS(prlimit)
		898
		899	# To avoid finding a compatibility unusable statfs, which typically
		900	# successfully compiles, but warns to use the newer statvfs interface:
		901	AS_IF([test $ac_cv_header_sys_statvfs_h = yes], [AC_CHECK_FUNCS([statvfs])])
		902	AS_IF([test $ac_cv_header_sys_statfs_h = yes -o $ac_cv_header_sys_mount_h = yes], [AC_CHECK_FUNCS([statfs])])
		903
		904	AC_MSG_CHECKING([whether to use statfs or statvfs])
		905	# Some systems have both statfs and statvfs, pick the most "native" for these
		906	AS_IF([test x$ac_cv_func_statfs = xyes && test x$ac_cv_func_statvfs = xyes],
		907	[
		908	# on solaris and irix, statfs doesn't even have the f_bavail field
		909	AS_IF([test x$ac_cv_member_struct_statfs_f_bavail = xno],
		910	[ac_cv_func_statfs=no],
		911	# else, at least on linux, statfs is the actual syscall
		912	[ac_cv_func_statvfs=no])
		913	])
		914
		915	AS_IF([test x$ac_cv_func_statfs = xyes],
		916	[
		917	AC_DEFINE([USE_STATFS], [1], [Define to use statfs()])
		918	AC_MSG_RESULT([statfs])
		919	],
		920	[test x$ac_cv_func_statvfs = xyes],
		921	[
		922	AC_DEFINE([USE_STATVFS], [1], [Define to use statvfs()])
		923	AC_MSG_RESULT([statvfs])
		924	],
		925	[ AC_MSG_RESULT([neither])])
		926
		927	AC_CHECK_HEADERS(crt_externs.h)
		928	AC_CHECK_FUNCS(_NSGetEnviron)
		929
		930	AC_CHECK_FUNCS(newlocale uselocale strtod_l strtoll_l strtoull_l)
		931
		932	# Internet address families
		933	if test $glib_native_win32 = yes; then
		934	glib_inet_includes=["
		935	#include <winsock2.h>
		936	"]
		937	else
		938	glib_inet_includes=["
		939	#include <sys/types.h>
		940	#include <sys/socket.h>
		941	"]
		942	fi
		943
		944	glib_failed=false
		945	GLIB_CHECK_VALUE(AF_INET, $glib_inet_includes, glib_failed=true)
		946	GLIB_CHECK_VALUE(AF_INET6, $glib_inet_includes, glib_failed=true)
		947	# winsock defines this even though it doesn't support it
		948	GLIB_CHECK_VALUE(AF_UNIX, $glib_inet_includes, glib_failed=true)
		949	if $glib_failed ; then
		950	AC_MSG_ERROR([Could not determine values for AF_INET* constants])
		951	fi
		952
		953	glib_failed=false
		954	GLIB_CHECK_VALUE(MSG_PEEK, $glib_inet_includes, glib_failed=true)
		955	GLIB_CHECK_VALUE(MSG_OOB, $glib_inet_includes, glib_failed=true)
		956	GLIB_CHECK_VALUE(MSG_DONTROUTE, $glib_inet_includes, glib_failed=true)
		957	if $glib_failed ; then
		958	AC_MSG_ERROR([Could not determine values for MSG_* constants])
		959	fi
		960
		961	AC_CHECK_FUNCS(getprotobyname_r endservent if_nametoindex if_indextoname sendmmsg recvmmsg)
		962
		963	AS_IF([test $glib_native_win32 = yes], [
		964	# <wspiapi.h> in the Windows SDK and in mingw-w64 has wrappers for
		965	# inline workarounds for getaddrinfo, getnameinfo and freeaddrinfo if
		966	# they aren't present at run-time (on Windows 2000).
		967	AC_CHECK_HEADER([wspiapi.h], [WSPIAPI_INCLUDE="#include <wspiapi.h>"])
		968	AC_SUBST(WSPIAPI_INCLUDE)
		969	], [
		970	# Android does not have C_IN in public headers, we define it wherever necessary
		971	AS_IF([test $glib_native_android != yes], [
		972	AC_MSG_CHECKING([if arpa/nameser_compat.h is needed])
		973	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
		974	#include <arpa/nameser.h>],
		975	[int qclass = C_IN;])],
		976	[AC_MSG_RESULT([no])],
		977	[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
		978	#include <arpa/nameser.h>
		979	#include <arpa/nameser_compat.h>],
		980	[int qclass = C_IN;])],
		981	[AC_MSG_RESULT([yes])
		982	NAMESER_COMPAT_INCLUDE="#include <arpa/nameser_compat.h>"],
		983	[AC_MSG_ERROR([could not compile test program either way])])])])
		984	AC_SUBST(NAMESER_COMPAT_INCLUDE)
		985
		986	# We can't just use AC_CHECK_FUNC/AC_CHECK_LIB here. Bug 586150
		987	NETWORK_LIBS=""
		988	AC_MSG_CHECKING([for res_query])
		989	AC_TRY_LINK([#include <sys/types.h>
		990	#include <netinet/in.h>
		991	#include <arpa/nameser.h>
		992	#include <resolv.h>
		993	],[
		994	res_query("test", 0, 0, (void *)0, 0);
		995	],[AC_MSG_RESULT([yes])],
		996	[save_libs="$LIBS"
		997	LIBS="-lresolv $LIBS"
		998	AC_TRY_LINK([#include <sys/types.h>
		999	#include <netinet/in.h>
		1000	#include <arpa/nameser.h>
		1001	#include <resolv.h>
		1002	],[
		1003	res_query("test", 0, 0, (void *)0, 0);
		1004	],[AC_MSG_RESULT([in -lresolv])
		1005	NETWORK_LIBS="-lresolv $NETWORK_LIBS"],
		1006	[LIBS="-lbind $save_libs"
		1007	AC_TRY_LINK([#include <resolv.h>],
		1008	[res_query("test", 0, 0, (void *)0, 0);],
		1009	[AC_MSG_RESULT([in -lbind])
		1010	NETWORK_LIBS="-lbind $NETWORK_LIBS"],
		1011	[AC_MSG_ERROR(not found)])])
		1012	LIBS="$save_libs"])
		1013	AC_CHECK_FUNC(socket, :, AC_CHECK_LIB(socket, socket,
		1014	[NETWORK_LIBS="-lsocket $NETWORK_LIBS"],
		1015	[AC_MSG_ERROR(Could not find socket())]))
		1016	save_libs="$LIBS"
		1017	LIBS="$LIBS $NETWORK_LIBS"
		1018	AC_MSG_CHECKING([for res_init])
		1019	AC_TRY_LINK([#include <sys/types.h>
		1020	#include <netinet/in.h>
		1021	#include <arpa/nameser.h>
		1022	#include <resolv.h>
		1023	],[
		1024	res_init();
		1025	],[AC_MSG_RESULT([yes])
		1026	AC_DEFINE(HAVE_RES_INIT, 1, [Define to 1 if you have the 'res_init' function.])
		1027	],[AC_MSG_RESULT([no])])
		1028	LIBS="$save_libs"
		1029	])
		1030	AC_SUBST(NETWORK_LIBS)
		1031
		1032	AC_CHECK_HEADER([linux/netlink.h],
		1033	[AC_DEFINE(HAVE_NETLINK, 1, [We have AF_NETLINK sockets])],,
		1034	[#include <sys/socket.h>])
		1035	AM_CONDITIONAL(HAVE_NETLINK, [test "$ac_cv_header_linux_netlink_h" = "yes"])
		1036
		1037	AC_CHECK_TYPE([struct ip_mreqn], [
		1038	AC_DEFINE(HAVE_IP_MREQN,, [Define if we have struct ip_mreqn])],,
		1039	[#include <netinet/in.h>])
		1040
		1041	case $host in
		1042	*-*-solaris* )
		1043	AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1, Needed to get declarations for msg_control and msg_controllen on Solaris)
		1044	AC_DEFINE(_XOPEN_SOURCE, 2, Needed to get declarations for msg_control and msg_controllen on Solaris)
		1045	AC_DEFINE(__EXTENSIONS__, 1, Needed to get declarations for msg_control and msg_controllen on Solaris)
		1046	;;
		1047	esac
		1048
		1049	dnl
		1050	dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
		1051	dnl
		1052	AS_IF([test "$ac_cv_func_statfs" = yes], [
		1053	AC_MSG_CHECKING([number of arguments to statfs()])
		1054	AC_TRY_COMPILE([#include <unistd.h>
		1055	#ifdef HAVE_SYS_PARAM_H
		1056	#include <sys/param.h>
		1057	#endif
		1058	#ifdef HAVE_SYS_VFS_H
		1059	#include <sys/vfs.h>
		1060	#endif
		1061	#ifdef HAVE_SYS_MOUNT_H
		1062	#include <sys/mount.h>
		1063	#endif
		1064	#ifdef HAVE_SYS_STATFS_H
		1065	#include <sys/statfs.h>
		1066	#endif], [struct statfs st;
		1067	statfs("/", &st);],[
		1068	AC_MSG_RESULT([2])
		1069	AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
		1070	AC_TRY_COMPILE([#include <unistd.h>
		1071	#ifdef HAVE_SYS_PARAM_H
		1072	#include <sys/param.h>
		1073	#endif
		1074	#ifdef HAVE_SYS_VFS_H
		1075	#include <sys/vfs.h>
		1076	#endif
		1077	#ifdef HAVE_SYS_MOUNT_H
		1078	#include <sys/mount.h>
		1079	#endif
		1080	#ifdef HAVE_SYS_STATFS_H
		1081	#include <sys/statfs.h>
		1082	#endif], [struct statfs st;
		1083	statfs("/", &st, sizeof (st), 0);],[
		1084	AC_MSG_RESULT([4])
		1085	AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
		1086	AC_MSG_RESULT(unknown)
		1087	AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
		1088	])
		1089
		1090	dnl
		1091	dnl open takes O_DIRECTORY as an option
		1092	dnl
		1093	AC_MSG_CHECKING([open() option O_DIRECTORY])
		1094	AC_TRY_COMPILE([#include <fcntl.h>
		1095	#include <sys/types.h>
		1096	#include <sys/stat.h>],
		1097	[open(0, O_DIRECTORY, 0);],[
		1098	AC_MSG_RESULT([yes])
		1099	AC_DEFINE(HAVE_OPEN_O_DIRECTORY, 1, [open option O_DIRECTORY])],[
		1100	AC_MSG_RESULT([no])])
		1101
		1102	#
		1103	# Check whether to use an included printf
		1104	#
		1105	AC_FUNC_VSNPRINTF_C99
		1106	AC_FUNC_PRINTF_UNIX98
		1107
		1108	AC_ARG_ENABLE(included-printf,
		1109	[AS_HELP_STRING([--enable-included-printf],
		1110	[use included printf [default=auto]])],
		1111	enable_included_printf="$enableval")
		1112
		1113	need_included_printf=no
		1114	if test "x$enable_included_printf" = "xyes" ; then
		1115	need_included_printf=yes
		1116	fi
		1117	if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
		1118	need_included_printf=yes
		1119	fi
		1120	if test "$ac_cv_func_printf_unix98" != "yes" ; then
		1121	need_included_printf=yes
		1122	fi
		1123	if test "x$ac_cv_sizeof_long_long" = "x8" &&
		1124	test -z "$glib_cv_long_long_format" ; then
		1125	need_included_printf=yes
		1126	fi
		1127
		1128	if test "x$enable_included_printf" = "xno" &&
		1129	test "x$need_included_printf" = "xyes" ; then
		1130	AC_MSG_ERROR([
		1131	*** Your C library's printf doesn't appear to have the features that
		1132	*** GLib needs, but you specified --enable-included-printf=no.])
		1133	fi
		1134
		1135	enable_included_printf=$need_included_printf
		1136
		1137	AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
		1138	AS_IF([test "$enable_included_printf" != "yes"], [
		1139	AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
		1140	], [
		1141	if test -z "$glib_cv_long_long_format" ; then
		1142	glib_cv_long_long_format="ll"
		1143	fi
		1144	AC_DEFINE(HAVE_VASPRINTF,1)
		1145	])
		1146
		1147	# Checks needed for gnulib vasnprintf
		1148	bh_C_SIGNED
		1149	jm_AC_TYPE_LONG_LONG
		1150	gt_TYPE_LONGDOUBLE
		1151	gt_TYPE_WCHAR_T
		1152	gt_TYPE_WINT_T
		1153	AC_TYPE_SIZE_T
		1154	AC_CHECK_TYPES(ptrdiff_t)
		1155	jm_AC_TYPE_INTMAX_T
		1156	AC_CHECK_FUNCS([snprintf strnlen wcslen wcsnlen mbrtowc wcrtomb])
		1157	AC_FUNC_SNPRINTF_C99
		1158
		1159	# Check if <sys/select.h> needs to be included for fd_set
		1160	AC_MSG_CHECKING([for fd_set])
		1161	AC_TRY_COMPILE([#include <sys/types.h>],
		1162	[fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
		1163	AS_IF([test "$gtk_ok" = "yes"], [
		1164	AC_MSG_RESULT([yes, found in sys/types.h])
		1165	], [
		1166	AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
		1167	if test "$gtk_ok" = "yes"; then
		1168	# *** FIXME: give it a different name
		1169	AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
		1170	AC_MSG_RESULT([yes, found in sys/select.h])
		1171	else
		1172	AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
		1173	AC_MSG_RESULT(no)
		1174	fi
		1175	])
		1176
		1177	dnl Check for nl_langinfo and CODESET
		1178	AC_LANG_SAVE
		1179	AC_LANG_C
		1180	AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
		1181	AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <langinfo.h>],
		1182	[char *codeset = nl_langinfo (CODESET);])],
		1183	[glib_cv_langinfo_codeset=yes],
		1184	[glib_cv_langinfo_codeset=no])])
		1185	if test x$glib_cv_langinfo_codeset = xyes; then
		1186	AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
		1187	fi
		1188
		1189	dnl Check for nl_langinfo and LC_TIME parts that are needed in gdatetime.c
		1190	AC_CACHE_CHECK([for nl_langinfo (PM_STR)],glib_cv_langinfo_time,[
		1191	AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <langinfo.h>],
		1192	[char *str;
		1193	str = nl_langinfo (PM_STR);
		1194	str = nl_langinfo (D_T_FMT);
		1195	str = nl_langinfo (D_FMT);
		1196	str = nl_langinfo (T_FMT);
		1197	str = nl_langinfo (T_FMT_AMPM);
		1198	str = nl_langinfo (MON_1);
		1199	str = nl_langinfo (ABMON_12);
		1200	str = nl_langinfo (DAY_1);
		1201	str = nl_langinfo (ABDAY_7);])],
		1202	[glib_cv_langinfo_time=yes],
		1203	[glib_cv_langinfo_time=no])])
		1204	if test x$glib_cv_langinfo_time = xyes; then
		1205	AC_DEFINE(HAVE_LANGINFO_TIME,1,[Have nl_langinfo (PM_STR)])
		1206	fi
		1207
		1208	dnl Check for nl_langinfo and _NL_CTYPE_OUTDIGITn_MB
		1209	AC_CACHE_CHECK([for nl_langinfo (_NL_CTYPE_OUTDIGITn_MB)], glib_cv_langinfo_outdigit,[
		1210	AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <langinfo.h>],
		1211	[char *str;
		1212	str = nl_langinfo (_NL_CTYPE_OUTDIGIT0_MB);
		1213	str = nl_langinfo (_NL_CTYPE_OUTDIGIT1_MB);
		1214	str = nl_langinfo (_NL_CTYPE_OUTDIGIT2_MB);
		1215	str = nl_langinfo (_NL_CTYPE_OUTDIGIT3_MB);
		1216	str = nl_langinfo (_NL_CTYPE_OUTDIGIT4_MB);
		1217	str = nl_langinfo (_NL_CTYPE_OUTDIGIT5_MB);
		1218	str = nl_langinfo (_NL_CTYPE_OUTDIGIT6_MB);
		1219	str = nl_langinfo (_NL_CTYPE_OUTDIGIT7_MB);
		1220	str = nl_langinfo (_NL_CTYPE_OUTDIGIT8_MB);
		1221	str = nl_langinfo (_NL_CTYPE_OUTDIGIT9_MB);])],
		1222	[glib_cv_langinfo_outdigit=yes],
		1223	[glib_cv_langinfo_outdigit=no])])
		1224	if test x$glib_cv_langinfo_outdigit = xyes; then
		1225	AC_DEFINE(HAVE_LANGINFO_OUTDIGIT,1,[Have nl_langinfo (_NL_CTYPE_OUTDIGITn_MB)])
		1226	fi
		1227	AC_LANG_RESTORE
		1228
		1229	dnl ****************************************
		1230	dnl *** posix_memalign ***
		1231	dnl ****************************************
		1232	AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
		1233	AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
		1234	glib_cv_compliant_posix_memalign=0
		1235	if test "$ac_cv_func_posix_memalign" = "yes" ; then
		1236	AC_TRY_RUN([
		1237	#define _XOPEN_SOURCE 600
		1238	#include <stdlib.h> /* posix_memalign() should be defined here */
		1239	/* some systems break if #include <malloc.h> used */
		1240	static void test_memalign (size_t boundary, size_t size) {
		1241	void *mem = 0;
		1242	if (posix_memalign (&mem, boundary, size) != 0 || !mem)
		1243	exit (1);
		1244	else
		1245	free (mem);
		1246	}
		1247	int main() {
		1248	test_memalign ( 128, 128 - 2 * sizeof (void*));
		1249	test_memalign ( 256, 256 - 2 * sizeof (void*));
		1250	test_memalign ( 512, 512 - 2 * sizeof (void*));
		1251	test_memalign ( 1024, 1024 - 2 * sizeof (void*));
		1252	test_memalign ( 2048, 2048 - 2 * sizeof (void*));
		1253	test_memalign ( 4096, 4096 - 2 * sizeof (void*));
		1254	test_memalign ( 8192, 8192 - 2 * sizeof (void*));
		1255	test_memalign (16384, 16384 - 2 * sizeof (void*));
		1256	test_memalign (32768, 32768 - 2 * sizeof (void*));
		1257	exit (0); /* success */
		1258	}
		1259	],
		1260	[glib_cv_compliant_posix_memalign=1], [], [:])
		1261	:
		1262	fi
		1263	])
		1264	AS_IF([test "$glib_cv_compliant_posix_memalign" = "1"], [
		1265	AC_MSG_RESULT(yes)
		1266	AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
		1267	], [
		1268	AC_MSG_RESULT(no)
		1269	])
		1270
		1271
		1272	dnl ****************************************
		1273	dnl *** strlcpy/strlcat ***
		1274	dnl ****************************************
		1275	# Check for strlcpy
		1276	AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
		1277	AC_TRY_RUN([#include <stdlib.h>
		1278	#include <string.h>
		1279	int main() {
		1280	char p[10];
		1281	(void) strlcpy (p, "hi", 10);
		1282	if (strlcat (p, "bye", 0) != 3)
		1283	return 1;
		1284	return 0;
		1285	}], glib_cv_have_strlcpy=yes,
		1286	glib_cv_have_strlcpy=no,
		1287	glib_cv_have_strlcpy=no)])
		1288	if test "$glib_cv_have_strlcpy" = "yes"; then
		1289	AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
		1290	fi
		1291
		1292
		1293	dnl **********************
		1294	dnl *** va_copy checks ***
		1295	dnl **********************
		1296	dnl we currently check for all three va_copy possibilities, so we get
		1297	dnl all results in config.log for bug reports.
		1298	AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
		1299	AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
		1300	#include <stdlib.h>
		1301	void f (int i, ...) {
		1302	va_list args1, args2;
		1303	va_start (args1, i);
		1304	va_copy (args2, args1);
		1305	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
		1306	exit (1);
		1307	va_end (args1); va_end (args2);
		1308	}
		1309	int main() {
		1310	f (0, 42);
		1311	return 0;
		1312	}]])],
		1313	[glib_cv_va_copy=yes],
		1314	[glib_cv_va_copy=no])
		1315	])
		1316	AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
		1317	AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
		1318	#include <stdlib.h>
		1319	void f (int i, ...) {
		1320	va_list args1, args2;
		1321	va_start (args1, i);
		1322	__va_copy (args2, args1);
		1323	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
		1324	exit (1);
		1325	va_end (args1); va_end (args2);
		1326	}
		1327	int main() {
		1328	f (0, 42);
		1329	return 0;
		1330	}]])],
		1331	[glib_cv___va_copy=yes],
		1332	[glib_cv___va_copy=no])
		1333	])
		1334
		1335	if test "x$glib_cv_va_copy" = "xyes"; then
		1336	g_va_copy_func=va_copy
		1337	else if test "x$glib_cv___va_copy" = "xyes"; then
		1338	g_va_copy_func=__va_copy
		1339	fi
		1340	fi
		1341
		1342	if test -n "$g_va_copy_func"; then
		1343	AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
		1344	fi
		1345
		1346	AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
		1347	AC_TRY_RUN([#include <stdarg.h>
		1348	#include <stdlib.h>
		1349	void f (int i, ...) {
		1350	va_list args1, args2;
		1351	va_start (args1, i);
		1352	args2 = args1;
		1353	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
		1354	exit (1);
		1355	va_end (args1); va_end (args2);
		1356	}
		1357	int main() {
		1358	f (0, 42);
		1359	return 0;
		1360	}],
		1361	[glib_cv_va_val_copy=yes],
		1362	[glib_cv_va_val_copy=no],
		1363	[glib_cv_va_val_copy=yes])
		1364	])
		1365
		1366	AS_IF([ test "x$glib_cv_va_val_copy" = "xno"], [
		1367	AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
		1368	])
		1369
		1370	dnl ***********************
		1371	dnl *** g_module checks ***
		1372	dnl ***********************
		1373	G_MODULE_LIBS=
		1374	G_MODULE_LIBS_EXTRA=
		1375	G_MODULE_PLUGIN_LIBS=
		1376	if test x"$glib_native_win32" = xyes; then
		1377	dnl No use for this on Win32
		1378	G_MODULE_LDFLAGS=
		1379	else
		1380	export SED
		1381	G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
		1382	fi
		1383	dnl G_MODULE_IMPL= don't reset, so cmd-line can override
		1384	G_MODULE_NEED_USCORE=0
		1385	G_MODULE_BROKEN_RTLD_GLOBAL=0
		1386	G_MODULE_HAVE_DLERROR=0
		1387	dnl *** force native WIN32 shared lib loader
		1388	if test -z "$G_MODULE_IMPL"; then
		1389	case "$host" in
		1390	*-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
		1391	esac
		1392	fi
		1393	dnl *** force native AIX library loader
		1394	dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
		1395	if test -z "$G_MODULE_IMPL"; then
		1396	case "$host" in
		1397	*-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
		1398	esac
		1399	fi
		1400	dnl *** dlopen() and dlsym() in system libraries
		1401	AS_IF([ test -z "$G_MODULE_IMPL"], [
		1402	AC_CHECK_FUNC(dlopen,
		1403	[AC_CHECK_FUNC(dlsym,
		1404	[G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
		1405	[])
		1406	])
		1407	dnl *** NSLinkModule (dyld) in system libraries (Darwin)
		1408	AS_IF([ test -z "$G_MODULE_IMPL" ], [
		1409	AC_CHECK_FUNC(NSLinkModule,
		1410	[G_MODULE_IMPL=G_MODULE_IMPL_DYLD
		1411	G_MODULE_NEED_USCORE=1],
		1412	[])
		1413	])
		1414	dnl *** dlopen() and dlsym() in libdl
		1415	AS_IF([ test -z "$G_MODULE_IMPL"], [
		1416	AC_CHECK_LIB(dl, dlopen,
		1417	[AC_CHECK_LIB(dl, dlsym,
		1418	[G_MODULE_LIBS=-ldl
		1419	G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
		1420	[])
		1421	])
		1422	dnl *** additional checks for G_MODULE_IMPL_DL
		1423	AS_IF([ test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL" ], [
		1424	LIBS_orig="$LIBS"
		1425	LDFLAGS_orig="$LDFLAGS"
		1426	LIBS="$G_MODULE_LIBS $LIBS"
		1427	LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
		1428	dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
		1429	echo "void glib_plugin_test(void) { }" > plugin.c
		1430	${SHELL} ./libtool --mode=compile --tag=CC ${CC} ${CFLAGS} \
		1431	${CPPFLAGS} -c -o plugin.lo plugin.c >/dev/null 2>&1
		1432	${SHELL} ./libtool --mode=link --tag=CC ${CC} ${CFLAGS} \
		1433	${LDFLAGS} -module -o plugin.la -export-dynamic \
		1434	-shrext ".o" -avoid-version plugin.lo \
		1435	-rpath /dont/care >/dev/null 2>&1
		1436	eval `./libtool --config | grep ^objdir`
		1437	AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
		1438	glib_cv_rtldglobal_broken,[
		1439	AC_TRY_RUN([
		1440	#include <dlfcn.h>
		1441	#ifndef RTLD_GLOBAL
		1442	# define RTLD_GLOBAL 0
		1443	#endif
		1444	#ifndef RTLD_LAZY
		1445	# define RTLD_LAZY 0
		1446	#endif
		1447	int glib_plugin_test;
		1448	int main () {
		1449	void *handle, *global, *local;
		1450	global = &glib_plugin_test;
		1451	handle = dlopen ("./$objdir/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
		1452	if (!handle) return 0;
		1453	local = dlsym (handle, "glib_plugin_test");
		1454	return global == local;
		1455	} ],
		1456	[glib_cv_rtldglobal_broken=no],
		1457	[glib_cv_rtldglobal_broken=yes],
		1458	[glib_cv_rtldglobal_broken=no])
		1459	rm -f plugin.c plugin.o plugin.lo plugin.la ${objdir}/plugin.*
		1460	rmdir ${objdir} 2>/dev/null
		1461	])
		1462	if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
		1463	G_MODULE_BROKEN_RTLD_GLOBAL=1
		1464	else
		1465	G_MODULE_BROKEN_RTLD_GLOBAL=0
		1466	fi
		1467	dnl *** check whether we need preceeding underscores
		1468	AC_CACHE_CHECK([for preceeding underscore in symbols],
		1469	glib_cv_uscore,[
		1470	AC_TRY_RUN([#include <dlfcn.h>
		1471	int glib_underscore_test (void) { return 42; }
		1472	int main() {
		1473	void *f1 = (void*)0, *f2 = (void*)0, *handle;
		1474	handle = dlopen ((void*)0, 0);
		1475	if (handle) {
		1476	f1 = dlsym (handle, "glib_underscore_test");
		1477	f2 = dlsym (handle, "_glib_underscore_test");
		1478	} return (!f2 || f1);
		1479	}],
		1480	[glib_cv_uscore=yes],
		1481	[glib_cv_uscore=no],
		1482	[])
		1483	rm -f plugin.c plugin.$ac_objext plugin.lo
		1484	])
		1485	GLIB_ASSERT_SET(glib_cv_uscore)
		1486	if test "x$glib_cv_uscore" = "xyes"; then
		1487	G_MODULE_NEED_USCORE=1
		1488	else
		1489	G_MODULE_NEED_USCORE=0
		1490	fi
		1491
		1492	LDFLAGS="$LDFLAGS_orig"
		1493	dnl *** check for having dlerror()
		1494	AC_CHECK_FUNC(dlerror,
		1495	[G_MODULE_HAVE_DLERROR=1],
		1496	[G_MODULE_HAVE_DLERROR=0])
		1497	LIBS="$LIBS_orig"
		1498	])
		1499	dnl *** done, have we got an implementation?
		1500	if test -z "$G_MODULE_IMPL"; then
		1501	G_MODULE_IMPL=0
		1502	G_MODULE_SUPPORTED=false
		1503	else
		1504	G_MODULE_SUPPORTED=true
		1505	fi
		1506
		1507	AC_MSG_CHECKING(for the suffix of module shared libraries)
		1508	export SED
		1509	shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
		1510	eval $shrext_cmds
		1511	module=yes eval std_shrext=$shrext_cmds
		1512	# chop the initial dot
		1513	glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
		1514	AC_MSG_RESULT(.$glib_gmodule_suffix)
		1515	# any reason it may fail?
		1516	if test "x$glib_gmodule_suffix" = x; then
		1517	AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
		1518	fi
		1519
		1520	AC_SUBST(G_MODULE_SUPPORTED)
		1521	AC_SUBST(G_MODULE_IMPL)
		1522	AC_SUBST(G_MODULE_LIBS)
		1523	AC_SUBST(G_MODULE_LIBS_EXTRA)
		1524	AC_SUBST(G_MODULE_PLUGIN_LIBS)
		1525	AC_SUBST(G_MODULE_LDFLAGS)
		1526	AC_SUBST(G_MODULE_HAVE_DLERROR)
		1527	AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
		1528	AC_SUBST(G_MODULE_NEED_USCORE)
		1529	AC_SUBST(GLIB_DEBUG_FLAGS)
		1530
		1531	dnl **********************
		1532	dnl *** g_spawn checks ***
		1533	dnl **********************
		1534
		1535	AC_MSG_CHECKING(for gspawn implementation)
		1536	case "$host" in
		1537	*-*-mingw*)
		1538	GSPAWN=gspawn-win32.lo
		1539	;;
		1540	*)
		1541	GSPAWN=gspawn.lo
		1542	;;
		1543	esac
		1544	AC_MSG_RESULT($GSPAWN)
		1545	AC_SUBST(GSPAWN)
		1546
		1547	dnl *************************
		1548	dnl *** GIOChannel checks ***
		1549	dnl *************************
		1550
		1551	AC_MSG_CHECKING(for GIOChannel implementation)
		1552	case "$host" in
		1553	*-*-mingw*)
		1554	GIO=giowin32.lo
		1555	;;
		1556	*)
		1557	GIO=giounix.lo
		1558	;;
		1559	esac
		1560	AC_MSG_RESULT($GIO)
		1561	AC_SUBST(GIO)
		1562
		1563	dnl *********************************
		1564	dnl *** Directory for GIO modules ***
		1565	dnl *********************************
		1566
		1567	AC_ARG_WITH(gio-module-dir,
		1568	[AS_HELP_STRING([--with-gio-module-dir=DIR],
		1569	[load gio modules from this directory [LIBDIR/gio/modules]])],
		1570	[],
		1571	[with_gio_module_dir='${libdir}/gio/modules'])
		1572	GIO_MODULE_DIR=$with_gio_module_dir
		1573	AC_SUBST(GIO_MODULE_DIR)
		1574
		1575	dnl **********************************
		1576	dnl *** Check for libselinux (GIO) ***
		1577	dnl **********************************
		1578	AC_ARG_ENABLE(selinux,
		1579	AS_HELP_STRING([--disable-selinux],
		1580	[build without selinux support]))
		1581	msg_selinux=no
		1582	SELINUX_LIBS=
		1583	AS_IF([ test "x$enable_selinux" != "xno"], [
		1584
		1585	AC_CHECK_LIB(selinux, is_selinux_enabled,
		1586	[AC_CHECK_HEADERS(selinux/selinux.h,
		1587	[AC_CHECK_LIB(selinux, lgetfilecon_raw,
		1588	[AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
		1589	SELINUX_LIBS="-lselinux"
		1590	msg_selinux=yes])
		1591	])
		1592	])
		1593	])
		1594	AC_SUBST(SELINUX_LIBS)
		1595
		1596	dnl *****************************
		1597	dnl ** Check for inotify (GIO) **
		1598	dnl *****************************
		1599	inotify_support=no
		1600	AC_CHECK_HEADERS([sys/inotify.h],
		1601	[
		1602	AC_CHECK_FUNCS(inotify_init1, [inotify_support=yes], [inotify_support=no])
		1603	])
		1604
		1605	AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
		1606
		1607	dnl ****************************
		1608	dnl ** Check for kqueue (GIO) **
		1609	dnl ****************************
		1610	kqueue_support=no
		1611	AC_CHECK_HEADERS([sys/event.h],
		1612	[
		1613	AC_CHECK_FUNCS(kqueue kevent, [kqueue_support=yes])
		1614	])
		1615
		1616	AM_CONDITIONAL(HAVE_KQUEUE, [test "$kqueue_support" = "yes"])
		1617
		1618	dnl ****************************
		1619	dnl *** Checks for FAM (GIO) ***
		1620	dnl ****************************
		1621
		1622	should_disable_fam=no
		1623
		1624	AC_ARG_ENABLE(fam,
		1625	AS_HELP_STRING([--disable-fam],
		1626	[don't use fam for file system monitoring]),
		1627	[
		1628	if test "x$enable_fam" = "xno"; then
		1629	should_disable_fam=yes
		1630	fi
		1631	]
		1632	)
		1633	fam_support=no
		1634	FAM_LIBS=
		1635	if test "x$should_disable_fam" = "xno"; then
		1636	AC_CHECK_LIB(fam, FAMOpen,
		1637	[AC_CHECK_HEADERS(fam.h,
		1638	[AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
		1639	AC_CHECK_LIB(fam, FAMNoExists,
		1640	AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
		1641	FAM_LIBS="-lfam"]
		1642	fam_support=yes,
		1643	AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
		1644	AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
		1645	AC_SUBST(FAM_LIBS)
		1646	fi
		1647	AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
		1648
		1649
		1650	dnl *****************************
		1651	dnl *** Check for xattr (GIO) ***
		1652	dnl *****************************
		1653	AC_ARG_ENABLE(xattr,
		1654	AS_HELP_STRING([--disable-xattr], [build without xattr support]))
		1655	msg_xattr=no
		1656	XATTR_LIBS=
		1657	AS_IF([ test "x$enable_xattr" != "xno"], [
		1658
		1659	dnl either glibc or libattr can provide xattr support
		1660
		1661	dnl for both of them, we check for getxattr being in
		1662	dnl the library and a valid xattr header.
		1663
		1664	dnl try glibc
		1665	AC_CHECK_LIB(c, getxattr,
		1666	[AC_CHECK_HEADERS(sys/xattr.h,
		1667	[AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
		1668	msg_xattr=yes])
		1669	])
		1670
		1671	AS_IF([ test "x$msg_xattr" != "xyes"], [
		1672	dnl failure. try libattr
		1673	AC_CHECK_LIB(attr, getxattr,
		1674	[AC_CHECK_HEADERS(attr/xattr.h,
		1675	[AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
		1676	XATTR_LIBS="-lattr"
		1677	msg_xattr=yes])
		1678	])
		1679	])
		1680
		1681	AS_IF([ test "x$msg_xattr" = "xyes"], [
		1682	AC_MSG_CHECKING([for XATTR_NOFOLLOW])
		1683	AC_TRY_COMPILE([
		1684	#include <stdio.h>
		1685	#ifdef HAVE_SYS_TYPES_H
		1686	#include <sys/types.h>
		1687	#endif
		1688	#ifdef HAVE_SYS_XATTR_H
		1689	#include <sys/xattr.h>
		1690	#elif HAVE_ATTR_XATTR_H
		1691	#include <attr/xattr.h>
		1692	#endif
		1693	],
		1694	[ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
		1695	[
		1696	AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
		1697	AC_MSG_RESULT([yes])
		1698	],
		1699	[AC_MSG_RESULT([no])]
		1700	)
		1701	])
		1702	])
		1703	AC_SUBST(XATTR_LIBS)
		1704
		1705	dnl ************************
		1706	dnl *** check for libelf ***
		1707	dnl ************************
		1708	AC_ARG_ENABLE(libelf,
		1709	AS_HELP_STRING([--disable-libelf], [build without libelf support]))
		1710	AS_IF([ test "x$enable_libelf" != "xno"],[
		1711	PKG_CHECK_MODULES([LIBELF], [libelf >= 0.8.12], [have_libelf=yes], [have_libelf=maybe])
		1712	AS_IF([ test $have_libelf = maybe ], [
		1713	glib_save_LIBS=$LIBS
		1714	AC_CHECK_LIB([elf], [elf_begin], [:], [have_libelf=no])
		1715	AC_CHECK_LIB([elf], [elf_getshdrstrndx], [:], [have_libelf=no])
		1716	AC_CHECK_LIB([elf], [elf_getshdrnum], [:], [have_libelf=no])
		1717	AC_CHECK_HEADER([libelf.h], [:], [have_libelf=no])
		1718	LIBS=$glib_save_LIBS
		1719
		1720	if test $have_libelf != no; then
		1721	LIBELF_LIBS=-lelf
		1722	have_libelf=yes
		1723	fi
		1724	])
		1725	])
		1726
		1727	if test x$have_libelf = xyes; then
		1728	AC_DEFINE(HAVE_LIBELF, 1, [Define if libelf is available])
		1729	fi
		1730
		1731	dnl ****************************************
		1732	dnl *** platform dependent source checks ***
		1733	dnl ****************************************
		1734
		1735	AC_MSG_CHECKING(for platform-dependent source)
		1736	case "$host" in
		1737	*-*-cygwin*|*-*-mingw*)
		1738	PLATFORMDEP=gwin32.lo
		1739	;;
		1740	*)
		1741	PLATFORMDEP=
		1742	;;
		1743	esac
		1744	AC_MSG_RESULT($PLATFORMDEP)
		1745	AC_SUBST(PLATFORMDEP)
		1746
		1747	AC_MSG_CHECKING([whether to compile timeloop])
		1748	case "$host" in
		1749	*-*-cygwin*|*-*-mingw*|*-*-minix)
		1750	enable_timeloop=no
		1751	;;
		1752	*)
		1753	enable_timeloop=yes
		1754	;;
		1755	esac
		1756	AC_MSG_RESULT($enable_timeloop)
		1757	AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
		1758
		1759	AC_MSG_CHECKING([if building for some Win32 platform])
		1760	case "$host" in
		1761	*-*-mingw*|*-*-cygwin*)
		1762	platform_win32=yes
		1763	;;
		1764	*)
		1765	platform_win32=no
		1766	;;
		1767	esac
		1768	AC_MSG_RESULT($platform_win32)
		1769	AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
		1770
		1771	dnl ***********************
		1772	dnl *** g_thread checks ***
		1773	dnl ***********************
		1774
		1775	AC_ARG_WITH(threads,
		1776	[AS_HELP_STRING([--with-threads=@<:@posix/win32@:>@],
		1777	[specify a thread implementation to use])],
		1778	[],
		1779	[with_threads=yes])
		1780
		1781	dnl error and warning message
		1782	dnl *************************
		1783
		1784	THREAD_NO_IMPLEMENTATION="No thread implementation found."
		1785
		1786	FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
		1787	platform (normally it's "_REENTRANT"). I'll not use any flag on
		1788	compilation now, but then your programs might not work.
		1789	Please provide information on how it is done on your system."
		1790
		1791	LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
		1792	"
		1793
		1794	LIBS_NOT_FOUND_2=". Please choose another thread implementation or
		1795	provide information on your thread implementation."
		1796
		1797	FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
		1798	functions will not be MT-safe during their first call because
		1799	there is no working 'getpwuid_r' on your system."
		1800
		1801	FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
		1802	because there is no 'localtime_r' on your system."
		1803
		1804	AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
		1805	linking threaded applications. As GLib cannot do that
		1806	automatically, you will get an linkg error everytime you are
		1807	not using the right compiler. In that case you have to relink
		1808	with the right compiler. Ususally just '_r' is appended
		1809	to the compiler name."
		1810
		1811	dnl determination of thread implementation
		1812	dnl ***************************************
		1813
		1814	AC_MSG_CHECKING(for thread implementation)
		1815
		1816	have_threads=no
		1817	AS_IF([ test "x$with_threads" = xyes || test "x$with_threads" = xposix], [
		1818	AS_IF([ test "x$have_threads" = xno], [
		1819	AC_TRY_COMPILE([#include <pthread.h>],
		1820	[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
		1821	have_threads=posix)
		1822	])
		1823	# Tru64Unix requires -pthread to find pthread.h. See #103020
		1824	if test "x$have_threads" = xno; then
		1825	glib_save_CPPFLAGS="$CPPFLAGS"
		1826	CPPFLAGS="$CPPFLAGS -pthread"
		1827	AC_TRY_COMPILE([#include <pthread.h>],
		1828	[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
		1829	have_threads=posix)
		1830	CPPFLAGS="$glib_save_CPPFLAGS"
		1831	fi
		1832	])
		1833	if test "x$with_threads" = xyes || test "x$with_threads" = xwin32; then
		1834	case $host in
		1835	*-*-mingw*)
		1836	have_threads=win32
		1837	;;
		1838	esac
		1839	fi
		1840
		1841	if test "x$have_threads" = xno; then
		1842	AC_MSG_RESULT(none available)
		1843	AC_MSG_ERROR($THREAD_NO_IMPLEMENTATION)
		1844	else
		1845	AC_MSG_RESULT($have_threads)
		1846	fi
		1847
		1848
		1849	dnl determination of G_THREAD_CFLAGS
		1850	dnl ********************************
		1851
		1852	G_THREAD_LIBS=
		1853	G_THREAD_LIBS_EXTRA=
		1854	G_THREAD_CFLAGS=
		1855
		1856	dnl
		1857	dnl Test program for basic POSIX threads functionality
		1858	dnl
		1859	m4_define([glib_thread_test],[
		1860	#include <pthread.h>
		1861	int check_me = 0;
		1862	void* func(void* data) {check_me = 42; return &check_me;}
		1863	int main()
		1864	{ pthread_t t;
		1865	void *ret;
		1866	pthread_create (&t, $1, func, 0);
		1867	pthread_join (t, &ret);
		1868	return (check_me != 42 || ret != &check_me);
		1869	}])
		1870
		1871	AS_IF([ test x"$have_threads" = xposix], [
		1872	# First we test for posix, whether -pthread or -pthreads do the trick as
		1873	# both CPPFLAG and LIBS.
		1874	# One of them does for most gcc versions and some other platforms/compilers
		1875	# too and could be considered as the canonical way to go.
		1876	case $host in
		1877	*-*-cygwin*|*-*-darwin*)
		1878	# skip cygwin and darwin -pthread or -pthreads test
		1879	;;
		1880	*-solaris*)
		1881	# These compiler/linker flags work with both Sun Studio and gcc
		1882	# Sun Studio expands -mt to -D_REENTRANT and -lthread
		1883	# gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
		1884	G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
		1885	G_THREAD_LIBS="-lpthread -lthread"
		1886	;;
		1887	*)
		1888	for flag in pthread pthreads mt; do
		1889	glib_save_CFLAGS="$CFLAGS"
		1890	CFLAGS="$CFLAGS -$flag"
		1891	AC_TRY_RUN(glib_thread_test(0),
		1892	glib_flag_works=yes,
		1893	glib_flag_works=no,
		1894	[AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test(0))],
		1895	glib_flag_works=yes,
		1896	glib_flag_works=no)])
		1897	CFLAGS="$glib_save_CFLAGS"
		1898	if test $glib_flag_works = yes ; then
		1899	G_THREAD_CFLAGS=-$flag
		1900	G_THREAD_LIBS=-$flag
		1901	break;
		1902	fi
		1903	done
		1904	;;
		1905	esac
		1906	])
		1907
		1908	AS_IF([ test x"$G_THREAD_CFLAGS" = x], [
		1909
		1910	# The canonical -pthread[s] does not work. Try something different.
		1911
		1912	case $host in
		1913	*-aix*)
		1914	if test x"$GCC" = xyes; then
		1915	# GCC 3.0 and above needs -pthread.
		1916	# Should be coverd by the case above.
		1917	# GCC 2.x and below needs -mthreads
		1918	G_THREAD_CFLAGS="-mthreads"
		1919	G_THREAD_LIBS=$G_THREAD_CFLAGS
		1920	else
		1921	# We are probably using the aix compiler. Normaly a
		1922	# program would have to be compiled with the _r variant
		1923	# of the corresponding compiler, but we as GLib cannot
		1924	# do that: but the good news is that for compiling the
		1925	# only difference is the added -D_THREAD_SAFE compile
		1926	# option. This is according to the "C for AIX User's
		1927	# Guide".
		1928	G_THREAD_CFLAGS="-D_THREAD_SAFE"
		1929	fi
		1930	;;
		1931	*-sysv5uw7*) # UnixWare 7
		1932	# We are not using gcc with -pthread. Catched above.
		1933	G_THREAD_CFLAGS="-Kthread"
		1934	G_THREAD_LIBS=$G_THREAD_CFLAGS
		1935	;;
		1936	*-mingw*)
		1937	# No flag needed when using MSVCRT.DLL
		1938	G_THREAD_CFLAGS=""
		1939	;;
		1940	*)
		1941	G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
		1942	;;
		1943	esac
		1944	])
		1945
		1946	# if we are not finding the localtime_r function, then we probably are
		1947	# not using the proper multithread flag
		1948
		1949	glib_save_CPPFLAGS="$CPPFLAGS"
		1950	CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
		1951
		1952	# First we test, whether localtime_r is declared in time.h
		1953	# directly. Then we test whether a macro localtime_r exists, in
		1954	# which case localtime_r in the test program is replaced and thus
		1955	# if we still find localtime_r in the output, it is not defined as
		1956	# a macro.
		1957
		1958	AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
		1959	[AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
		1960	localtime_r(a,b)],
		1961	AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
		1962
		1963	CPPFLAGS="$glib_save_CPPFLAGS"
		1964
		1965	AC_MSG_CHECKING(thread related cflags)
		1966	AC_MSG_RESULT($G_THREAD_CFLAGS)
		1967	CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
		1968
		1969	dnl determination of G_THREAD_LIBS
		1970	dnl ******************************
		1971
		1972	AS_IF([test x$have_threads = xposix], [
		1973	glib_save_CPPFLAGS="$CPPFLAGS"
		1974	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
		1975	AS_IF([ test x"$G_THREAD_LIBS" = x ], [
		1976	case $host in
		1977	*-aix*)
		1978	# We are not using gcc (would have set G_THREAD_LIBS) and thus
		1979	# probably using the aix compiler.
		1980	AC_MSG_WARN($AIX_COMPILE_INFO)
		1981	;;
		1982	*)
		1983	G_THREAD_LIBS=error
		1984	glib_save_LIBS="$LIBS"
		1985	for thread_lib in "" pthread pthread32 pthreads thread; do
		1986	if test x"$thread_lib" = x; then
		1987	add_thread_lib=""
		1988	IN=""
		1989	else
		1990	add_thread_lib="-l$thread_lib"
		1991	IN=" in -l$thread_lib"
		1992	fi
		1993	if test x"$have_threads" = xposix; then
		1994	defattr=0
		1995	else
		1996	defattr=pthread_attr_default
		1997	fi
		1998
		1999	LIBS="$add_thread_lib $glib_save_LIBS"
		2000
		2001	AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
		2002	AC_TRY_RUN(glib_thread_test($defattr),
		2003	glib_result=yes,
		2004	glib_result=no,
		2005	[AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test($defattr))],
		2006	glib_result=yes,
		2007	glib_result=no)])
		2008	AC_MSG_RESULT($glib_result)
		2009
		2010	if test "$glib_result" = "yes" ; then
		2011	G_THREAD_LIBS="$add_thread_lib"
		2012	break
		2013	fi
		2014	done
		2015	if test "x$G_THREAD_LIBS" = xerror; then
		2016	AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
		2017	fi
		2018	LIBS="$glib_save_LIBS"
		2019	;;
		2020	esac
		2021	])
		2022
		2023	g_threads_impl="POSIX"
		2024	AC_DEFINE([THREADS_POSIX], [1], [Use pthreads])
		2025	AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
		2026	CPPFLAGS="$glib_save_CPPFLAGS"
		2027	], [test x$have_threads = xwin32], [
		2028	AC_DEFINE([THREADS_WIN32], [1], [Use w32 threads])
		2029	g_threads_impl="WIN32"
		2030	], [
		2031	AC_DEFINE([THREADS_NONE], [1], [Use no threads])
		2032	g_threads_impl="NONE"
		2033	G_THREAD_LIBS=error
		2034	])
		2035	AM_CONDITIONAL(THREADS_POSIX, [test "$g_threads_impl" = "POSIX"])
		2036	AM_CONDITIONAL(THREADS_WIN32, [test "$g_threads_impl" = "WIN32"])
		2037	AM_CONDITIONAL(THREADS_NONE, [test "$g_threads_impl" = "NONE"])
		2038
		2039	if test "x$G_THREAD_LIBS" = xerror; then
		2040	AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
		2041	fi
		2042
		2043	AC_MSG_CHECKING(thread related libraries)
		2044	AC_MSG_RESULT($G_THREAD_LIBS)
		2045
		2046	dnl check for mt safe function variants and some posix functions
		2047	dnl ************************************************************
		2048
		2049	glib_save_LIBS="$LIBS"
		2050	# we are not doing the following for now, as this might require glib
		2051	# to always be linked with the thread libs on some platforms.
		2052	# LIBS="$LIBS $G_THREAD_LIBS"
		2053	AC_CHECK_FUNCS(localtime_r gmtime_r getpwuid_r getgrgid_r)
		2054
		2055	LIBS="$G_THREAD_LIBS $LIBS"
		2056	AS_IF([ test x"$have_threads" = xposix], [
		2057	glib_save_CPPFLAGS="$CPPFLAGS"
		2058	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
		2059	# This is not AC_CHECK_FUNC to also work with function
		2060	# name mangling in header files.
		2061	AC_MSG_CHECKING(for pthread_attr_setstacksize)
		2062	AC_LINK_IFELSE(
		2063	[AC_LANG_PROGRAM(
		2064	[#include <pthread.h>],
		2065	[pthread_attr_t t; pthread_attr_setstacksize(&t,0)])],
		2066	[AC_MSG_RESULT(yes)
		2067	AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
		2068	[Have function pthread_attr_setstacksize])],
		2069	[AC_MSG_RESULT(no)])
		2070	AC_MSG_CHECKING(for pthread_condattr_setclock)
		2071	AC_LINK_IFELSE(
		2072	[AC_LANG_PROGRAM(
		2073	[#include <pthread.h>],
		2074	[pthread_condattr_t a; pthread_condattr_setclock(&a,0)])],
		2075	[AC_MSG_RESULT(yes)
		2076	AC_DEFINE(HAVE_PTHREAD_CONDATTR_SETCLOCK,1,
		2077	[Have function pthread_condattr_setclock])],
		2078	[AC_MSG_RESULT(no)])
		2079	AC_MSG_CHECKING(for pthread_cond_timedwait_relative_np)
		2080	AC_LINK_IFELSE(
		2081	[AC_LANG_PROGRAM(
		2082	[#include <pthread.h>],
		2083	[pthread_cond_timedwait_relative_np(NULL, NULL, NULL)])],
		2084	[AC_MSG_RESULT(yes)
		2085	AC_DEFINE(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP,1,
		2086	[Have function pthread_cond_timedwait_relative_np])],
		2087	[AC_MSG_RESULT(no)])
		2088	dnl Sets thread names on OS X 10.6, iOS 3.2 (and higher)
		2089	AC_MSG_CHECKING(for pthread_setname_np(const char*))
		2090	AC_LINK_IFELSE(
		2091	[AC_LANG_PROGRAM(
		2092	[#include <pthread.h>],
		2093	[pthread_setname_np("example")])],
		2094	[AC_MSG_RESULT(yes)
		2095	AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID,1,
		2096	[Have function pthread_setname_np(const char*)])],
		2097	[AC_MSG_RESULT(no)])
		2098	dnl Sets thread names on Solaris 11.3 & higher
		2099	AC_MSG_CHECKING(for pthread_setname_np(pthread_t, const char*))
		2100	AC_LINK_IFELSE(
		2101	[AC_LANG_PROGRAM(
		2102	[#include <pthread.h>],
		2103	[pthread_setname_np(pthread_self(), "example")])],
		2104	[AC_MSG_RESULT(yes)
		2105	AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_WITH_TID,1,
		2106	[Have function pthread_setname_np(pthread_t, const char*)])],
		2107	[AC_MSG_RESULT(no)])
		2108	CPPFLAGS="$glib_save_CPPFLAGS"
		2109	])
		2110
		2111	LIBS="$glib_save_LIBS"
		2112
		2113	# now spit out all the warnings.
		2114	if test "$ac_cv_func_getpwuid_r" != "yes"; then
		2115	AC_MSG_WARN($FUNC_NO_GETPWUID_R)
		2116	fi
		2117	if test "$ac_cv_func_localtime_r" != "yes"; then
		2118	AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
		2119	fi
		2120
		2121	#
		2122	# Hack to deal with:
		2123	#
		2124	# a) GCC < 3.3 for Linux doesn't include -lpthread when
		2125	# building shared libraries with linux.
		2126	# b) FreeBSD doesn't do this either.
		2127	#
		2128	case $host in
		2129	*android*)
		2130	G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
		2131	;;
		2132	*-*-freebsd*|*-*-linux*)
		2133	G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
		2134	;;
		2135	*)
		2136	G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
		2137	;;
		2138	esac
		2139
		2140	AC_SUBST(G_THREAD_CFLAGS)
		2141	AC_SUBST(G_THREAD_LIBS)
		2142	AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
		2143	AC_SUBST(G_THREAD_LIBS_EXTRA)
		2144
		2145	AC_CHECK_FUNCS(clock_gettime, [], [
		2146	AC_CHECK_LIB(rt, clock_gettime, [
		2147	G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
		2148	G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
		2149	])
		2150	])
		2151
		2152
		2153	dnl ************************
		2154	dnl *** g_atomic_* tests ***
		2155	dnl ************************
		2156
		2157	dnl We need to decide at configure time if GLib will use real atomic
		2158	dnl operations ("lock free") or emulated ones with a mutex. This is
		2159	dnl because we must put this information in glibconfig.h so we know if
		2160	dnl it is safe or not to inline using compiler intrinsics directly from
		2161	dnl the header.
		2162	dnl
		2163	dnl We also publish the information via G_ATOMIC_LOCK_FREE in case the
		2164	dnl user is interested in knowing if they can use the atomic ops across
		2165	dnl processes.
		2166	dnl
		2167	dnl We can currently support the atomic ops natively when building GLib
		2168	dnl with recent versions of GCC or MSVC. MSVC doesn't run ./configure,
		2169	dnl so we skip that case here and define G_ATOMIC_LOCK_FREE exactly when
		2170	dnl we are using GCC (and not mingw*).
		2171	dnl
		2172	dnl Note that the atomic ops are only available with GCC on x86 when
		2173	dnl using -march=i486 or higher. If we detect that the atomic ops are
		2174	dnl not available but would be available given the right flags, we want
		2175	dnl to abort and advise the user to fix their CFLAGS. It's better to do
		2176	dnl that then to silently fall back on emulated atomic ops just because
		2177	dnl the user had the wrong build environment.
		2178
		2179	dnl We may add other compilers here in the future...
		2180
		2181	AC_CACHE_CHECK([for lock-free atomic intrinsics], glib_cv_g_atomic_lock_free, [
		2182	case $host in
		2183	*-*-mingw*)
		2184	glib_cv_g_atomic_lock_free=yes
		2185	;;
		2186	*)
		2187	AC_TRY_LINK([],
		2188	[volatile int atomic = 2;\
		2189	__sync_bool_compare_and_swap (&atomic, 2, 3);],
		2190	[glib_cv_g_atomic_lock_free=yes],
		2191	[glib_cv_g_atomic_lock_free=no])
		2192	if test "$glib_cv_g_atomic_lock_free" = "no"; then
		2193	SAVE_CFLAGS="${CFLAGS}"
		2194	CFLAGS="-march=i486"
		2195	AC_TRY_LINK([],
		2196	[volatile int atomic = 2;\
		2197	__sync_bool_compare_and_swap (&atomic, 2, 3);],
		2198	[AC_MSG_ERROR([GLib must be build with -march=i486 or later.])],
		2199	[])
		2200	CFLAGS="${SAVE_CFLAGS}"
		2201	fi
		2202	;;
		2203	esac])
		2204
		2205
		2206	case $host in
		2207	*-*-mingw*)
		2208	;;
		2209	*)
		2210	# Some compilers support atomic operations but do not define
		2211	# __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4, like clang
		2212	if test x"$glib_cv_g_atomic_lock_free" = xyes; then
		2213	AC_TRY_LINK([],
		2214	[__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4;],
		2215	[],
		2216	[AC_DEFINE(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4, 1, [ compiler supports atomic operations])])
		2217	fi
		2218	;;
		2219	esac
		2220
		2221	dnl We need a more robust approach here...
		2222	case $host_cpu in
		2223	i?86|x86_64|s390|s390x|arm*|crisv32*|etrax*)
		2224	glib_memory_barrier_needed=no
		2225	;;
		2226	sparc*|alpha*|powerpc*|ia64)
		2227	glib_memory_barrier_needed=yes
		2228	;;
		2229	*)
		2230	glib_memory_barrier_needed=yes
		2231	;;
		2232	esac
		2233
		2234	dnl ************************
		2235	dnl ** Check for futex(2) **
		2236	dnl ************************
		2237	AC_CACHE_CHECK(for futex(2) system call,
		2238	glib_cv_futex,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		2239	#include <linux/futex.h>
		2240	#include <sys/syscall.h>
		2241	#include <unistd.h>
		2242	],[
		2243	syscall (__NR_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
		2244	])],glib_cv_futex=yes,glib_cv_futex=no))
		2245	if test x"$glib_cv_futex" = xyes; then
		2246	AC_DEFINE(HAVE_FUTEX, 1, [we have the futex(2) system call])
		2247	fi
		2248
		2249	AC_CACHE_CHECK(for eventfd(2) system call,
		2250	glib_cv_eventfd,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		2251	#include <sys/eventfd.h>
		2252	#include <unistd.h>
		2253	],[
		2254	eventfd (0, EFD_CLOEXEC);
		2255	])],glib_cv_eventfd=yes,glib_cv_eventfd=no))
		2256	if test x"$glib_cv_eventfd" = x"yes"; then
		2257	AC_DEFINE(HAVE_EVENTFD, 1, [we have the eventfd(2) system call])
		2258	fi
		2259	AM_CONDITIONAL(HAVE_EVENTFD, [test "$glib_cv_eventfd" = "yes"])
		2260
		2261	dnl ****************************************
		2262	dnl *** GLib POLL* compatibility defines ***
		2263	dnl ****************************************
		2264
		2265	glib_poll_includes=["
		2266	#include <sys/types.h>
		2267	#include <poll.h>
		2268	"]
		2269
		2270	AS_IF([ test $ac_cv_header_sys_types_h = yes &&
		2271	test $ac_cv_func_poll = yes ], [
		2272	glib_failed=false
		2273	GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
		2274	GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
		2275	GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
		2276	GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
		2277	GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
		2278	GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
		2279	if $glib_failed ; then
		2280	AC_MSG_ERROR([Could not determine values for POLL* constants])
		2281	fi
		2282	], [
		2283	glib_cv_value_POLLIN=1
		2284	glib_cv_value_POLLOUT=4
		2285	glib_cv_value_POLLPRI=2
		2286	glib_cv_value_POLLERR=8
		2287	glib_cv_value_POLLHUP=16
		2288	glib_cv_value_POLLNVAL=32
		2289	])
		2290
		2291	AC_MSG_CHECKING([for broken poll])
		2292	AC_RUN_IFELSE([AC_LANG_SOURCE([[
		2293	#include <stdlib.h>
		2294	#include <fcntl.h>
		2295	#include <poll.h>
		2296	int main(void) {
		2297	struct pollfd fds[1];
		2298	int fd;
		2299	fd = open("/dev/null", 1);
		2300	fds[0].fd = fd;
		2301	fds[0].events = POLLIN;
		2302	fds[0].revents = 0;
		2303	if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
		2304	exit(1); /* Does not work for devices -- fail */
		2305	}
		2306	exit(0);
		2307	}]])],
		2308	[broken_poll=no],
		2309	[broken_poll=yes
		2310	AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
		2311	[broken_poll="no (cross compiling)"])
		2312	AC_MSG_RESULT($broken_poll)
		2313
		2314	dnl *********************
		2315	dnl *** GRegex checks ***
		2316	dnl *********************
		2317
		2318	PCRE_REQUIRED_VERSION=8.13
		2319
		2320	# Check if we should use the internal or the system-supplied pcre
		2321	AC_ARG_WITH(pcre,
		2322	[AS_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
		2323	[whether to use system PCRE [default=system]])],
		2324	[],
		2325	[with_pcre=system])
		2326
		2327	AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
		2328
		2329	AS_IF([ test "x$with_pcre" = xsystem], [
		2330	PKG_CHECK_MODULES(PCRE,
		2331	libpcre >= $PCRE_REQUIRED_VERSION)
		2332	AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
		2333	glib_save_CFLAGS="$CFLAGS"
		2334	glib_save_LIBS="$LIBS"
		2335	CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
		2336	AC_TRY_RUN([#include <pcre.h>
		2337	int main () {
		2338	int support;
		2339	pcre_config (PCRE_CONFIG_UTF8, &support);
		2340	if (!support)
		2341	return 1;
		2342	pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
		2343	if (!support)
		2344	return 1;
		2345	return 0;
		2346	}],
		2347	glib_cv_pcre_has_unicode=yes,
		2348	glib_cv_pcre_has_unicode=no,
		2349	glib_cv_pcre_has_unicode=yes)
		2350	CFLAGS="$glib_save_CFLAGS"
		2351	LIBS="$glib_save_LIBS"
		2352	])
		2353	if test "$glib_cv_pcre_has_unicode" = "no"; then
		2354	AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
		2355	fi
		2356	AC_SUBST(PCRE_CFLAGS)
		2357	AC_SUBST(PCRE_LIBS)
		2358	AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
		2359	PCRE_REQUIRES=libpcre
		2360	AC_SUBST(PCRE_REQUIRES)
		2361	], [
		2362	# If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
		2363	AS_IF([ test x"$GCC" = xyes], [
		2364	AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
		2365	save_CFLAGS="$CFLAGS"
		2366	CFLAGS="$CFLAGS -Wno-pointer-sign"
		2367	AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
		2368	AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
		2369	CFLAGS="$save_CFLAGS"
		2370	])
		2371	])
		2372	AC_SUBST(PCRE_WARN_CFLAGS)
		2373
		2374	dnl **********************
		2375	dnl *** Win32 API libs ***
		2376	dnl **********************
		2377
		2378	case $host in
		2379	*-*-cygwin*)
		2380	G_LIBS_EXTRA="-luser32 -lkernel32"
		2381	;;
		2382	*-*-mingw*)
		2383	G_LIBS_EXTRA="-lws2_32 -lole32 -lwinmm -lshlwapi"
		2384	;;
		2385	*)
		2386	G_LIBS_EXTRA=""
		2387	;;
		2388	esac
		2389	AC_SUBST(G_LIBS_EXTRA)
		2390
		2391	dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
		2392	dnl since we need it for g_iconv()
		2393
		2394	AC_MSG_CHECKING([for EILSEQ])
		2395	AC_TRY_COMPILE([
		2396	#include <errno.h>
		2397	],
		2398	[
		2399	int error = EILSEQ;
		2400	], have_eilseq=yes, have_eilseq=no);
		2401	AC_MSG_RESULT($have_eilseq)
		2402
		2403	dnl Add a conditional we can use when cross-compiling, so we avoid running
		2404	dnl binaries
		2405	AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
		2406
		2407	dnl **************************
		2408	dnl *** Checks for gtk-doc ***
		2409	dnl **************************
		2410	# gtkdocize greps for ^GTK_DOC_CHECK and parses it, so you need to have
		2411	# it on it's own line.
		2412	m4_ifdef([GTK_DOC_CHECK], [
		2413	GTK_DOC_CHECK([1.20], [--flavour no-tmpl])
		2414	],[
		2415	AM_CONDITIONAL([ENABLE_GTK_DOC],[false])
		2416	])
		2417
		2418	AC_ARG_ENABLE(man,
		2419	[AS_HELP_STRING([--enable-man],
		2420	[generate man pages [default=auto]])],,
		2421	enable_man=maybe)
		2422
		2423	AS_IF([test "$enable_man" != no], [
		2424	AC_PATH_PROG([XSLTPROC], [xsltproc])
		2425	AS_IF([test -z "$XSLTPROC"], [
		2426	AS_IF([test "$enable_man" = yes], [
		2427	AC_MSG_ERROR([xsltproc is required for --enable-man])
		2428	])
		2429	enable_man=no
		2430	])
		2431	])
		2432
		2433	AS_IF([ test "$enable_man" != no ], [
		2434	dnl check for DocBook DTD in the local catalog
		2435	JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
		2436	[DocBook XML DTD V4.1.2], [have_docbook_dtd=yes], [have_docbook_dtd=no])
		2437	AS_IF([test "$have_docbook_dtd" != yes], [
		2438	AS_IF([test "$enable_man" = yes ], [
		2439	AC_MSG_ERROR([DocBook DTD is required for --enable-man])
		2440	])
		2441	enable_man=no
		2442	])
		2443	])
		2444
		2445	AS_IF([test "$enable_man" != no], [
		2446	dnl check for DocBook XSL stylesheets in the local catalog
		2447	JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
		2448	[DocBook XSL Stylesheets], [have_docbook_style=yes],[have_docbook_style=no])
		2449	AS_IF([ test "$have_docbook_style" != yes ], [
		2450	AS_IF([ test "$enable_man" = yes ], [
		2451	AC_MSG_ERROR([DocBook XSL Stylesheets are required for --enable-man])
		2452	])
		2453	enable_man=no
		2454	])
		2455	])
		2456
		2457	AM_CONDITIONAL(ENABLE_MAN, test "$enable_man" != no)
		2458
		2459	AC_MSG_CHECKING([whether to generate man pages])
		2460	AS_IF([ test "$enable_man" != no ], [
		2461	AC_MSG_RESULT([yes])
		2462	], [
		2463	AC_MSG_RESULT([no])
		2464	])
		2465
		2466	dnl
		2467	dnl Tracing
		2468	dnl
		2469
		2470	AC_ARG_ENABLE([dtrace],
		2471	[AS_HELP_STRING([--enable-dtrace],
		2472	[include tracing support for dtrace])])
		2473	have_dtrace=no
		2474	AC_MSG_CHECKING([whether to include dtrace tracing support])
		2475	AS_IF([ test "x$enable_dtrace" != xno], [
		2476	if test x$glib_have_carbon = xyes; then
		2477	AC_MSG_RESULT([no (not yet compatible with MacOS dtrace)])
		2478	else
		2479	AC_MSG_RESULT([yes])
		2480	AC_CHECK_PROGS(DTRACE, dtrace)
		2481	if test -z "$DTRACE"; then
		2482	if test "x$enable_dtrace" = xyes; then
		2483	AC_MSG_ERROR([dtrace not found])
		2484	fi
		2485	else
		2486	AC_CHECK_HEADER([sys/sdt.h],have_dtrace=yes,
		2487	[if test "x$enable_dtrace" = xyes; then
		2488	AC_MSG_ERROR([dtrace support needs sys/sdt.h header])
		2489	fi])
		2490	fi
		2491	fi
		2492	], [
		2493	AC_MSG_RESULT([no])
		2494	])
		2495	if test "x$have_dtrace" = xyes; then
		2496	AC_DEFINE([HAVE_DTRACE], [1], [Define to 1 if using dtrace probes.])
		2497	fi
		2498	AM_CONDITIONAL([ENABLE_DTRACE], [test x$have_dtrace = xyes ])
		2499
		2500	AC_MSG_CHECKING([whether to include systemtap tracing support])
		2501	AC_ARG_ENABLE([systemtap],
		2502	[AS_HELP_STRING([--enable-systemtap],
		2503	[include tracing support for systemtap])])
		2504	have_systemtap=no
		2505	if test "x$enable_systemtap" != xno -a "x$have_dtrace" = xyes; then
		2506	have_systemtap=yes
		2507	fi
		2508	AC_MSG_RESULT(${have_systemtap})
		2509
		2510	AM_CONDITIONAL([ENABLE_SYSTEMTAP], [test x$have_systemtap = xyes])
		2511
		2512	AC_ARG_WITH([tapset-install-dir],
		2513	AS_HELP_STRING([--with-tapset-install-dir=DIR],
		2514	[path where systemtap tapsets are installed [DATADIR/systemtap/tapset]]),
		2515	[if test "x${withval}" = x; then
		2516	ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"
		2517	else
		2518	ABS_TAPSET_DIR="${withval}"
		2519	fi],
		2520	[ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"])
		2521	AC_SUBST(ABS_TAPSET_DIR)
		2522
		2523	dnl ************************************
		2524	dnl *** Enable lcov coverage reports ***
		2525	dnl ************************************
		2526
		2527	AC_ARG_ENABLE(coverage,
		2528	AS_HELP_STRING([--enable-coverage],
		2529	[enable coverage testing with gcov]),
		2530	[use_gcov=$enableval], [use_gcov=no])
		2531
		2532	AS_IF([ test "x$use_gcov" = "xyes"], [
		2533	dnl we need gcc:
		2534	if test "$GCC" != "yes"; then
		2535	AC_MSG_ERROR([GCC is required for --enable-coverage])
		2536	fi
		2537
		2538	dnl Check if ccache is being used
		2539	AC_CHECK_PROG(SHTOOL, shtool, shtool)
		2540	case `$SHTOOL path $CC` in
		2541	*ccache*[)] gcc_ccache=yes;;
		2542	*[)] gcc_ccache=no;;
		2543	esac
		2544
		2545	if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
		2546	AC_MSG_ERROR([ccache must be disabled when --enable-coverage option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
		2547	fi
		2548
		2549	ltp_version_list="1.6 1.7 1.8 1.9 1.10"
		2550	AC_CHECK_PROG(LTP, lcov, lcov)
		2551	AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
		2552
		2553	AS_IF([ test "$LTP" ], [
		2554	AC_CACHE_CHECK([for ltp version], glib_cv_ltp_version, [
		2555	glib_cv_ltp_version=invalid
		2556	ltp_version=`$LTP -v 2>/dev/null | $SED -e 's/^.* //'`
		2557	for ltp_check_version in $ltp_version_list; do
		2558	if test "$ltp_version" = "$ltp_check_version"; then
		2559	glib_cv_ltp_version="$ltp_check_version (ok)"
		2560	fi
		2561	done
		2562	])
		2563	], [
		2564	ltp_msg="To enable code coverage reporting you must have one of the following LTP versions installed: $ltp_version_list"
		2565	AC_MSG_ERROR([$ltp_msg])
		2566	])
		2567
		2568	case $glib_cv_ltp_version in
		2569	""|invalid[)]
		2570	ltp_msg="You must have one of the following versions of LTP: $ltp_version_list (found: $ltp_version)."
		2571	AC_MSG_ERROR([$ltp_msg])
		2572	LTP="exit 0;"
		2573	;;
		2574	esac
		2575
		2576	if test -z "$LTP_GENHTML"; then
		2577	AC_MSG_ERROR([Could not find genhtml from the LTP package])
		2578	fi
		2579
		2580	dnl Remove all optimization flags from CFLAGS
		2581	changequote({,})
		2582	CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
		2583	changequote([,])
		2584
		2585	dnl Add the special gcc flags
		2586	CFLAGS="$CFLAGS -O0 -fprofile-arcs -ftest-coverage"
		2587	LDFLAGS="$LDFLAGS -lgcov"
		2588	])
		2589
		2590	dnl ******************************
		2591	dnl *** output the whole stuff ***
		2592	dnl ******************************
		2593
		2594	dnl this section will only be run if config.status is invoked with no
		2595	dnl arguments, or with "glib/glibconfig.h" as an argument.
		2596	AC_CONFIG_COMMANDS([glib/glibconfig.h],
		2597	[
		2598	outfile=glib/glibconfig.h-tmp
		2599	cat > $outfile <<\_______EOF
		2600	/* glibconfig.h
		2601	*
		2602	* This is a generated file. Please modify 'configure.ac'
		2603	*/
		2604
		2605	#ifndef __GLIBCONFIG_H__
		2606	#define __GLIBCONFIG_H__
		2607
		2608	#include <glib/gmacros.h>
		2609
		2610	_______EOF
		2611
		2612	echo '#include <limits.h>' >> $outfile
		2613	echo '#include <float.h>' >> $outfile
		2614	if test x$glib_values_h = xyes; then
		2615	echo '#include <values.h>' >> $outfile
		2616	fi
		2617	if test "$glib_header_alloca_h" = "yes"; then
		2618	echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
		2619	fi
		2620	if test x$glib_included_printf != xyes; then
		2621	echo "
		2622	/* Specifies that GLib's g_print*() functions wrap the
		2623	* system printf functions. This is useful to know, for example,
		2624	* when using glibc's register_printf_function().
		2625	*/" >> $outfile
		2626	echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
		2627	fi
		2628
		2629	cat >> $outfile <<_______EOF
		2630
		2631	G_BEGIN_DECLS
		2632
		2633	#define G_MINFLOAT FLT_MIN
		2634	#define G_MAXFLOAT FLT_MAX
		2635	#define G_MINDOUBLE DBL_MIN
		2636	#define G_MAXDOUBLE DBL_MAX
		2637	#define G_MINSHORT SHRT_MIN
		2638	#define G_MAXSHORT SHRT_MAX
		2639	#define G_MAXUSHORT USHRT_MAX
		2640	#define G_MININT INT_MIN
		2641	#define G_MAXINT INT_MAX
		2642	#define G_MAXUINT UINT_MAX
		2643	#define G_MINLONG LONG_MIN
		2644	#define G_MAXLONG LONG_MAX
		2645	#define G_MAXULONG ULONG_MAX
		2646
		2647	_______EOF
		2648
		2649
		2650	### this should always be true in a modern C/C++ compiler
		2651	### and is statically asserted by glib-init.c
		2652	cat >>$outfile <<_______EOF
		2653	typedef signed char gint8;
		2654	typedef unsigned char guint8;
		2655	_______EOF
		2656
		2657
		2658	if test -n "$gint16"; then
		2659	cat >>$outfile <<_______EOF
		2660	typedef signed $gint16 gint16;
		2661	typedef unsigned $gint16 guint16;
		2662	#define G_GINT16_MODIFIER $gint16_modifier
		2663	#define G_GINT16_FORMAT $gint16_format
		2664	#define G_GUINT16_FORMAT $guint16_format
		2665	_______EOF
		2666	fi
		2667
		2668
		2669	if test -n "$gint32"; then
		2670	cat >>$outfile <<_______EOF
		2671	typedef signed $gint32 gint32;
		2672	typedef unsigned $gint32 guint32;
		2673	#define G_GINT32_MODIFIER $gint32_modifier
		2674	#define G_GINT32_FORMAT $gint32_format
		2675	#define G_GUINT32_FORMAT $guint32_format
		2676	_______EOF
		2677	fi
		2678
		2679	cat >>$outfile <<_______EOF
		2680	#define G_HAVE_GINT64 1 /* deprecated, always true */
		2681
		2682	${glib_extension}typedef signed $gint64 gint64;
		2683	${glib_extension}typedef unsigned $gint64 guint64;
		2684
		2685	#define G_GINT64_CONSTANT(val) $gint64_constant
		2686	#define G_GUINT64_CONSTANT(val) $guint64_constant
		2687	_______EOF
		2688
		2689	if test x$gint64_format != x ; then
		2690	cat >>$outfile <<_______EOF
		2691	#define G_GINT64_MODIFIER $gint64_modifier
		2692	#define G_GINT64_FORMAT $gint64_format
		2693	#define G_GUINT64_FORMAT $guint64_format
		2694	_______EOF
		2695	else
		2696	cat >>$outfile <<_______EOF
		2697	#undef G_GINT64_MODIFIER
		2698	#undef G_GINT64_FORMAT
		2699	#undef G_GUINT64_FORMAT
		2700	_______EOF
		2701	fi
		2702
		2703	cat >>$outfile <<_______EOF
		2704
		2705	#define GLIB_SIZEOF_VOID_P $glib_void_p
		2706	#define GLIB_SIZEOF_LONG $glib_long
		2707	#define GLIB_SIZEOF_SIZE_T $glib_size_t
		2708	#define GLIB_SIZEOF_SSIZE_T $glib_ssize_t
		2709
		2710	_______EOF
		2711
		2712	cat >>$outfile <<_______EOF
		2713	typedef signed $glib_ssize_type_define gssize;
		2714	typedef unsigned $glib_size_type_define gsize;
		2715	#define G_GSIZE_MODIFIER $gsize_modifier
		2716	#define G_GSSIZE_MODIFIER $gssize_modifier
		2717	#define G_GSIZE_FORMAT $gsize_format
		2718	#define G_GSSIZE_FORMAT $gssize_format
		2719
		2720	#define G_MAXSIZE G_MAXU$glib_msize_type
		2721	#define G_MINSSIZE G_MIN$glib_mssize_type
		2722	#define G_MAXSSIZE G_MAX$glib_mssize_type
		2723
		2724	typedef gint64 goffset;
		2725	#define G_MINOFFSET G_MININT64
		2726	#define G_MAXOFFSET G_MAXINT64
		2727
		2728	#define G_GOFFSET_MODIFIER G_GINT64_MODIFIER
		2729	#define G_GOFFSET_FORMAT G_GINT64_FORMAT
		2730	#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
		2731
		2732	#define G_POLLFD_FORMAT $g_pollfd_format
		2733
		2734	_______EOF
		2735
		2736	if test -z "$glib_unknown_void_p"; then
		2737	cat >>$outfile <<_______EOF
		2738
		2739	#define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
		2740	#define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
		2741
		2742	#define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
		2743	#define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
		2744
		2745	typedef signed $glib_intptr_type_define gintptr;
		2746	typedef unsigned $glib_intptr_type_define guintptr;
		2747
		2748	#define G_GINTPTR_MODIFIER $gintptr_modifier
		2749	#define G_GINTPTR_FORMAT $gintptr_format
		2750	#define G_GUINTPTR_FORMAT $guintptr_format
		2751	_______EOF
		2752	else
		2753	echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
		2754	fi
		2755
		2756
		2757
		2758	cat >>$outfile <<_______EOF
		2759	#ifndef G_DISABLE_DEPRECATED
		2760	#define g_ATEXIT(proc) (atexit (proc))
		2761	#define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END
		2762	#endif
		2763	$glib_defines
		2764	$glib_os
		2765	$glib_static_compilation
		2766
		2767	$glib_vacopy
		2768
		2769	_______EOF
		2770
		2771	if test x$g_have_iso_c_varargs = xyes ; then
		2772	cat >>$outfile <<_______EOF
		2773	#ifndef __cplusplus
		2774	# define G_HAVE_ISO_VARARGS 1
		2775	#endif
		2776	_______EOF
		2777	fi
		2778	if test x$g_have_iso_cxx_varargs = xyes ; then
		2779	cat >>$outfile <<_______EOF
		2780	#ifdef __cplusplus
		2781	# define G_HAVE_ISO_VARARGS 1
		2782	#endif
		2783	_______EOF
		2784	fi
		2785	if test x$g_have_gnuc_varargs = xyes ; then
		2786	cat >>$outfile <<_______EOF
		2787
		2788	/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
		2789	* is passed ISO vararg support is turned off, and there is no work
		2790	* around to turn it on, so we unconditionally turn it off.
		2791	*/
		2792	#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
		2793	# undef G_HAVE_ISO_VARARGS
		2794	#endif
		2795
		2796	#define G_HAVE_GNUC_VARARGS 1
		2797	_______EOF
		2798	fi
		2799
		2800	case x$g_stack_grows in
		2801	xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
		2802	*) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
		2803	esac
		2804
		2805
		2806	echo >>$outfile
		2807	if test x$g_have_eilseq = xno; then
		2808	cat >>$outfile <<_______EOF
		2809	#ifndef EILSEQ
		2810	/* On some pre-C99 systems, EILSEQ is not defined.
		2811	* The correspondence between this and the corresponding definition
		2812	* in libiconv is essential.
		2813	*/
		2814	# define EILSEQ ENOENT
		2815	#endif
		2816	_______EOF
		2817
		2818	fi
		2819
		2820	if test x$g_have_gnuc_visibility = xyes; then
		2821	cat >>$outfile <<_______EOF
		2822	#define G_HAVE_GNUC_VISIBILITY 1
		2823	_______EOF
		2824	fi
		2825	cat >>$outfile <<_______EOF
		2826	#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
		2827	#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
		2828	#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
		2829	#define G_GNUC_INTERNAL __hidden
		2830	#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
		2831	#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
		2832	#else
		2833	#define G_GNUC_INTERNAL
		2834	#endif
		2835	_______EOF
		2836
		2837	echo >>$outfile
		2838	cat >>$outfile <<_______EOF
		2839	#define G_THREADS_ENABLED
		2840	#define G_THREADS_IMPL_$g_threads_impl_def
		2841	_______EOF
		2842
		2843	if test x"$g_memory_barrier_needed" != xno; then
		2844	echo >>$outfile
		2845	echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
		2846	fi
		2847	if test x"$g_atomic_lock_free" = xyes; then
		2848	echo >>$outfile
		2849	echo "#define G_ATOMIC_LOCK_FREE" >>$outfile
		2850	fi
		2851	echo >>$outfile
		2852	g_bit_sizes="16 32 64"
		2853	for bits in $g_bit_sizes; do
		2854	cat >>$outfile <<_______EOF
		2855	#define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
		2856	#define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
		2857	#define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
		2858	#define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
		2859	_______EOF
		2860	done
		2861
		2862	cat >>$outfile <<_______EOF
		2863	#define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
		2864	#define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
		2865	#define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
		2866	#define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
		2867	#define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
		2868	#define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
		2869	#define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
		2870	#define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
		2871	#define GSIZE_TO_LE(val) ((gsize) GUINT${gsizebits}_TO_LE (val))
		2872	#define GSSIZE_TO_LE(val) ((gssize) GINT${gssizebits}_TO_LE (val))
		2873	#define GSIZE_TO_BE(val) ((gsize) GUINT${gsizebits}_TO_BE (val))
		2874	#define GSSIZE_TO_BE(val) ((gssize) GINT${gssizebits}_TO_BE (val))
		2875	#define G_BYTE_ORDER $g_byte_order
		2876
		2877	#define GLIB_SYSDEF_POLLIN =$g_pollin
		2878	#define GLIB_SYSDEF_POLLOUT =$g_pollout
		2879	#define GLIB_SYSDEF_POLLPRI =$g_pollpri
		2880	#define GLIB_SYSDEF_POLLHUP =$g_pollhup
		2881	#define GLIB_SYSDEF_POLLERR =$g_pollerr
		2882	#define GLIB_SYSDEF_POLLNVAL =$g_pollnval
		2883
		2884	#define G_MODULE_SUFFIX "$g_module_suffix"
		2885
		2886	typedef $g_pid_type GPid;
		2887
		2888	#define GLIB_SYSDEF_AF_UNIX $g_af_unix
		2889	#define GLIB_SYSDEF_AF_INET $g_af_inet
		2890	#define GLIB_SYSDEF_AF_INET6 $g_af_inet6
		2891
		2892	#define GLIB_SYSDEF_MSG_OOB $g_msg_oob
		2893	#define GLIB_SYSDEF_MSG_PEEK $g_msg_peek
		2894	#define GLIB_SYSDEF_MSG_DONTROUTE $g_msg_dontroute
		2895
		2896	G_END_DECLS
		2897
		2898	#endif /* __GLIBCONFIG_H__ */
		2899	_______EOF
		2900
		2901
		2902	if cmp -s $outfile glib/glibconfig.h; then
		2903	AC_MSG_NOTICE([glib/glibconfig.h is unchanged])
		2904	rm -f $outfile
		2905	else
		2906	mv $outfile glib/glibconfig.h
		2907	fi
		2908	],[
		2909
		2910	# Note that if two cases are the same, case goes with the first one.
		2911	# Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
		2912	# on variable expansion in case labels. Look at the generated config.status
		2913	# for a hint.
		2914
		2915	if test "x${ac_cv_working_alloca_h+set}" = xset ; then
		2916	glib_header_alloca_h="$ac_cv_working_alloca_h"
		2917	else
		2918	glib_header_alloca_h="$ac_cv_header_alloca_h"
		2919	fi
		2920
		2921	if test x$enable_included_printf = xyes ; then
		2922	glib_included_printf=yes
		2923	fi
		2924
		2925	case 2 in
		2926	$ac_cv_sizeof_short)
		2927	gint16=short
		2928	gint16_modifier='"h"'
		2929	gint16_format='"hi"'
		2930	guint16_format='"hu"'
		2931	;;
		2932	$ac_cv_sizeof_int)
		2933	gint16=int
		2934	gint16_modifier='""'
		2935	gint16_format='"i"'
		2936	guint16_format='"u"'
		2937	;;
		2938	esac
		2939	case 4 in
		2940	$ac_cv_sizeof_short)
		2941	gint32=short
		2942	gint32_modifier='"h"'
		2943	gint32_format='"hi"'
		2944	guint32_format='"hu"'
		2945	;;
		2946	$ac_cv_sizeof_int)
		2947	gint32=int
		2948	gint32_modifier='""'
		2949	gint32_format='"i"'
		2950	guint32_format='"u"'
		2951	;;
		2952	$ac_cv_sizeof_long)
		2953	gint32=long
		2954	gint32_modifier='"l"'
		2955	gint32_format='"li"'
		2956	guint32_format='"lu"'
		2957	;;
		2958	esac
		2959	case 8 in
		2960	$ac_cv_sizeof_int)
		2961	gint64=int
		2962	gint64_modifier='""'
		2963	gint64_format='"i"'
		2964	guint64_format='"u"'
		2965	glib_extension=
		2966	gint64_constant='(val)'
		2967	guint64_constant='(val)'
		2968	;;
		2969	$ac_cv_sizeof_long)
		2970	gint64=long
		2971	gint64_modifier='"l"'
		2972	gint64_format='"li"'
		2973	guint64_format='"lu"'
		2974	glib_extension=
		2975	gint64_constant='(val##L)'
		2976	guint64_constant='(val##UL)'
		2977	;;
		2978	$ac_cv_sizeof_long_long)
		2979	gint64='long long'
		2980	if test -n "$glib_cv_long_long_format"; then
		2981	gint64_modifier='"'$glib_cv_long_long_format'"'
		2982	gint64_format='"'$glib_cv_long_long_format'i"'
		2983	guint64_format='"'$glib_cv_long_long_format'u"'
		2984	fi
		2985	glib_extension='G_GNUC_EXTENSION '
		2986	gint64_constant='(G_GNUC_EXTENSION (val##LL))'
		2987	guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
		2988	;;
		2989	$ac_cv_sizeof___int64)
		2990	gint64='__int64'
		2991	if test -n "$glib_cv_long_long_format"; then
		2992	gint64_modifier='"'$glib_cv_long_long_format'"'
		2993	gint64_format='"'$glib_cv_long_long_format'i"'
		2994	guint64_format='"'$glib_cv_long_long_format'u"'
		2995	fi
		2996	glib_extension=
		2997	gint64_constant='(val##i64)'
		2998	guint64_constant='(val##ui64)'
		2999	;;
		3000	esac
		3001	glib_size_t=$ac_cv_sizeof_size_t
		3002	glib_ssize_t=$ac_cv_sizeof_ssize_t
		3003	glib_size_type_define="$glib_size_type"
		3004	glib_ssize_type_define="$glib_ssize_type"
		3005	glib_void_p=$ac_cv_sizeof_void_p
		3006	glib_long=$ac_cv_sizeof_long
		3007
		3008	case "$glib_size_type" in
		3009	short)
		3010	gsize_modifier='"h"'
		3011	gsize_format='"hu"'
		3012	glib_msize_type='SHRT'
		3013	;;
		3014	int)
		3015	gsize_modifier='""'
		3016	gsize_format='"u"'
		3017	glib_msize_type='INT'
		3018	;;
		3019	long)
		3020	gsize_modifier='"l"'
		3021	gsize_format='"lu"'
		3022	glib_msize_type='LONG'
		3023	;;
		3024	"long long"|__int64)
		3025	gsize_modifier='"I64"'
		3026	gsize_format='"I64u"'
		3027	glib_msize_type='INT64'
		3028	;;
		3029	esac
		3030
		3031	case "$glib_ssize_type" in
		3032	short)
		3033	gssize_modifier='"h"'
		3034	gssize_format='"hi"'
		3035	glib_mssize_type='SHRT'
		3036	;;
		3037	int)
		3038	gssize_modifier='""'
		3039	gssize_format='"i"'
		3040	glib_mssize_type='INT'
		3041	;;
		3042	long)
		3043	gssize_modifier='"l"'
		3044	gssize_format='"li"'
		3045	glib_mssize_type='LONG'
		3046	;;
		3047	"long long"|__int64)
		3048	gssize_modifier='"I64"'
		3049	gssize_format='"I64i"'
		3050	glib_mssize_type='INT64'
		3051	;;
		3052	esac
		3053
		3054	gintbits=`expr $ac_cv_sizeof_int \* 8`
		3055	glongbits=`expr $ac_cv_sizeof_long \* 8`
		3056	gsizebits=`expr $ac_cv_sizeof_size_t \* 8`
		3057	gssizebits=`expr $ac_cv_sizeof_ssize_t \* 8`
		3058
		3059	case $ac_cv_sizeof_void_p in
		3060	$ac_cv_sizeof_int)
		3061	glib_intptr_type_define=int
		3062	gintptr_modifier='""'
		3063	gintptr_format='"i"'
		3064	guintptr_format='"u"'
		3065	glib_gpi_cast='(gint)'
		3066	glib_gpui_cast='(guint)'
		3067	;;
		3068	$ac_cv_sizeof_long)
		3069	glib_intptr_type_define=long
		3070	gintptr_modifier='"l"'
		3071	gintptr_format='"li"'
		3072	guintptr_format='"lu"'
		3073	glib_gpi_cast='(glong)'
		3074	glib_gpui_cast='(gulong)'
		3075	;;
		3076	$ac_cv_sizeof_long_long)
		3077	glib_intptr_type_define='long long'
		3078	gintptr_modifier='"I64"'
		3079	gintptr_format='"I64i"'
		3080	guintptr_format='"I64u"'
		3081	glib_gpi_cast='(gint64)'
		3082	glib_gpui_cast='(guint64)'
		3083	;;
		3084	$ac_cv_sizeof___int64)
		3085	glib_intptr_type_define=__int64
		3086	gintptr_modifier='"I64"'
		3087	gintptr_format='"I64i"'
		3088	guintptr_format='"I64u"'
		3089	glib_gpi_cast='(gint64)'
		3090	glib_gpui_cast='(guint64)'
		3091	;;
		3092	*)
		3093	glib_unknown_void_p=yes
		3094	;;
		3095	esac
		3096
		3097
		3098	glib_defines="
		3099	#define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
		3100	#define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
		3101	#define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
		3102	"
		3103
		3104	case xyes in
		3105	x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
		3106	x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
		3107	*) glib_vacopy=''
		3108	esac
		3109
		3110	if test x$glib_cv_va_val_copy = xno; then
		3111	glib_vacopy="\$glib_vacopy
		3112	#define G_VA_COPY_AS_ARRAY 1"
		3113	fi
		3114
		3115	g_have_gnuc_varargs=$g_have_gnuc_varargs
		3116	g_have_iso_c_varargs=$g_have_iso_c_varargs
		3117	g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
		3118
		3119	g_have_gnuc_visibility=$g_have_gnuc_visibility
		3120	g_have_sunstudio_visibility=$g_have_sunstudio_visibility
		3121
		3122	if test x$ac_cv_c_bigendian = xyes; then
		3123	g_byte_order=G_BIG_ENDIAN
		3124	g_bs_native=BE
		3125	g_bs_alien=LE
		3126	else
		3127	g_byte_order=G_LITTLE_ENDIAN
		3128	g_bs_native=LE
		3129	g_bs_alien=BE
		3130	fi
		3131
		3132	g_pollin=$glib_cv_value_POLLIN
		3133	g_pollout=$glib_cv_value_POLLOUT
		3134	g_pollpri=$glib_cv_value_POLLPRI
		3135	g_pollhup=$glib_cv_value_POLLHUP
		3136	g_pollerr=$glib_cv_value_POLLERR
		3137	g_pollnval=$glib_cv_value_POLLNVAL
		3138
		3139	# If a family is not found on the system, define that family to
		3140	# a negative value, picking a different one for each undefined
		3141	# family (-1 for AF_UNIX, -2 for the next one, -3 ...)
		3142	# This is needed because glib-mkenums doesn't handle optional
		3143	# values in enums, and thus we have to have all existing values
		3144	# defined in the enum.
		3145	if test "x$glib_cv_value_AF_UNIX" != "x"; then
		3146	g_af_unix=$glib_cv_value_AF_UNIX
		3147	else
		3148	g_af_unix=-1
		3149	fi
		3150	g_af_inet=$glib_cv_value_AF_INET
		3151	g_af_inet6=$glib_cv_value_AF_INET6
		3152
		3153	g_msg_peek=$glib_cv_value_MSG_PEEK
		3154	g_msg_oob=$glib_cv_value_MSG_OOB
		3155	g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
		3156
		3157	g_stack_grows=$glib_cv_stack_grows
		3158
		3159	g_have_eilseq=$have_eilseq
		3160
		3161	g_threads_impl_def=$g_threads_impl
		3162
		3163	g_atomic_lock_free="$glib_cv_g_atomic_lock_free"
		3164	g_memory_barrier_needed="$glib_memory_barrier_needed"
		3165	g_gcc_atomic_ops="$glib_cv_gcc_has_builtin_atomic_operations"
		3166
		3167	g_module_suffix="$glib_gmodule_suffix"
		3168	g_pid_type="$glib_pid_type"
		3169	g_pollfd_format="\"$glib_pollfd_format\""
		3170
		3171	case $host in
		3172	*-*-cygwin*)
		3173	glib_os="#define G_OS_UNIX
		3174	#define G_PLATFORM_WIN32
		3175	#define G_WITH_CYGWIN"
		3176	;;
		3177	*-*-mingw*)
		3178	glib_os="#define G_OS_WIN32
		3179	#define G_PLATFORM_WIN32"
		3180	;;
		3181	*)
		3182	glib_os="#define G_OS_UNIX"
		3183	;;
		3184	esac
		3185	glib_static_compilation=""
		3186	if test x$glib_win32_static_compilation = xyes; then
		3187	glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
		3188	#define GOBJECT_STATIC_COMPILATION 1"
		3189	fi
		3190	])
		3191
		3192	# Redo enough to get guint32 and guint64 for the alignment checks below
		3193	case 4 in
		3194	$ac_cv_sizeof_short)
		3195	gint32=short
		3196	;;
		3197	$ac_cv_sizeof_int)
		3198	gint32=int
		3199	;;
		3200	$ac_cv_sizeof_long)
		3201	gint32=long
		3202	;;
		3203	esac
		3204	case 8 in
		3205	$ac_cv_sizeof_int)
		3206	gint64=int
		3207	;;
		3208	$ac_cv_sizeof_long)
		3209	gint64=long
		3210	;;
		3211	$ac_cv_sizeof_long_long)
		3212	gint64='long long'
		3213	;;
		3214	$ac_cv_sizeof___int64)
		3215	gint64='__int64'
		3216	;;
		3217	esac
		3218
		3219	AC_CHECK_TYPE([guint32],,,[typedef unsigned $gint32 guint32;])
		3220	AC_CHECK_ALIGNOF([guint32], [AC_INCLUDES_DEFAULT
		3221	typedef unsigned $gint32 guint32;])
		3222	AC_CHECK_TYPE([guint64],,,[typedef unsigned $gint64 guint64;])
		3223	AC_CHECK_ALIGNOF([guint64], [AC_INCLUDES_DEFAULT
		3224	typedef unsigned $gint64 guint64;])
		3225	AC_CHECK_TYPE([unsigned long])
		3226	AC_CHECK_ALIGNOF([unsigned long])
		3227
		3228	# Check for libdbus1 - Optional - is only used in the GDBus test cases
		3229	#
		3230	# 1.2.14 required for dbus_message_set_serial
		3231	PKG_CHECK_MODULES(DBUS1,
		3232	dbus-1 >= 1.2.14,
		3233	[AC_DEFINE(HAVE_DBUS1, 1, [Define if dbus-1 is available]) have_dbus1=yes],
		3234	have_dbus1=no)
		3235	AC_SUBST(DBUS1_CFLAGS)
		3236	AC_SUBST(DBUS1_LIBS)
		3237	AM_CONDITIONAL(HAVE_DBUS1, [test "x$have_dbus1" = "xyes"])
		3238
		3239	AC_CHECK_PROGS([DBUS_DAEMON], [dbus-daemon])
		3240	AM_CONDITIONAL([HAVE_DBUS_DAEMON], [test x$DBUS_DAEMON = xdbus-daemon ])
		3241
		3242	dnl
		3243	dnl Check for -Bsymbolic-functions linker flag used to avoid
		3244	dnl intra-library PLT jumps, if available.
		3245	dnl
		3246
		3247	AC_ARG_ENABLE(Bsymbolic,
		3248	[AS_HELP_STRING([--disable-Bsymbolic],
		3249	[avoid linking with -Bsymbolic])],,
		3250	[SAVED_LDFLAGS="${LDFLAGS}" SAVED_LIBS="${LIBS}"
		3251	AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
		3252	LDFLAGS=-Wl,-Bsymbolic-functions
		3253	LIBS=
		3254	AC_TRY_LINK([], [return 0],
		3255	AC_MSG_RESULT(yes)
		3256	enable_Bsymbolic=yes,
		3257	AC_MSG_RESULT(no)
		3258	enable_Bsymbolic=no)
		3259	LDFLAGS="${SAVED_LDFLAGS}" LIBS="${SAVED_LIBS}"])
		3260
		3261	if test "x${enable_Bsymbolic}" = "xyes"; then
		3262	GLIB_LINK_FLAGS=-Wl,-Bsymbolic-functions
		3263	fi
		3264
		3265	dnl
		3266	dnl Check for -z,nodelete linker flag: the type system assumes that
		3267	dnl libgobject stays loaded for the lifetime of the process.
		3268	dnl Since ld.bfd does not treat wrong -z options as fatal by default,
		3269	dnl we also try to check for the --fatal-warnings linker flag if
		3270	dnl auto-detecting.
		3271	dnl
		3272
		3273	AC_ARG_ENABLE([znodelete],
		3274	[AS_HELP_STRING([--disable-znodelete],
		3275	[avoid linking with -z,nodelete])],,
		3276	[SAVED_LDFLAGS="${LDFLAGS}" SAVED_LIBS="${LIBS}"
		3277	AC_MSG_CHECKING([for --fatal-warnings linker flag])
		3278	LDFLAGS=-Wl,--fatal-warnings
		3279	LIBS=
		3280	AC_TRY_LINK([], [return 0],
		3281	AC_MSG_RESULT(yes)
		3282	[ldflags_fatal=-Wl,--fatal-warnings],
		3283	AC_MSG_RESULT(no)
		3284	ldflags_fatal=)
		3285	AC_MSG_CHECKING([for -z,nodelete linker flag])
		3286	LDFLAGS="$ldflags_fatal -Wl,-z,nodelete"
		3287	AC_TRY_LINK([], [return 0],
		3288	AC_MSG_RESULT(yes)
		3289	enable_znodelete=yes,
		3290	AC_MSG_RESULT(no)
		3291	enable_znodelete=no)
		3292	LDFLAGS="${SAVED_LDFLAGS}" LIBS="${SAVED_LIBS}"])
		3293
		3294	if test "x${enable_znodelete}" = "xyes"; then
		3295	GLIB_LINK_FLAGS="$GLIB_LINK_FLAGS -Wl,-z,nodelete"
		3296	fi
		3297
		3298	AC_SUBST(GLIB_LINK_FLAGS)
		3299
		3300	dnl
		3301	dnl Check for -fvisibility=hidden to determine if we can do GNU-style
		3302	dnl visibility attributes for symbol export control
		3303	dnl
		3304	GLIB_HIDDEN_VISIBILITY_CFLAGS=""
		3305	case "$host" in
		3306	*-*-mingw*)
		3307	dnl on mingw32 we do -fvisibility=hidden and __declspec(dllexport)
		3308	AC_DEFINE([_GLIB_EXTERN], [__attribute__((visibility("default"))) __declspec(dllexport) extern],
		3309	[defines how to decorate public symbols while building])
		3310	CFLAGS="${CFLAGS} -fvisibility=hidden"
		3311	;;
		3312	*)
		3313	dnl on other compilers, check if we can do -fvisibility=hidden
		3314	SAVED_CFLAGS="${CFLAGS}"
		3315	CFLAGS="-fvisibility=hidden"
		3316	AC_MSG_CHECKING([for -fvisibility=hidden compiler flag])
		3317	AC_TRY_COMPILE([], [return 0],
		3318	AC_MSG_RESULT(yes)
		3319	enable_fvisibility_hidden=yes,
		3320	AC_MSG_RESULT(no)
		3321	enable_fvisibility_hidden=no)
		3322	CFLAGS="${SAVED_CFLAGS}"
		3323
		3324	AS_IF([test "${enable_fvisibility_hidden}" = "yes"], [
		3325	AC_DEFINE([_GLIB_EXTERN], [__attribute__((visibility("default"))) extern],
		3326	[defines how to decorate public symbols while building])
		3327	GLIB_HIDDEN_VISIBILITY_CFLAGS="-fvisibility=hidden"
		3328	])
		3329	;;
		3330	esac
		3331	AC_SUBST(GLIB_HIDDEN_VISIBILITY_CFLAGS)
		3332
		3333	dnl Compiler flags; macro originates from systemd
		3334	dnl See https://bugzilla.gnome.org/show_bug.cgi?id=608953
		3335	AC_ARG_ENABLE(compile-warnings,
		3336	[AS_HELP_STRING([--disable-compile-warnings],
		3337	[Don't use builtin compiler warnings])],,
		3338	enable_compile_warnings=yes)
		3339	AS_IF([test "x$enable_compile_warnings" = xyes], [
		3340	CC_CHECK_FLAGS_APPEND([GLIB_WARN_CFLAGS], [CFLAGS], [\
		3341	-Wall -Wstrict-prototypes -Werror=declaration-after-statement \
		3342	-Werror=missing-prototypes -Werror=implicit-function-declaration \
		3343	-Werror=pointer-arith -Werror=init-self -Werror=format-security \
		3344	-Werror=format=2 -Werror=missing-include-dirs])
		3345	])
		3346	AC_SUBST(GLIB_WARN_CFLAGS)
		3347
		3348	#
		3349	# Define variables corresponding to the correct include paths to use for
		3350	# in-tree building.
		3351	#
		3352
		3353	# for config.h:
		3354	config_h_INCLUDES='-I$(top_builddir)'
		3355	AC_SUBST(config_h_INCLUDES)
		3356
		3357	# glib:
		3358	# config.h
		3359	# $(top_builddir)/glib: for glibconfig.h
		3360	# $(top_srcdir)/glib: for glib.h
		3361	# $(top_srcdir): for everything
		3362	glib_INCLUDES='$(config_h_INCLUDES) -I$(top_builddir)/glib -I$(top_srcdir)/glib -I$(top_srcdir)'
		3363	AC_SUBST(glib_INCLUDES)
		3364
		3365	# gobject:
		3366	# same as glib
		3367	gobject_INCLUDES='$(glib_INCLUDES)'
		3368	AC_SUBST(gobject_INCLUDES)
		3369
		3370	# gmodule:
		3371	# glib includes
		3372	# $(top_srcdir)/gmodule: for gmodule.h
		3373	gmodule_INCLUDES='$(glib_INCLUDES) -I$(top_srcdir)/gmodule'
		3374	AC_SUBST(gmodule_INCLUDES)
		3375
		3376	# gio:
		3377	# same as gmodule
		3378	gio_INCLUDES='$(gmodule_INCLUDES)'
		3379	AC_SUBST(gio_INCLUDES)
		3380
		3381
		3382	AC_CONFIG_FILES([
		3383	glib-2.0.pc
		3384	gmodule-2.0.pc
		3385	gmodule-export-2.0.pc
		3386	gmodule-no-export-2.0.pc
		3387	gthread-2.0.pc
		3388	gobject-2.0.pc
		3389	gio-2.0.pc
		3390	gio-unix-2.0.pc
		3391	gio-windows-2.0.pc
		3392	glib-zip
		3393	glib-gettextize
		3394	Makefile
		3395	build/Makefile
		3396	build/win32/Makefile
		3397	build/win32/dirent/Makefile
		3398	build/win32/vs9/Makefile
		3399	build/win32/vs9/glib-version-paths.vsprops
		3400	build/win32/vs10/Makefile
		3401	build/win32/vs10/glib-version-paths.props
		3402	build/win32/vs11/Makefile
		3403	build/win32/vs12/Makefile
		3404	build/win32/vs14/Makefile
		3405	glib/Makefile
		3406	glib/libcharset/Makefile
		3407	glib/gnulib/Makefile
		3408	glib/pcre/Makefile
		3409	glib/update-pcre/Makefile
		3410	glib/tests/Makefile
		3411	gmodule/Makefile
		3412	gmodule/gmoduleconf.h
		3413	gobject/Makefile
		3414	gobject/glib-mkenums
		3415	gobject/tests/Makefile
		3416	gthread/Makefile
		3417	gio/Makefile
		3418	gio/gdbus-2.0/codegen/Makefile
		3419	gio/gdbus-2.0/codegen/config.py
		3420	gio/gnetworking.h
		3421	gio/xdgmime/Makefile
		3422	gio/inotify/Makefile
		3423	gio/kqueue/Makefile
		3424	gio/fam/Makefile
		3425	gio/win32/Makefile
		3426	gio/tests/Makefile
		3427	gio/tests/gdbus-object-manager-example/Makefile
		3428	gio/tests/services/Makefile
		3429	gio/tests/services/org.gtk.GDBus.Examples.ObjectManager.service
		3430	gio/tests/modules/Makefile
		3431	po/Makefile.in
		3432	docs/Makefile
		3433	docs/reference/Makefile
		3434	docs/reference/glib/Makefile
		3435	docs/reference/glib/version.xml
		3436	docs/reference/gobject/Makefile
		3437	docs/reference/gobject/version.xml
		3438	docs/reference/gio/Makefile
		3439	docs/reference/gio/version.xml
		3440	tests/Makefile
		3441	tests/gobject/Makefile
		3442	tests/refcount/Makefile
		3443	m4macros/Makefile
		3444	])
		3445
		3446	AC_CONFIG_COMMANDS([chmod-scripts],
		3447	[chmod 0755 glib-zip
		3448	chmod 0755 glib-gettextize
		3449	chmod 0755 gobject/glib-mkenums])
		3450
		3451	# we want to invoke this macro solely so that the config.status script
		3452	# and automake generated makefiles know about these generated files.
		3453	# They are only needed to distcheck the package
		3454	if false; then
		3455	AC_CONFIG_FILES([
		3456	INSTALL
		3457	README
		3458	config.h.win32
		3459	glib/glibconfig.h.win32
		3460	glib/makefile.msc
		3461	glib/glib.rc
		3462	gmodule/makefile.msc
		3463	gmodule/gmodule.rc
		3464	gobject/makefile.msc
		3465	gobject/gobject.rc
		3466	gthread/makefile.msc
		3467	gthread/gthread.rc
		3468	gio/gio.rc
		3469	tests/makefile.msc
		3470	])
		3471	fi
		3472
		3473	AC_OUTPUT