Context Navigation

configure.in @ 21371

Visit:

Revision 21371, 72.6 KB checked in by ghudson, 20 years ago (diff)
Merge with glib 2.4.8.

Line
1	# Process this file with autoconf to produce a configure script.
2	# require autoconf 2.54
3	AC_PREREQ(2.54)
4
5	dnl ***********************************
6	dnl * include special GLib macros *
7	dnl ***********************************
8
9	m4_define(glib_configure_in)
10	m4_include(acglib.m4)dnl
11	m4_include(glib/libcharset/codeset.m4)dnl
12	m4_include(glib/libcharset/glibc21.m4)dnl
13	m4_include(m4macros/glib-gettext.m4)dnl
14
15	#
16	# The following version number definitions apply to GLib, GModule, GObject
17	# and GThread as a whole, so if changes occoured in any of them, they are all
18	# treated with the same interface and binary age.
19	#
20	# Making releases:
21	# glib_micro_version += 1;
22	# glib_interface_age += 1;
23	# glib_binary_age += 1;
24	# if any functions have been added, set glib_interface_age to 0.
25	# if backwards compatibility has been broken,
26	# set glib_binary_age _and_ glib_interface_age to 0.
27	#
28	m4_define([glib_major_version], [2])
29	m4_define([glib_minor_version], [4])
30	m4_define([glib_micro_version], [8])
31	m4_define([glib_interface_age], [8])
32	m4_define([glib_binary_age],
33	[m4_eval(100 * glib_minor_version + glib_micro_version)])
34	m4_define([glib_version],
35	[glib_major_version.glib_minor_version.glib_micro_version])
36
37	# libtool version related macros
38	m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
39	m4_define([glib_lt_current],
40	[m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
41	m4_define([glib_lt_revision], [glib_interface_age])
42	m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
43	m4_define([glib_lt_current_minus_age],
44	[m4_eval(glib_lt_current - glib_lt_age)])
45
46	# if the minor version number is odd, then we want debugging. Otherwise
47	# we only want minimal debugging support.
48	m4_define([glib_debug_default],
49	[m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
50
51
52	AC_INIT(glib, [glib_version],
53	[http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
54
55	AC_CONFIG_SRCDIR([glib/glib.h])
56
57	# Save this value here, since automake will set cflags later
58	cflags_set=${CFLAGS+set}
59
60	AM_INIT_AUTOMAKE([no-define])
61
62	# Specify a configuration file
63	AM_CONFIG_HEADER([config.h])
64
65
66	GLIB_MAJOR_VERSION=glib_major_version
67	GLIB_MINOR_VERSION=glib_minor_version
68	GLIB_MICRO_VERSION=glib_micro_version
69	GLIB_INTERFACE_AGE=glib_interface_age
70	GLIB_BINARY_AGE=glib_binary_age
71	GLIB_VERSION=glib_version
72
73	AC_SUBST(GLIB_MAJOR_VERSION)
74	AC_SUBST(GLIB_MINOR_VERSION)
75	AC_SUBST(GLIB_MICRO_VERSION)
76	AC_SUBST(GLIB_VERSION)
77	AC_SUBST(GLIB_INTERFACE_AGE)
78	AC_SUBST(GLIB_BINARY_AGE)
79
80	AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
81	[Define to the GLIB major version])
82	AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
83	[Define to the GLIB minor version])
84	AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
85	[Define to the GLIB micro version])
86	AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
87	[Define to the GLIB interface age])
88	AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
89	[Define to the GLIB binary age])
90
91	# libtool versioning
92	LT_RELEASE=glib_lt_release
93	LT_CURRENT=glib_lt_current
94	LT_REVISION=glib_lt_revision
95	LT_AGE=glib_lt_age
96	LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
97	AC_SUBST(LT_RELEASE)
98	AC_SUBST(LT_CURRENT)
99	AC_SUBST(LT_REVISION)
100	AC_SUBST(LT_AGE)
101	AC_SUBST(LT_CURRENT_MINUS_AGE)
102
103	dnl Initialize maintainer mode
104	AM_MAINTAINER_MODE
105
106	AC_CANONICAL_HOST
107
108	AC_MSG_CHECKING([for the BeOS])
109	case $host in
110	--beos*)
111	glib_native_beos="yes"
112	;;
113	*)
114	glib_native_beos="no"
115	;;
116	esac
117	AC_MSG_RESULT([$glib_native_beos])
118
119	dnl
120
121	AC_MSG_CHECKING([for Win32])
122	case "$host" in
123	--mingw*)
124	glib_native_win32=yes
125	G_LIB_WIN32_RESOURCE=glib-win32res.lo
126	G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo
127	G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo
128	G_THREAD_WIN32_RESOURCE=gthread-win32res.lo
129	GLIB_DEF=glib.def
130	GMODULE_DEF=gmodule.def
131	GOBJECT_DEF=gobject.def
132	GTHREAD_DEF=gthread.def
133	TESTGMODULE_EXP=testgmodule.exp
134	glib_pid_type='void *'
135	;;
136	*)
137	glib_native_win32=no
138	G_LIB_WIN32_RESOURCE=
139	G_MODULE_WIN32_RESOURCE=
140	G_OBJECT_WIN32_RESOURCE=
141	G_THREAD_WIN32_RESOURCE=
142	GLIB_DEF=
143	GMODULE_DEF=
144	GOBJECT_DEF=
145	GTHREAD_DEF=
146	TESTGMODULE_EXP=
147	glib_pid_type=int
148	;;
149	esac
150	AC_MSG_RESULT([$glib_native_win32])
151	AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
152	AC_SUBST(G_LIB_WIN32_RESOURCE)
153	AC_SUBST(G_MODULE_WIN32_RESOURCE)
154	AC_SUBST(G_OBJECT_WIN32_RESOURCE)
155	AC_SUBST(G_THREAD_WIN32_RESOURCE)
156	AC_SUBST(GLIB_DEF)
157	AC_SUBST(GMODULE_DEF)
158	AC_SUBST(GOBJECT_DEF)
159	AC_SUBST(GTHREAD_DEF)
160	AC_SUBST(TESTGMODULE_EXP)
161
162	if test "$glib_native_win32" = "yes"; then
163	AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
164	fi
165	AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
166
167	dnl declare --enable-* args and collect ac_help strings
168	AC_ARG_ENABLE(debug,
169	AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
170	[turn on debugging @<:@default=glib_debug_default@:>@]),,
171	enable_debug=glib_debug_default)
172
173	AC_ARG_ENABLE(gc_friendly,
174	[AC_HELP_STRING([--enable-gc-friendly],
175	[turn on garbage collector friendliness [default=no]])],,
176	[enable_gc_friendly=no])
177	AC_ARG_ENABLE(mem_pools,
178	[AC_HELP_STRING([--disable-mem-pools],
179	[disable all glib memory pools])],,
180	[disable_mem_pools=no])
181	AC_ARG_ENABLE(ansi,
182	[AC_HELP_STRING([--enable-ansi],
183	[turn on strict ansi [default=no]])],,
184	[enable_ansi=no])
185	AC_ARG_ENABLE(threads,
186	[AC_HELP_STRING([--enable-threads],
187	[turn on basic thread support [default=yes]
188	([=no] will override --with-threads)])],,
189	[enable_threads=yes])
190	AC_ARG_ENABLE(rebuilds,
191	[AC_HELP_STRING([--disable-rebuilds],
192	[disable all source autogeneration rules])],,
193	[enable_rebuilds=yes])
194
195	if test "x$enable_threads" != "xyes"; then
196	enable_threads=no
197	fi
198
199	AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, ["${enable_debug}"],
200	[Whether glib was compiled with debugging enabled])
201
202	AC_MSG_CHECKING([whether to enable garbage collector friendliness])
203	if test "x$enable_gc_friendly" = "xyes"; then
204	AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
205	AC_SUBST(ENABLE_GC_FRIENDLY)
206	AC_MSG_RESULT([yes])
207	else
208	AC_MSG_RESULT([no])
209	fi
210
211	AC_MSG_CHECKING([whether to disable memory pools])
212	if test "x$disable_mem_pools" = "xno"; then
213	AC_MSG_RESULT([no])
214	else
215	AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
216	AC_SUBST(DISABLE_MEM_POOLS)
217	AC_MSG_RESULT([yes])
218	fi
219
220	if test "$glib_native_win32" = "yes"; then
221	if test x$enable_static = xyes -o x$enable_static = x; then
222	AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
223	enable_static=no
224	fi
225	if test x$enable_shared = xno; then
226	AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
227	fi
228	enable_shared=yes
229	fi
230
231	dnl Checks for programs.
232	AC_PROG_CC
233
234	dnl Check for a working C++ compiler, but do not bail out, if none is found.
235	AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
236	AC_LANG_SAVE
237	AC_LANG_CPLUSPLUS
238	AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
239	AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
240	AC_LANG_RESTORE
241
242	AM_PROG_CC_STDC
243	AC_PROG_INSTALL
244
245	AC_SYS_LARGEFILE
246
247	#
248	# Find pkg-config
249	#
250	AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
251	if test x$PKG_CONFIG = xno ; then
252	AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
253	fi
254
255	if $PKG_CONFIG --atleast-pkgconfig-version 0.14 ; then
256	:
257	else
258	AC_MSG_ERROR([*** pkg-config too old; version 0.14 or better required.])
259	fi
260
261	if test "x$enable_debug" = "xyes"; then
262	if test x$cflags_set != xset ; then
263	case " $CFLAGS " in
264	[[\ \ ]]-g[[\ \ ]]) ;;
265	*) CFLAGS="$CFLAGS -g" ;;
266	esac
267	fi
268
269	GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
270	else
271	GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
272
273	if test "x$enable_debug" = "xno"; then
274	GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
275	fi
276	fi
277
278	# Ensure MSVC-compatible struct packing convention is used when
279	# compiling for Win32 with gcc.
280	# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
281	# gcc2 uses "-fnative-struct".
282	if test x"$glib_native_win32" = xyes; then
283	if test x"$GCC" = xyes; then
284	msnative_struct=''
285	AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
286	if test -z "$ac_cv_prog_CC"; then
287	our_gcc="$CC"
288	else
289	our_gcc="$ac_cv_prog_CC"
290	fi
291	case `$our_gcc --version \| sed -e 's,\..*,.,' -e q` in
292	2.)
293	if $our_gcc -v --help 2>/dev/null \| grep fnative-struct >/dev/null; then
294	msnative_struct='-fnative-struct'
295	fi
296	;;
297	*)
298	if $our_gcc -v --help 2>/dev/null \| grep ms-bitfields >/dev/null; then
299	msnative_struct='-mms-bitfields'
300	fi
301	;;
302	esac
303	if test x"$msnative_struct" = x ; then
304	AC_MSG_RESULT([no way])
305	AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
306	else
307	CFLAGS="$CFLAGS $msnative_struct"
308	AC_MSG_RESULT([${msnative_struct}])
309	fi
310	fi
311	fi
312
313	AC_EXEEXT
314
315	# define a MAINT-like variable REBUILD which is set if Perl
316	# and awk are found, so autogenerated sources can be rebuilt
317	AC_PROG_AWK
318	AC_CHECK_PROGS(PERL, [perl5 perl])
319	# We would like indent, but don't require it.
320	AC_CHECK_PROG(INDENT, indent, indent)
321	REBUILD=\#
322	if test "x$enable_rebuilds" = "xyes" && \
323	test -n "$PERL" && \
324	$PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
325	test -n "$AWK" ; then
326	REBUILD=
327	fi
328	AC_SUBST(REBUILD)
329
330	# Need full path to Perl for glib-mkenums
331	#
332	if test "x$PERL" != x ; then
333	AC_PATH_PROG(PERL_PATH, [$PERL])
334	else
335	PERL_PATH="/usr/bin/env perl"
336	fi
337	AC_SUBST(PERL_PATH)
338
339	dnl ***********************
340	dnl * Tests for iconv *
341	dnl ***********************
342	dnl
343	dnl We do this before the gettext checks, to avoid distortion
344
345	AC_ARG_WITH(libiconv,
346	[AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
347	[use the libiconv library])],,
348	[with_libiconv=maybe])
349
350	found_iconv=no
351	case $with_libiconv in
352	maybe)
353	# Check in the C library first
354	AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
355	# Check if we have GNU libiconv
356	if test $found_iconv = "no"; then
357	AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
358	fi
359	# Check if we have a iconv in -liconv, possibly from vendor
360	if test $found_iconv = "no"; then
361	AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
362	fi
363	;;
364	no)
365	AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
366	;;
367	gnu\|yes)
368	AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
369	;;
370	native)
371	AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
372	;;
373	esac
374
375	if test "x$found_iconv" = "xno" ; then
376	AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
377	fi
378
379	dnl
380	dnl gettext support
381	dnl
382
383	ALL_LINGUAS="am ar az be bg bn bs ca cs cy da de el en_CA en_GB eo es et eu fa fi fr ga gl gu he hi hr id is it ja ko lt lv mk mn ms nb ne nl nn no or pa pl pt pt_BR ro ru sk sl sq sr sr@ije sr@Latn sv ta tr uk vi wa yi zh_CN zh_TW"
384	GLIB_GNU_GETTEXT
385
386	if test "$gt_cv_have_gettext" != "yes" ; then
387	AC_MSG_ERROR([
388	*** You must have either have gettext support in your C library, or use the
389	*** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
390	])
391	fi
392
393	LIBS="$INTLLIBS $LIBS"
394
395	GETTEXT_PACKAGE=glib20
396	AC_SUBST(GETTEXT_PACKAGE)
397	AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
398	[Define the gettext package to be used])
399
400	GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
401
402	dnl
403	dnl Now we are done with gettext checks, figure out ICONV_LIBS
404	dnl
405
406	if test x$with_libiconv != xno ; then
407	case " $INTLLIBS " in
408	[[\ \ ]]-liconv[[\ \ ]]) ;;
409	*) ICONV_LIBS="-liconv" ;;
410	esac
411	fi
412	AC_SUBST(ICONV_LIBS)
413
414	case $with_libiconv in
415	gnu)
416	AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
417	;;
418	native)
419	AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
420	;;
421	esac
422
423	dnl Initialize libtool
424	AM_DISABLE_STATIC
425	AM_PROG_LIBTOOL
426
427	if test "x$GCC" = "xyes"; then
428	case " $CFLAGS " in
429	[[\ \ ]]-Wall[[\ \ ]]) ;;
430	*) CFLAGS="$CFLAGS -Wall" ;;
431	esac
432
433	if test "x$enable_ansi" = "xyes"; then
434	case " $CFLAGS " in
435	[[\ \ ]]-ansi[[\ \ ]]) ;;
436	*) CFLAGS="$CFLAGS -ansi" ;;
437	esac
438
439	case " $CFLAGS " in
440	[[\ \ ]]-pedantic[[\ \ ]]) ;;
441	*) CFLAGS="$CFLAGS -pedantic" ;;
442	esac
443	fi
444	fi
445
446	dnl
447	dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
448	dnl
449	if test $cross_compiling != yes ; then
450	AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
451	glib_save_LIBS=$LIBS
452	LIBS="$LIBS -lm"
453	AC_TRY_RUN([#include <math.h>
454	int main (void) { return (log(1) != log(1.)); }],
455	AC_MSG_RESULT(none needed),
456	glib_save_CFLAGS=$CFLAGS
457	CFLAGS="$CFLAGS -std1"
458	AC_TRY_RUN([#include <math.h>
459	int main (void) { return (log(1) != log(1.)); }],
460	AC_MSG_RESULT(-std1),
461	AC_MSG_RESULT()
462	CFLAGS=$glib_save_CFLAGS
463	AC_MSG_WARN(
464	[No ANSI prototypes found in library. (-std1 didn't work.)])
465	)
466	)
467	LIBS=$glib_save_LIBS
468	fi
469
470	dnl NeXTStep cc seems to need this
471	AC_MSG_CHECKING([for extra flags for POSIX compliance])
472	AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
473	AC_MSG_RESULT(none needed),
474	glib_save_CFLAGS=$CFLAGS
475	CFLAGS="$CFLAGS -posix"
476	AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
477	AC_MSG_RESULT(-posix),
478	AC_MSG_RESULT()
479	CFLAGS=$glib_save_CFLAGS
480	AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
481
482	# Checks for header files.
483	AC_HEADER_STDC
484
485	# Checks for library functions.
486	AC_FUNC_VPRINTF
487
488	AC_FUNC_ALLOCA
489
490	AC_CHECK_FUNCS(atexit on_exit)
491
492	AC_CHECK_SIZEOF(char)
493	AC_CHECK_SIZEOF(short)
494	AC_CHECK_SIZEOF(long)
495	AC_CHECK_SIZEOF(int)
496	AC_CHECK_SIZEOF(void *)
497	AC_CHECK_SIZEOF(long long)
498	AC_CHECK_SIZEOF(__int64)
499
500	if test x$ac_cv_sizeof_long = x8 \|\| test x$ac_cv_sizeof_long_long = x8 \|\| test x$ac_cv_sizeof___int64 = x8 ; then
501	:
502	else
503	AC_MSG_ERROR([
504	*** GLib requires a 64 bit type. You might want to consider
505	*** using the GNU C compiler.
506	])
507	fi
508
509	if test x$ac_cv_sizeof_long_long = x8; then
510	# long long is a 64 bit integer.
511	AC_MSG_CHECKING(for format to printf and scanf a guint64)
512	AC_CACHE_VAL(glib_cv_long_long_format,[
513	for format in ll q I64; do
514	AC_TRY_RUN([#include <stdio.h>
515	int main()
516	{
517	long long b, a = -0x3AFAFAFAFAFAFAFALL;
518	char buffer[1000];
519	sprintf (buffer, "%${format}u", a);
520	sscanf (buffer, "%${format}u", &b);
521	exit (b!=a);
522	}
523	],
524	[glib_cv_long_long_format=${format}
525	break],
526	[],[:])
527	done])
528	if test -n "$glib_cv_long_long_format"; then
529	AC_MSG_RESULT(%${glib_cv_long_long_format}u)
530	AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
531	if test x"$glib_cv_long_long_format" = xI64; then
532	AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
533	fi
534	else
535	AC_MSG_RESULT(none)
536	fi
537	elif test x$ac_cv_sizeof___int64 = x8; then
538	# __int64 is a 64 bit integer.
539	AC_MSG_CHECKING(for format to printf and scanf a guint64)
540	# We know this is MSVC, and what the formats are
541	glib_cv_long_long_format=I64
542	AC_MSG_RESULT(%${glib_cv_long_long_format}u)
543	AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
544	AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
545	fi
546
547	dnl long doubles were not used, and a portability problem
548	dnl AC_C_LONG_DOUBLE
549	AC_C_CONST
550
551	dnl ok, here we try to check whether the systems prototypes for
552	dnl malloc and friends actually match the prototypes provided
553	dnl by gmem.h (keep in sync). i currently only know how to check
554	dnl this reliably with gcc (-Werror), improvements for other
555	dnl compilers are apprechiated.
556	SANE_MALLOC_PROTOS=no
557	AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
558	glib_save_CFLAGS=$CFLAGS
559	if test "x$GCC" = "xyes"; then
560	CFLAGS="$CFLAGS -Werror"
561	AC_TRY_COMPILE([#include <stdlib.h>], [
562	void* (*my_calloc_p) (size_t, size_t) = calloc;
563	void* (*my_malloc_p) (size_t) = malloc;
564	void (my_free_p) (void) = free;
565	void* (my_realloc_p) (void, size_t) = realloc;
566	my_calloc_p = 0;
567	my_malloc_p = 0;
568	my_free_p = 0;
569	my_realloc_p = 0;
570	],
571	AC_DEFINE(SANE_MALLOC_PROTOS, 1,
572	[Define if you have correct malloc prototypes])
573	SANE_MALLOC_PROTOS=yes)
574	fi
575	AC_MSG_RESULT($SANE_MALLOC_PROTOS)
576	CFLAGS=$glib_save_CFLAGS
577
578	dnl
579	dnl check in which direction the stack grows
580	dnl
581	AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
582	AC_TRY_RUN([
583	volatile int a = 0, b = 0;
584	void foo (void);
585	int main () { volatile int y = 7; a = &y; foo (); return b > a; }
586	void foo (void) { volatile int x = 5; b = &x; }
587	],
588	glib_cv_stack_grows=no
589	,
590	glib_cv_stack_grows=yes
591	,)
592	])
593
594	dnl AC_C_INLINE is useless to us since it bails out too early, we need to
595	dnl truely know which ones of `inline', `__inline' and `__inline__' are
596	dnl actually supported.
597	AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
598	AC_COMPILE_IFELSE([
599	__inline int foo () { return 0; }
600	int main () { return foo (); }
601	],
602	glib_cv_has__inline=yes
603	,
604	glib_cv_has__inline=no
605	,)
606	])
607	case x$glib_cv_has__inline in
608	xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
609	esac
610	AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
611	AC_COMPILE_IFELSE([
612	__inline__ int foo () { return 0; }
613	int main () { return foo (); }
614	],
615	glib_cv_has__inline__=yes
616	,
617	glib_cv_has__inline__=no
618	,)
619	])
620	case x$glib_cv_has__inline__ in
621	xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
622	esac
623	AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
624	AC_COMPILE_IFELSE([
625	#undef inline
626	inline int foo () { return 0; }
627	int main () { return foo (); }
628	],
629	glib_cv_hasinline=yes
630	,
631	glib_cv_hasinline=no
632	,)
633	])
634	case x$glib_cv_hasinline in
635	xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
636	esac
637
638	# check for flavours of varargs macros
639	AC_MSG_CHECKING(for ISO C99 varargs macros in C)
640	AC_TRY_COMPILE([],[
641	int a(int p1, int p2, int p3);
642	#define call_a(...) a(1,__VA_ARGS__)
643	call_a(2,3);
644	],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
645	AC_MSG_RESULT($g_have_iso_c_varargs)
646
647	AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
648	if test "$CXX" = ""; then
649	dnl No C++ compiler
650	g_have_iso_cxx_varargs=no
651	else
652	AC_LANG_CPLUSPLUS
653	AC_TRY_COMPILE([],[
654	int a(int p1, int p2, int p3);
655	#define call_a(...) a(1,__VA_ARGS__)
656	call_a(2,3);
657	],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
658	AC_LANG_C
659	fi
660	AC_MSG_RESULT($g_have_iso_cxx_varargs)
661
662	AC_MSG_CHECKING(for GNUC varargs macros)
663	AC_TRY_COMPILE([],[
664	int a(int p1, int p2, int p3);
665	#define call_a(params...) a(1,params)
666	call_a(2,3);
667	],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
668	AC_MSG_RESULT($g_have_gnuc_varargs)
669
670	# check for bytesex stuff
671	AC_C_BIGENDIAN
672
673	# check for header files
674	AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h sys/types.h])
675	AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
676
677	# Checks for libcharset
678	jm_LANGINFO_CODESET
679	jm_GLIBC21
680	AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
681	AC_CHECK_FUNCS(setlocale)
682
683	# check additional type sizes
684	AC_CHECK_SIZEOF(size_t)
685
686	dnl Try to figure out whether gsize, gssize should be long or int
687	AC_MSG_CHECKING([for the appropriate definition for size_t])
688
689	case $ac_cv_sizeof_size_t in
690	$ac_cv_sizeof_short)
691	glib_size_type=short
692	;;
693	$ac_cv_sizeof_int)
694	glib_size_type=int
695	;;
696	$ac_cv_sizeof_long)
697	glib_size_type=long
698	;;
699	*) AC_MSG_ERROR([No type matching size_t in size])
700	;;
701	esac
702
703	dnl If int/long are the same size, we see which one produces
704	dnl warnings when used in the location as size_t. (This matters
705	dnl on AIX with xlc)
706	dnl
707	if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
708	test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
709	GLIB_CHECK_COMPILE_WARNINGS([
710	#include <stddef.h>
711	int main ()
712	{
713	size_t s = 1;
714	unsigned int *size_int = &s;
715	return (int)*size_int;
716	}
717	],glib_size_type=int,
718	[GLIB_CHECK_COMPILE_WARNINGS([
719	#include <stddef.h>
720	int main ()
721	{
722	size_t s = 1;
723	unsigned long *size_long = &s;
724	return (int)*size_long;
725	}
726	],glib_size_type=long)])
727	fi
728
729	AC_MSG_RESULT(unsigned $glib_size_type)
730
731	# Check for some functions
732	AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf setenv unsetenv getc_unlocked readlink symlink)
733
734	AC_FUNC_VSNPRINTF_C99
735	AC_FUNC_PRINTF_UNIX98
736
737	#
738	# Check whether to use an included printf
739	#
740
741	AC_ARG_ENABLE(included-printf,
742	[AC_HELP_STRING([--enable-included-printf],
743	[use included printf [default=auto]])],
744	enable_included_printf="$enableval")
745
746	need_included_printf=no
747	if test "x$enable_included_printf" = "xyes" ; then
748	need_included_printf=yes
749	fi
750	if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
751	need_included_printf=yes
752	fi
753	if test "$ac_cv_func_printf_unix98" != "yes" ; then
754	need_included_printf=yes
755	fi
756	if test "x$ac_cv_sizeof_long_long" = "x8" &&
757	test -z "$glib_cv_long_long_format" ; then
758	need_included_printf=yes
759	fi
760
761	if test "x$enable_included_printf" = "xno" &&
762	test "x$need_included_printf" = "xyes" ; then
763	AC_MSG_ERROR([
764	*** Your C library's printf doesn't appear to have the features that
765	*** GLib needs, but you specified --enable-included-printf=no.])
766	fi
767
768	enable_included_printf=$need_included_printf
769
770	AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
771	if test "$enable_included_printf" != "yes" ; then
772	AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
773	else
774	if test -z "$glib_cv_long_long_format" ; then
775	glib_cv_long_long_format="ll"
776	fi
777	AC_DEFINE(HAVE_VASPRINTF,1)
778	fi
779
780	# Checks needed for gnulib vasnprintf
781	bh_C_SIGNED
782	jm_AC_TYPE_LONG_LONG
783	gt_TYPE_LONGDOUBLE
784	gt_TYPE_WCHAR_T
785	gt_TYPE_WINT_T
786	AC_TYPE_SIZE_T
787	AC_CHECK_TYPES(ptrdiff_t)
788	jm_AC_TYPE_INTMAX_T
789	AC_CHECK_FUNCS(snprintf)
790	AC_FUNC_SNPRINTF_C99
791
792	# Check if bcopy can be used for overlapping copies, if memmove isn't found.
793	# The check is borrowed from the PERL Configure script.
794	if test "$ac_cv_func_memmove" != "yes"; then
795	AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
796	glib_cv_working_bcopy,[AC_TRY_RUN([
797	int main() {
798	char buf[128], abc[128], *b;
799	int len, off, align;
800	bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
801	for (align = 7; align >= 0; align--) {
802	for (len = 36; len; len--) {
803	b = buf+align; bcopy(abc, b, len);
804	for (off = 1; off <= len; off++) {
805	bcopy(b, b+off, len); bcopy(b+off, b, len);
806	if (bcmp(b, abc, len)) return(1);
807	}
808	}
809	}
810	return(0);
811	}],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
812
813	GLIB_ASSERT_SET(glib_cv_working_bcopy)
814	if test "$glib_cv_working_bcopy" = "yes"; then
815	AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
816	fi
817	fi
818
819	# Check for sys_errlist
820	AC_MSG_CHECKING(for sys_errlist)
821	AC_TRY_LINK(, [
822	extern char *sys_errlist[];
823	extern int sys_nerr;
824	sys_errlist[sys_nerr-1][0] = 0;
825	], glib_ok=yes, glib_ok=no)
826	AC_MSG_RESULT($glib_ok)
827	if test "$glib_ok" = "no"; then
828	AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
829	fi
830
831	# Check for sys_siglist
832	AC_MSG_CHECKING(for sys_siglist)
833	AC_TRY_LINK(, [
834	extern char *sys_siglist[];
835	exit (sys_siglist[0]);
836	], glib_ok=yes, glib_ok=no)
837	AC_MSG_RESULT($glib_ok)
838	if test "$glib_ok" = "no"; then
839	AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
840	fi
841
842	# Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
843	AC_MSG_CHECKING(for sys_siglist declaration)
844	AC_TRY_COMPILE([#include <signal.h>], [
845	strlen (sys_siglist[0]);
846	], glib_ok=yes, glib_ok=no)
847	AC_MSG_RESULT($glib_ok)
848	if test "$glib_ok" = "no"; then
849	AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
850	fi
851
852	# Check if <sys/select.h> needs to be included for fd_set
853	AC_MSG_CHECKING([for fd_set])
854	AC_TRY_COMPILE([#include <sys/types.h>],
855	[fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
856	if test "$gtk_ok" = "yes"; then
857	AC_MSG_RESULT([yes, found in sys/types.h])
858	else
859	AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
860	if test "$gtk_ok" = "yes"; then
861	# *** FIXME: give it a different name
862	AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
863	AC_MSG_RESULT([yes, found in sys/select.h])
864	else
865	AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
866	AC_MSG_RESULT(no)
867	fi
868	fi
869
870	dnl * check for sane realloc() *
871	AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
872	AC_TRY_RUN([#include <stdlib.h>
873	int main() {
874	return realloc (0, sizeof (int)) == 0;
875	}],
876	[glib_cv_sane_realloc=yes],
877	[glib_cv_sane_realloc=no],
878	[glib_cv_sane_realloc=yes])
879	])
880	if test x$glib_cv_sane_realloc = xyes; then
881	AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
882	fi
883
884	dnl Check for nl_langinfo and CODESET
885
886	AC_MSG_CHECKING([for nl_langinfo (CODESET)])
887	AC_TRY_COMPILE([#include <langinfo.h>],
888	[char *codeset = nl_langinfo (CODESET);],
889	AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
890	have_codeset=yes,
891	have_codeset=no)
892	AC_MSG_RESULT($have_codeset)
893
894
895	dnl ****************************************
896	dnl * strlcpy/strlcat *
897	dnl ****************************************
898	# Check for strlcpy
899	AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
900	AC_TRY_RUN([#include <stdlib.h>
901	#include <string.h>
902	int main() {
903	char p[10];
904	(void) strlcpy (p, "hi", 10);
905	if (strlcat (p, "bye", 0) != 3)
906	return 1;
907	return 0;
908	}], glib_cv_have_strlcpy=yes,
909	glib_cv_have_strlcpy=no,
910	glib_cv_have_strlcpy=no)])
911	if test "$glib_cv_have_strlcpy" = "yes"; then
912	AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
913	fi
914
915
916	dnl **********************
917	dnl * va_copy checks *
918	dnl **********************
919	dnl we currently check for all three va_copy possibilities, so we get
920	dnl all results in config.log for bug reports.
921	AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
922	AC_LINK_IFELSE([#include <stdarg.h>
923	void f (int i, ...) {
924	va_list args1, args2;
925	va_start (args1, i);
926	va_copy (args2, args1);
927	if (va_arg (args2, int) != 42 \|\| va_arg (args1, int) != 42)
928	exit (1);
929	va_end (args1); va_end (args2);
930	}
931	int main() {
932	f (0, 42);
933	return 0;
934	}],
935	[glib_cv_va_copy=yes],
936	[glib_cv_va_copy=no])
937	])
938	AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
939	AC_LINK_IFELSE([#include <stdarg.h>
940	void f (int i, ...) {
941	va_list args1, args2;
942	va_start (args1, i);
943	__va_copy (args2, args1);
944	if (va_arg (args2, int) != 42 \|\| va_arg (args1, int) != 42)
945	exit (1);
946	va_end (args1); va_end (args2);
947	}
948	int main() {
949	f (0, 42);
950	return 0;
951	}],
952	[glib_cv___va_copy=yes],
953	[glib_cv___va_copy=no])
954	])
955
956	if test "x$glib_cv_va_copy" = "xyes"; then
957	g_va_copy_func=va_copy
958	else if test "x$glib_cv___va_copy" = "xyes"; then
959	g_va_copy_func=__va_copy
960	fi
961	fi
962
963	if test -n "$g_va_copy_func"; then
964	AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
965	fi
966
967	AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
968	AC_TRY_RUN([#include <stdarg.h>
969	void f (int i, ...) {
970	va_list args1, args2;
971	va_start (args1, i);
972	args2 = args1;
973	if (va_arg (args2, int) != 42 \|\| va_arg (args1, int) != 42)
974	exit (1);
975	va_end (args1); va_end (args2);
976	}
977	int main() {
978	f (0, 42);
979	return 0;
980	}],
981	[glib_cv_va_val_copy=yes],
982	[glib_cv_va_val_copy=no],
983	[glib_cv_va_val_copy=yes])
984	])
985
986	if test "x$glib_cv_va_val_copy" = "xno"; then
987	AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
988	fi
989
990	dnl ***********************
991	dnl * g_module checks *
992	dnl ***********************
993	G_MODULE_LIBS=
994	G_MODULE_LIBS_EXTRA=
995	G_MODULE_PLUGIN_LIBS=
996	if test x"$glib_native_win32" = xyes; then
997	dnl No use for this on Win32
998	G_MODULE_LDFLAGS=
999	else
1000	G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) \| sh`
1001	fi
1002	dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1003	G_MODULE_NEED_USCORE=0
1004	G_MODULE_BROKEN_RTLD_GLOBAL=0
1005	G_MODULE_HAVE_DLERROR=0
1006	dnl *** force native WIN32 shared lib loader
1007	if test -z "$G_MODULE_IMPL"; then
1008	case "$host" in
1009	--mingw\|--cygwin) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1010	esac
1011	fi
1012	dnl *** force native AIX library loader
1013	dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1014	if test -z "$G_MODULE_IMPL"; then
1015	case "$host" in
1016	--aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1017	esac
1018	fi
1019	dnl *** dlopen() and dlsym() in system libraries
1020	if test -z "$G_MODULE_IMPL"; then
1021	AC_CHECK_FUNC(dlopen,
1022	[AC_CHECK_FUNC(dlsym,
1023	[G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1024	[])
1025	fi
1026	dnl *** load_image (BeOS)
1027	if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1028	AC_CHECK_LIB(root, load_image,
1029	[G_MODULE_LIBS="-lbe -lroot -lglib"
1030	G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1031	G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1032	G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1033	[])
1034	fi
1035	dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1036	if test -z "$G_MODULE_IMPL"; then
1037	AC_CHECK_FUNC(NSLinkModule,
1038	[G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1039	G_MODULE_NEED_USCORE=1],
1040	[])
1041	fi
1042	dnl *** dlopen() and dlsym() in libdl
1043	if test -z "$G_MODULE_IMPL"; then
1044	AC_CHECK_LIB(dl, dlopen,
1045	[AC_CHECK_LIB(dl, dlsym,
1046	[G_MODULE_LIBS=-ldl
1047	G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1048	[])
1049	fi
1050	dnl *** shl_load() in libdld (HP-UX)
1051	if test -z "$G_MODULE_IMPL"; then
1052	AC_CHECK_LIB(dld, shl_load,
1053	[G_MODULE_LIBS=-ldld
1054	G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1055	[])
1056	fi
1057	dnl *** additional checks for G_MODULE_IMPL_DL
1058	if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1059	LIBS_orig="$LIBS"
1060	LDFLAGS_orig="$LDFLAGS"
1061	LIBS="$G_MODULE_LIBS $LIBS"
1062	LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1063	dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1064	echo "void glib_plugin_test(void) { }" > plugin.c
1065	${SHELL} ./libtool --mode=compile ${CC} -shared \
1066	-export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1067	AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1068	glib_cv_rtldglobal_broken,[
1069	AC_TRY_RUN([
1070	#include <dlfcn.h>
1071	#ifndef RTLD_GLOBAL
1072	# define RTLD_GLOBAL 0
1073	#endif
1074	#ifndef RTLD_LAZY
1075	# define RTLD_LAZY 0
1076	#endif
1077	int glib_plugin_test;
1078	int main () {
1079	void handle, global, *local;
1080	global = &glib_plugin_test;
1081	handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL \| RTLD_LAZY);
1082	if (!handle) return 0;
1083	local = dlsym (handle, "glib_plugin_test");
1084	return global == local;
1085	} ],
1086	[glib_cv_rtldglobal_broken=no],
1087	[glib_cv_rtldglobal_broken=yes],
1088	[glib_cv_rtldglobal_broken=no])
1089	rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1090	rmdir .libs 2>/dev/null
1091	])
1092	if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1093	G_MODULE_BROKEN_RTLD_GLOBAL=1
1094	else
1095	G_MODULE_BROKEN_RTLD_GLOBAL=0
1096	fi
1097	dnl *** check whether we need preceeding underscores
1098	AC_CACHE_CHECK([for preceeding underscore in symbols],
1099	glib_cv_uscore,[
1100	AC_TRY_RUN([#include <dlfcn.h>
1101	int glib_underscore_test (void) { return 42; }
1102	int main() {
1103	void f1 = (void)0, f2 = (void)0, *handle;
1104	handle = dlopen ((void*)0, 0);
1105	if (handle) {
1106	f1 = dlsym (handle, "glib_underscore_test");
1107	f2 = dlsym (handle, "_glib_underscore_test");
1108	} return (!f2 \|\| f1);
1109	}],
1110	[glib_cv_uscore=yes],
1111	[glib_cv_uscore=no],
1112	[])
1113	rm -f plugin.c plugin.$ac_objext plugin.lo
1114	])
1115	GLIB_ASSERT_SET(glib_cv_uscore)
1116	if test "x$glib_cv_uscore" = "xyes"; then
1117	G_MODULE_NEED_USCORE=1
1118	else
1119	G_MODULE_NEED_USCORE=0
1120	fi
1121
1122	LDFLAGS="$LDFLAGS_orig"
1123	dnl *** check for having dlerror()
1124	AC_CHECK_FUNC(dlerror,
1125	[G_MODULE_HAVE_DLERROR=1],
1126	[G_MODULE_HAVE_DLERROR=0])
1127	LIBS="$LIBS_orig"
1128	fi
1129	dnl *** done, have we got an implementation?
1130	if test -z "$G_MODULE_IMPL"; then
1131	G_MODULE_IMPL=0
1132	G_MODULE_SUPPORTED=false
1133	else
1134	G_MODULE_SUPPORTED=true
1135	fi
1136
1137	AC_MSG_CHECKING(for the suffix of shared libraries)
1138	case "$host_os" in
1139	hpux9* \| hpux10* \| hpux11*) # taken from ltconfig
1140	glib_gmodule_suffix='sl'
1141	;;
1142	cygwin* \| mingw*)
1143	glib_gmodule_suffix='dll'
1144	;;
1145	aix*)
1146	glib_gmodule_suffix='a'
1147	;;
1148	*)
1149	glib_gmodule_suffix='so'
1150	;;
1151	esac
1152	AC_MSG_RESULT(.$glib_gmodule_suffix)
1153
1154	AC_SUBST(G_MODULE_SUPPORTED)
1155	AC_SUBST(G_MODULE_IMPL)
1156	AC_SUBST(G_MODULE_LIBS)
1157	AC_SUBST(G_MODULE_LIBS_EXTRA)
1158	AC_SUBST(G_MODULE_PLUGIN_LIBS)
1159	AC_SUBST(G_MODULE_LDFLAGS)
1160	AC_SUBST(G_MODULE_HAVE_DLERROR)
1161	AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1162	AC_SUBST(G_MODULE_NEED_USCORE)
1163	AC_SUBST(GLIB_DEBUG_FLAGS)
1164
1165	dnl **********************
1166	dnl * g_spawn checks *
1167	dnl **********************
1168
1169	AC_MSG_CHECKING(for gspawn implementation)
1170	case "$host" in
1171	--mingw*)
1172	GSPAWN=gspawn-win32.lo
1173	;;
1174	*)
1175	GSPAWN=gspawn.lo
1176	;;
1177	esac
1178	AC_MSG_RESULT($GSPAWN)
1179	AC_SUBST(GSPAWN)
1180
1181	dnl *************************
1182	dnl * GIOChannel checks *
1183	dnl *************************
1184
1185	AC_MSG_CHECKING(for GIOChannel implementation)
1186	case "$host" in
1187	--mingw*)
1188	GIO=giowin32.lo
1189	;;
1190	*)
1191	GIO=giounix.lo
1192	;;
1193	esac
1194	AC_MSG_RESULT($GIO)
1195	AC_SUBST(GIO)
1196
1197	dnl ****************************************
1198	dnl * platform dependent source checks *
1199	dnl ****************************************
1200
1201	AC_MSG_CHECKING(for platform-dependent source)
1202	case "$host" in
1203	--cygwin\|--mingw)
1204	PLATFORMDEP=gwin32.lo
1205	;;
1206	*)
1207	PLATFORMDEP=
1208	;;
1209	esac
1210	AC_MSG_RESULT($PLATFORMDEP)
1211	AC_SUBST(PLATFORMDEP)
1212
1213	AC_MSG_CHECKING([whether to compile timeloop])
1214	case "$host" in
1215	--cygwin\|--mingw)
1216	enable_timeloop=no
1217	;;
1218	*)
1219	enable_timeloop=yes
1220	;;
1221	esac
1222	AC_MSG_RESULT($enable_timeloop)
1223	AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1224
1225	AC_MSG_CHECKING([if building for some Win32 platform])
1226	case "$host" in
1227	--mingw\|--cygwin)
1228	platform_win32=yes
1229	;;
1230	*)
1231	platform_win32=no
1232	;;
1233	esac
1234	AC_MSG_RESULT($platform_win32)
1235	AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1236
1237	dnl ***********************
1238	dnl * g_thread checks *
1239	dnl ***********************
1240
1241	AC_ARG_WITH(threads,
1242	[AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
1243	[specify a thread implementation to use])],
1244	[if test "x$with_threads" = x; then
1245	want_threads=yes
1246	else
1247	want_threads=$with_threads
1248	fi],
1249	[want_threads=yes])
1250	if test "x$enable_threads" = "xno"; then
1251	want_threads=no
1252	fi
1253
1254	dnl error and warning message
1255	dnl *************************
1256
1257	THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1258	computer. GLib will not have a default thread implementation."
1259
1260	FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1261	platform (normally it's "_REENTRANT"). I'll not use any flag on
1262	compilation now, but then your programs might not work.
1263	Please provide information on how it is done on your system."
1264
1265	LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1266	"
1267
1268	LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1269	provide information on your thread implementation.
1270	You can also run 'configure --disable-threads'
1271	to compile without thread support."
1272
1273	FUNC_NO_GETPWUID_R="the 'g_get_(user_name\|real_name\|home_dir\|tmp_dir)'
1274	functions will not be MT-safe during their first call because
1275	there is no working 'getpwuid_r' on your system."
1276
1277	FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1278	because there is no 'localtime_r' on your system."
1279
1280	POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1281	crude surrogate will be used. If you happen to know a
1282	yield function for your system, please inform the GLib
1283	developers."
1284
1285	POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1286	threads on your system. Thus threads can only have the default
1287	priority. If you happen to know these main/max
1288	priorities, please inform the GLib developers."
1289
1290	AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1291	linking threaded applications. As GLib cannot do that
1292	automatically, you will get an linkg error everytime you are
1293	not using the right compiler. In that case you have to relink
1294	with the right compiler. Ususally just '_r' is appended
1295	to the compiler name."
1296
1297	dnl determination of thread implementation
1298	dnl ***************************************
1299
1300	# have_threads=no means no thread support
1301	# have_threads=none means no default thread implementation
1302
1303	have_threads=no
1304	if test "x$want_threads" = xyes \|\| test "x$want_threads" = xsolaris; then
1305	case $host in
1306	--solaris*)
1307	AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1308	;;
1309	esac
1310	fi
1311	if test "x$want_threads" = xyes \|\| test "x$want_threads" = xposix \
1312	\|\| test "x$want_threads" = xdce; then
1313	# -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1314	# -U_OSF_SOURCE is for Digital UNIX 4.0d
1315	GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1316	glib_save_CPPFLAGS="$CPPFLAGS"
1317	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1318	if test "x$have_threads" = xno; then
1319	AC_TRY_COMPILE([#include <pthread.h>],
1320	[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1321	have_threads=posix)
1322	fi
1323	if test "x$have_threads" = xno; then
1324	AC_TRY_COMPILE([#include <pthread.h>],
1325	[pthread_mutex_t m;
1326	pthread_mutex_init (&m, pthread_mutexattr_default);],
1327	have_threads=dce)
1328	fi
1329	# Tru64Unix requires -pthread to find pthread.h. See #103020
1330	CPPFLAGS="$CPPFLAGS -pthread"
1331	if test "x$have_threads" = xno; then
1332	AC_TRY_COMPILE([#include <pthread.h>],
1333	[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1334	have_threads=posix)
1335	fi
1336	CPPFLAGS="$glib_save_CPPFLAGS"
1337	fi
1338	if test "x$want_threads" = xyes \|\| test "x$want_threads" = xwin32; then
1339	case $host in
1340	--mingw*)
1341	have_threads=win32
1342	;;
1343	esac
1344	fi
1345	if test "x$want_threads" = xnone; then
1346	have_threads=none
1347	fi
1348
1349	AC_MSG_CHECKING(for thread implementation)
1350
1351	if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1352	AC_MSG_RESULT(none available)
1353	AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1354	else
1355	AC_MSG_RESULT($have_threads)
1356	fi
1357
1358
1359	dnl determination of G_THREAD_CFLAGS
1360	dnl ********************************
1361
1362	G_THREAD_LIBS=
1363	G_THREAD_LIBS_EXTRA=
1364	G_THREAD_CFLAGS=
1365
1366	dnl
1367	dnl Test program for basic POSIX threads functionality
1368	dnl
1369	m4_define([glib_thread_test],[
1370	#include <pthread.h>
1371	int check_me = 0;
1372	void* func(void* data) {check_me = 42; return &check_me;}
1373	int main()
1374	{ pthread_t t;
1375	void *ret;
1376	pthread_create (&t, $1, func, 0);
1377	pthread_join (t, &ret);
1378	exit (check_me != 42 \|\| ret != &check_me);
1379	}])
1380
1381	dnl
1382	dnl Test program for sched_get_priority_min()
1383	dnl
1384	m4_define([glib_sched_priority_test],[
1385	#include <sched.h>
1386	#include <errno.h>
1387	int main() {
1388	errno = 0;
1389	return sched_get_priority_min(SCHED_OTHER)==-1
1390	&& errno != 0;
1391	}])
1392
1393	if test x"$have_threads" != xno; then
1394
1395	if test x"$have_threads" = xposix; then
1396	# First we test for posix, whether -pthread or -pthreads do the trick as
1397	# both CPPFLAG and LIBS.
1398	# One of them does for most gcc versions and some other platforms/compilers
1399	# too and could be considered as the canonical way to go.
1400	case $host in
1401	--cygwin*)
1402	# skip cygwin -pthread or -pthreads test
1403	;;
1404	*)
1405	for flag in pthread pthreads; do
1406	glib_save_CFLAGS="$CFLAGS"
1407	CFLAGS="$CFLAGS -$flag"
1408	AC_TRY_RUN(glib_thread_test(0),
1409	glib_flag_works=yes,
1410	glib_flag_works=no,
1411	[AC_LINK_IFELSE(glib_thread_test(0),
1412	glib_flag_works=yes,
1413	glib_flag_works=no)])
1414	CFLAGS="$glib_save_CFLAGS"
1415	if test $glib_flag_works = yes ; then
1416	G_THREAD_CFLAGS=-$flag
1417	G_THREAD_LIBS=-$flag
1418	fi
1419	done
1420	;;
1421	esac
1422	fi
1423
1424	if test x"$G_THREAD_CFLAGS" = x; then
1425
1426	# The canonical -pthread[s] does not work. Try something different.
1427
1428	case $host in
1429	-aix)
1430	if test x"$GCC" = xyes; then
1431	# GCC 3.0 and above needs -pthread.
1432	# Should be coverd by the case above.
1433	# GCC 2.x and below needs -mthreads
1434	G_THREAD_CFLAGS="-mthreads"
1435	G_THREAD_LIBS=$G_THREAD_CFLAGS
1436	else
1437	# We are probably using the aix compiler. Normaly a
1438	# program would have to be compiled with the _r variant
1439	# of the corresponding compiler, but we as GLib cannot
1440	# do that: but the good news is that for compiling the
1441	# only difference is the added -D_THREAD_SAFE compile
1442	# option. This is according to the "C for AIX User's
1443	# Guide".
1444	G_THREAD_CFLAGS="-D_THREAD_SAFE"
1445	fi
1446	;;
1447	-dg-dgux) # DG/UX
1448	G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1449	;;
1450	-osf)
1451	# So we are using dce threads. posix threads are already
1452	# catched above.
1453	G_THREAD_CFLAGS="-threads"
1454	G_THREAD_LIBS=$G_THREAD_CFLAGS
1455	;;
1456	-solaris)
1457	if test x"$GCC" = xyes; then
1458	# We are using solaris threads. posix threads are
1459	# already catched above.
1460	G_THREAD_CFLAGS="-threads"
1461	else
1462	G_THREAD_CFLAGS="-mt"
1463	fi
1464	G_THREAD_LIBS=$G_THREAD_CFLAGS
1465	;;
1466	-sysv5uw7) # UnixWare 7
1467	# We are not using gcc with -pthread. Catched above.
1468	G_THREAD_CFLAGS="-Kthread"
1469	G_THREAD_LIBS=$G_THREAD_CFLAGS
1470	;;
1471	-mingw)
1472	# No flag needed when using MSVCRT.DLL
1473	G_THREAD_CFLAGS=""
1474	;;
1475	*)
1476	G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1477	;;
1478	esac
1479
1480	fi
1481
1482	# if we are not finding the localtime_r function, then we probably are
1483	# not using the proper multithread flag
1484
1485	glib_save_CPPFLAGS="$CPPFLAGS"
1486	CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1487
1488	# First we test, whether localtime_r is declared in time.h
1489	# directly. Then we test whether a macro localtime_r exists, in
1490	# which case localtime_r in the test program is replaced and thus
1491	# if we still find localtime_r in the output, it is not defined as
1492	# a macro.
1493
1494	AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1495	[AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1496	localtime_r(a,b)],
1497	AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1498
1499	CPPFLAGS="$glib_save_CPPFLAGS"
1500
1501	AC_MSG_CHECKING(thread related cflags)
1502	AC_MSG_RESULT($G_THREAD_CFLAGS)
1503	CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1504	fi
1505
1506	dnl determination of G_THREAD_LIBS
1507	dnl ******************************
1508
1509	mutex_has_default=no
1510	case $have_threads in
1511	posix\|dce)
1512	glib_save_CPPFLAGS="$CPPFLAGS"
1513	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1514	if test x"$G_THREAD_LIBS" = x; then
1515	case $host in
1516	-aix)
1517	# We are not using gcc (would have set G_THREAD_LIBS) and thus
1518	# probably using the aix compiler.
1519	AC_MSG_WARN($AIX_COMPILE_INFO)
1520	;;
1521	*)
1522	G_THREAD_LIBS=error
1523	glib_save_LIBS="$LIBS"
1524	for thread_lib in "" pthread pthread32 pthreads thread dce; do
1525	if test x"$thread_lib" = x; then
1526	add_thread_lib=""
1527	IN=""
1528	else
1529	add_thread_lib="-l$thread_lib"
1530	IN=" in -l$thread_lib"
1531	fi
1532	if test x"$have_threads" = xposix; then
1533	defattr=0
1534	else
1535	defattr=pthread_attr_default
1536	fi
1537
1538	LIBS="$add_thread_lib $glib_save_LIBS"
1539
1540	AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1541	AC_TRY_RUN(glib_thread_test($defattr),
1542	glib_result=yes,
1543	glib_result=no,
1544	[AC_LINK_IFELSE(glib_thread_test($defattr),
1545	glib_result=yes,
1546	glib_result=no)])
1547	AC_MSG_RESULT($glib_result)
1548
1549	if test "$glib_result" = "yes" ; then
1550	G_THREAD_LIBS="$add_thread_lib"
1551	break
1552	fi
1553	done
1554	if test "x$G_THREAD_LIBS" = xerror; then
1555	AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1556	fi
1557	LIBS="$glib_save_LIBS"
1558	;;
1559	esac
1560	fi
1561
1562	glib_save_LIBS="$LIBS"
1563	for thread_lib in "" rt rte; do
1564	if test x"$thread_lib" = x; then
1565	add_thread_lib=""
1566	IN=""
1567	else
1568	add_thread_lib="-l$thread_lib"
1569	IN=" in -l$thread_lib"
1570	fi
1571	LIBS="$add_thread_lib $glib_save_LIBS"
1572
1573	AC_MSG_CHECKING(for sched_get_priority_min$IN)
1574	AC_TRY_RUN(glib_sched_priority_test,
1575	glib_result=yes,
1576	glib_result=no,
1577	[AC_LINK_IFELSE(glib_sched_priority_test,
1578	glib_result=yes,
1579	glib_result=no)])
1580	AC_MSG_RESULT($glib_result)
1581
1582	if test "$glib_result" = "yes" ; then
1583	G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1584	posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1585	posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1586	break
1587	fi
1588	done
1589	LIBS="$glib_save_LIBS"
1590	mutex_has_default=yes
1591	mutex_default_type='pthread_mutex_t'
1592	mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1593	mutex_header_file='pthread.h'
1594	if test "x$have_threads" = "xposix"; then
1595	g_threads_impl="POSIX"
1596	else
1597	g_threads_impl="DCE"
1598	have_threads="posix"
1599	fi
1600	AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1601	CPPFLAGS="$glib_save_CPPFLAGS"
1602	;;
1603	solaris)
1604	mutex_has_default=yes
1605	mutex_default_type='mutex_t'
1606	mutex_default_init="DEFAULTMUTEX"
1607	mutex_header_file='thread.h'
1608	g_threads_impl="SOLARIS"
1609	;;
1610	win32)
1611	g_threads_impl="WIN32"
1612	;;
1613	none\|no)
1614	g_threads_impl="NONE"
1615	;;
1616	*)
1617	g_threads_impl="NONE"
1618	G_THREAD_LIBS=error
1619	;;
1620	esac
1621
1622	if test "x$G_THREAD_LIBS" = xerror; then
1623	AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1624	fi
1625
1626	case $host in
1627	--beos*)
1628	G_THREAD_LIBS="-lbe -lroot -lglib "
1629	G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1630	;;
1631	*)
1632	;;
1633	esac
1634
1635	AC_MSG_CHECKING(thread related libraries)
1636	AC_MSG_RESULT($G_THREAD_LIBS)
1637
1638	dnl check for mt safe function variants and some posix functions
1639	dnl ************************************************************
1640
1641	if test x"$have_threads" != xno; then
1642	glib_save_LIBS="$LIBS"
1643	# we are not doing the following for now, as this might require glib
1644	# to always be linked with the thread libs on some platforms.
1645	# LIBS="$LIBS $G_THREAD_LIBS"
1646	AC_CHECK_FUNCS(localtime_r)
1647	if test "$ac_cv_header_pwd_h" = "yes"; then
1648	AC_CACHE_CHECK([for posix getpwuid_r],
1649	ac_cv_func_posix_getpwuid_r,
1650	[AC_TRY_RUN([
1651	#include <errno.h>
1652	#include <pwd.h>
1653	int main () {
1654	char buffer[10000];
1655	struct passwd pwd, *pwptr = &pwd;
1656	int error;
1657	errno = 0;
1658	error = getpwuid_r (0, &pwd, buffer,
1659	sizeof (buffer), &pwptr);
1660	return (error < 0 && errno == ENOSYS)
1661	\|\| error == ENOSYS;
1662	} ],
1663	[ac_cv_func_posix_getpwuid_r=yes],
1664	[ac_cv_func_posix_getpwuid_r=no])])
1665	GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1666	if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1667	AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1668	[Have POSIX function getpwuid_r])
1669	else
1670	AC_CACHE_CHECK([for nonposix getpwuid_r],
1671	ac_cv_func_nonposix_getpwuid_r,
1672	[AC_TRY_LINK([#include <pwd.h>],
1673	[char buffer[10000];
1674	struct passwd pwd;
1675	getpwuid_r (0, &pwd, buffer,
1676	sizeof (buffer));],
1677	[ac_cv_func_nonposix_getpwuid_r=yes],
1678	[ac_cv_func_nonposix_getpwuid_r=no])])
1679	GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1680	if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1681	AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1682	[Have non-POSIX function getpwuid_r])
1683	fi
1684	fi
1685	fi
1686	LIBS="$G_THREAD_LIBS $LIBS"
1687	if test x"$have_threads" = xposix; then
1688	glib_save_CPPFLAGS="$CPPFLAGS"
1689	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1690	dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1691	GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1692	# This is not AC_CHECK_FUNC to also work with function
1693	# name mangling in header files.
1694	AC_MSG_CHECKING(for pthread_attr_setstacksize)
1695	AC_TRY_LINK([#include <pthread.h>],
1696	[pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1697	[AC_MSG_RESULT(yes)
1698	AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1699	[Have function pthread_attr_setstacksize])],
1700	[AC_MSG_RESULT(no)])
1701	AC_MSG_CHECKING(for minimal/maximal thread priority)
1702	if test x"$posix_priority_min" = x; then
1703	AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1704	PX_PRIO_MIN],,[
1705	posix_priority_min=PX_PRIO_MIN
1706	posix_priority_max=PX_PRIO_MAX])
1707	fi
1708	if test x"$posix_priority_min" = x; then
1709	# AIX
1710	AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1711	PTHREAD_PRIO_MIN],,[
1712	posix_priority_min=PTHREAD_PRIO_MIN
1713	posix_priority_max=PTHREAD_PRIO_MAX])
1714	fi
1715	if test x"$posix_priority_min" = x; then
1716	AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1717	PRI_OTHER_MIN],,[
1718	posix_priority_min=PRI_OTHER_MIN
1719	posix_priority_max=PRI_OTHER_MAX])
1720	fi
1721	if test x"$posix_priority_min" = x; then
1722	AC_MSG_RESULT(none found)
1723	AC_MSG_WARN($POSIX_NO_PRIORITIES)
1724	posix_priority_min=-1
1725	posix_priority_max=-1
1726	else
1727	AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1728	AC_MSG_CHECKING(for pthread_setschedparam)
1729	AC_TRY_LINK([#include <pthread.h>],
1730	[pthread_t t; pthread_setschedparam(t, 0, NULL)],
1731	[AC_MSG_RESULT(yes)
1732	AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1733	AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1734	[AC_MSG_RESULT(no)
1735	AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1736	fi
1737	posix_yield_func=none
1738	AC_MSG_CHECKING(for posix yield function)
1739	for yield_func in sched_yield pthread_yield_np pthread_yield \
1740	thr_yield; do
1741	AC_TRY_LINK([#include <pthread.h>],
1742	[$yield_func()],
1743	[posix_yield_func="$yield_func"
1744	break])
1745	done
1746	if test x"$posix_yield_func" = xnone; then
1747	AC_MSG_RESULT(none found)
1748	AC_MSG_WARN($POSIX_NO_YIELD)
1749	posix_yield_func="g_usleep(1000)"
1750	else
1751	AC_MSG_RESULT($posix_yield_func)
1752	posix_yield_func="$posix_yield_func()"
1753	fi
1754	AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1755	CPPFLAGS="$glib_save_CPPFLAGS"
1756
1757	elif test x"$have_threads" = xwin32; then
1758	# It's a pointer to a private struct
1759	GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1760	elif test x"$have_threads" = xsolaris; then
1761	GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1762	fi
1763
1764	LIBS="$glib_save_LIBS"
1765
1766	# now spit out all the warnings.
1767	if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1768	test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1769	AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1770	fi
1771	if test "$ac_cv_func_localtime_r" != "yes"; then
1772	AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1773	fi
1774	fi
1775
1776	if test x"$glib_cv_sizeof_system_thread" = x; then
1777	# use a pointer as a fallback.
1778	GLIB_SIZEOF(,void *, system_thread)
1779	fi
1780
1781	#
1782	# Hack to deal with:
1783	#
1784	# a) GCC < 3.3 for Linux doesn't include -lpthread when
1785	# building shared libraries with linux.
1786	# b) libtool doesn't recognize -pthread as a library dependency.
1787	#
1788	case $host in
1789	--linux*)
1790	G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS \| sed s/-pthread/-lpthread/`"
1791	;;
1792	*)
1793	G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS \| sed s/-pthread/-Wc,-pthread/`"
1794	;;
1795	esac
1796
1797	AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1798	[Source file containing theread implementation])
1799	AC_SUBST(G_THREAD_CFLAGS)
1800	AC_SUBST(G_THREAD_LIBS)
1801	AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1802	AC_SUBST(G_THREAD_LIBS_EXTRA)
1803
1804	dnl **********************************************
1805	dnl * GDefaultMutex setup and initialization *
1806	dnl **********************************************
1807	dnl
1808	dnl if mutex_has_default = yes, we also got
1809	dnl mutex_default_type, mutex_default_init and mutex_header_file
1810	if test $mutex_has_default = yes ; then
1811	glib_save_CPPFLAGS="$CPPFLAGS"
1812	glib_save_LIBS="$LIBS"
1813	LIBS="$G_THREAD_LIBS $LIBS"
1814	CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1815	GLIB_SIZEOF([#include <$mutex_header_file>],
1816	$mutex_default_type,
1817	gmutex)
1818	GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1819	$mutex_default_type,
1820	gmutex,
1821	$glib_cv_sizeof_gmutex,
1822	$mutex_default_init)
1823	if test x"$glib_cv_byte_contents_gmutex" = xno; then
1824	mutex_has_default=no
1825	fi
1826	CPPFLAGS="$glib_save_CPPFLAGS"
1827	LIBS="$glib_save_LIBS"
1828	fi
1829
1830	dnl ********************************
1831	dnl *** g_atomic_* tests for gcc ***
1832	dnl ********************************
1833
1834	AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1835
1836	if test x"$GCC" = xyes; then
1837	case $host_cpu in
1838	i386)
1839	AC_MSG_RESULT([none])
1840	glib_memory_barrier_needed=no
1841	;;
1842	i?86)
1843	AC_MSG_RESULT([i486])
1844	AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1845	[i486 atomic implementation])
1846	glib_memory_barrier_needed=no
1847	;;
1848	sparc*)
1849	SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1850	when you are using a sparc with v9 instruction set (most
1851	sparcs nowadays). This will make the code for atomic
1852	operations much faster. The resulting code will not run
1853	on very old sparcs though."
1854
1855	AC_LINK_IFELSE([[
1856	main ()
1857	{
1858	int tmp1, tmp2, tmp3;
1859	__asm__ __volatile__("casx [%2], %0, %1"
1860	: "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1861	}]],
1862	AC_MSG_RESULT([sparcv9])
1863	AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1864	[sparcv9 atomic implementation]),
1865	AC_MSG_RESULT([no])
1866	AC_MSG_WARN([[$SPARCV9_WARNING]]))
1867	glib_memory_barrier_needed=yes
1868	;;
1869	alpha*)
1870	AC_MSG_RESULT([alpha])
1871	AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1872	[alpha atomic implementation])
1873	glib_memory_barrier_needed=yes
1874	;;
1875	x86_64)
1876	AC_MSG_RESULT([x86_64])
1877	AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1878	[x86_64 atomic implementation])
1879	glib_memory_barrier_needed=no
1880	;;
1881	powerpc*)
1882	AC_MSG_RESULT([powerpc])
1883	AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1884	[powerpc atomic implementation])
1885	glib_memory_barrier_needed=yes
1886	;;
1887	ia64)
1888	AC_MSG_RESULT([ia64])
1889	AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1890	[ia64 atomic implementation])
1891	glib_memory_barrier_needed=yes
1892	;;
1893	*)
1894	AC_MSG_RESULT([none])
1895	glib_memory_barrier_needed=yes
1896	;;
1897	esac
1898	fi
1899
1900	dnl ****************************************
1901	dnl *** GLib POLL* compatibility defines ***
1902	dnl ****************************************
1903
1904	glib_poll_includes=["
1905	#include <sys/types.h>
1906	#include <sys/poll.h>
1907	"]
1908
1909	if test $ac_cv_header_sys_types_h = yes &&
1910	test $ac_cv_header_sys_poll_h = yes ; then
1911	glib_failed=false
1912	GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1913	GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1914	GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1915	GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1916	GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1917	GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1918	if $glib_failed ; then
1919	AC_MSG_ERROR([Could not determine values for POLL* constants])
1920	fi
1921	else
1922	glib_cv_value_POLLIN=1
1923	glib_cv_value_POLLOUT=4
1924	glib_cv_value_POLLPRI=2
1925	glib_cv_value_POLLERR=8
1926	glib_cv_value_POLLHUP=16
1927	glib_cv_value_POLLNVAL=32
1928	fi
1929
1930	dnl **********************
1931	dnl * Win32 API libs *
1932	dnl **********************
1933
1934	case $host in
1935	--cygwin*)
1936	G_LIBS_EXTRA="-luser32 -lkernel32"
1937	;;
1938	--mingw*)
1939	G_LIBS_EXTRA="-lwsock32"
1940	;;
1941	*)
1942	G_LIBS_EXTRA=""
1943	;;
1944	esac
1945	AC_SUBST(G_LIBS_EXTRA)
1946
1947	dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1948	dnl since we need it for g_iconv()
1949
1950	AC_MSG_CHECKING([for EILSEQ])
1951	AC_TRY_COMPILE([
1952	#include <errno.h>
1953	],
1954	[
1955	int error = EILSEQ;
1956	], have_eilseq=yes, have_eilseq=no);
1957	AC_MSG_RESULT($have_eilseq)
1958
1959	dnl ******************************************************************
1960	dnl * Look for glib-genmarshal in PATH if we are cross-compiling *
1961	dnl ******************************************************************
1962
1963	AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1964
1965	if test $cross_compiling = yes; then
1966	AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1967	if test x$GLIB_GENMARSHAL = xno; then
1968	AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1969	fi
1970	fi
1971
1972	dnl **************************
1973	dnl * Checks for gtk-doc *
1974	dnl **************************
1975
1976	GTK_DOC_CHECK([1.0])
1977
1978	AC_ARG_ENABLE(man,
1979	[AC_HELP_STRING([--enable-man],
1980	[regenerate man pages from Docbook [default=no]])],enable_man=yes,
1981	enable_man=no)
1982
1983	if test "${enable_man}" != no; then
1984	dnl
1985	dnl Check for xsltproc
1986	dnl
1987	AC_PATH_PROG([XSLTPROC], [xsltproc])
1988	if test -z "$XSLTPROC"; then
1989	enable_man=no
1990	fi
1991
1992	dnl check for DocBook DTD and stylesheets in the local catalog.
1993	JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
1994	[DocBook XML DTD V4.1.2],,enable_man=no)
1995	JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
1996	[DocBook XSL Stylesheets],,enable_man=no)
1997	fi
1998
1999	AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2000
2001	dnl ******************************
2002	dnl * output the whole stuff *
2003	dnl ******************************
2004
2005	dnl this section will only be run if config.status is invoked with no
2006	dnl arguments, or with "glibconfig.h" as an argument.
2007	AC_CONFIG_COMMANDS([glibconfig.h],
2008	[
2009	outfile=glibconfig.h-tmp
2010	cat > $outfile <<\_______EOF
2011	/* glibconfig.h
2012	*
2013	* This is a generated file. Please modify 'configure.in'
2014	*/
2015
2016	#ifndef __G_LIBCONFIG_H__
2017	#define __G_LIBCONFIG_H__
2018
2019	#include <glib/gmacros.h>
2020
2021	_______EOF
2022
2023	if test x$glib_limits_h = xyes; then
2024	echo '#include <limits.h>' >> $outfile
2025	fi
2026	if test x$glib_float_h = xyes; then
2027	echo '#include <float.h>' >> $outfile
2028	fi
2029	if test x$glib_values_h = xyes; then
2030	echo '#include <values.h>' >> $outfile
2031	fi
2032	if test "$glib_header_alloca_h" = "yes"; then
2033	echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2034	fi
2035	if test x$glib_sys_poll_h = xyes; then
2036	echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2037	fi
2038
2039	cat >> $outfile <<_______EOF
2040
2041	G_BEGIN_DECLS
2042
2043	#define G_MINFLOAT $glib_mf
2044	#define G_MAXFLOAT $glib_Mf
2045	#define G_MINDOUBLE $glib_md
2046	#define G_MAXDOUBLE $glib_Md
2047	#define G_MINSHORT $glib_ms
2048	#define G_MAXSHORT $glib_Ms
2049	#define G_MAXUSHORT $glib_Mus
2050	#define G_MININT $glib_mi
2051	#define G_MAXINT $glib_Mi
2052	#define G_MAXUINT $glib_Mui
2053	#define G_MINLONG $glib_ml
2054	#define G_MAXLONG $glib_Ml
2055	#define G_MAXULONG $glib_Mul
2056
2057	_______EOF
2058
2059
2060	### this should always be true in a modern C/C++ compiler
2061	cat >>$outfile <<_______EOF
2062	typedef signed char gint8;
2063	typedef unsigned char guint8;
2064	_______EOF
2065
2066
2067	if test -n "$gint16"; then
2068	cat >>$outfile <<_______EOF
2069	typedef signed $gint16 gint16;
2070	typedef unsigned $gint16 guint16;
2071	#define G_GINT16_MODIFIER $gint16_modifier
2072	#define G_GINT16_FORMAT $gint16_format
2073	#define G_GUINT16_FORMAT $guint16_format
2074	_______EOF
2075	fi
2076
2077
2078	if test -n "$gint32"; then
2079	cat >>$outfile <<_______EOF
2080	typedef signed $gint32 gint32;
2081	typedef unsigned $gint32 guint32;
2082	#define G_GINT32_MODIFIER $gint32_modifier
2083	#define G_GINT32_FORMAT $gint32_format
2084	#define G_GUINT32_FORMAT $guint32_format
2085	_______EOF
2086	fi
2087
2088	cat >>$outfile <<_______EOF
2089	#define G_HAVE_GINT64 1 /* deprecated, always true */
2090
2091	${glib_extension}typedef signed $gint64 gint64;
2092	${glib_extension}typedef unsigned $gint64 guint64;
2093
2094	#define G_GINT64_CONSTANT(val) $gint64_constant
2095	_______EOF
2096
2097	if test x$gint64_format != x ; then
2098	cat >>$outfile <<_______EOF
2099	#define G_GINT64_MODIFIER $gint64_modifier
2100	#define G_GINT64_FORMAT $gint64_format
2101	#define G_GUINT64_FORMAT $guint64_format
2102	_______EOF
2103	else
2104	cat >>$outfile <<_______EOF
2105	#undef G_GINT64_MODIFIER
2106	#undef G_GINT64_FORMAT
2107	#undef G_GUINT64_FORMAT
2108	_______EOF
2109	fi
2110
2111	cat >>$outfile <<_______EOF
2112
2113	#define GLIB_SIZEOF_VOID_P $glib_void_p
2114	#define GLIB_SIZEOF_LONG $glib_long
2115	#define GLIB_SIZEOF_SIZE_T $glib_size_t
2116
2117	_______EOF
2118
2119	cat >>$outfile <<_______EOF
2120	typedef signed $glib_size_type_define gssize;
2121	typedef unsigned $glib_size_type_define gsize;
2122	#define G_GSIZE_MODIFIER $gsize_modifier
2123	#define G_GSSIZE_FORMAT $gssize_format
2124	#define G_GSIZE_FORMAT $gsize_format
2125
2126	#define G_MAXSIZE G_MAXU$glib_msize_type
2127	_______EOF
2128
2129	if test -z "$glib_unknown_void_p"; then
2130	cat >>$outfile <<_______EOF
2131
2132	#define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2133	#define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2134
2135	#define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2136	#define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2137	_______EOF
2138	else
2139	echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2140	fi
2141
2142
2143
2144	cat >>$outfile <<_______EOF
2145	$glib_atexit
2146	$glib_memmove
2147	$glib_defines
2148	$glib_os
2149
2150	$glib_vacopy
2151
2152	#ifdef __cplusplus
2153	#define G_HAVE_INLINE 1
2154	#else /* !__cplusplus */
2155	$glib_inline
2156	#endif /* !__cplusplus */
2157
2158	_______EOF
2159
2160	if test x$g_have_iso_c_varargs = xyes ; then
2161	cat >>$outfile <<_______EOF
2162	#ifndef __cplusplus
2163	# define G_HAVE_ISO_VARARGS 1
2164	#endif
2165	_______EOF
2166	fi
2167	if test x$g_have_iso_cxx_varargs = xyes ; then
2168	cat >>$outfile <<_______EOF
2169	#ifdef __cplusplus
2170	# define G_HAVE_ISO_VARARGS 1
2171	#endif
2172	_______EOF
2173	fi
2174	if test x$g_have_gnuc_varargs = xyes ; then
2175	cat >>$outfile <<_______EOF
2176
2177	/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2178	* is passed ISO vararg support is turned off, and there is no work
2179	* around to turn it on, so we unconditionally turn it off.
2180	*/
2181	#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2182	# undef G_HAVE_ISO_VARARGS
2183	#endif
2184
2185	#define G_HAVE_GNUC_VARARGS 1
2186	_______EOF
2187	fi
2188
2189	case x$g_stack_grows in
2190	xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2191	*) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2192	esac
2193
2194
2195	echo >>$outfile
2196	if test x$g_have_eilseq = xno; then
2197	cat >>$outfile <<_______EOF
2198	#ifndef EILSEQ
2199	/* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2200	* The correspondence between this and the corresponding definition
2201	* in libiconv is essential.
2202	*/
2203	# define EILSEQ ENOENT
2204	#endif
2205	_______EOF
2206
2207	fi
2208
2209	echo >>$outfile
2210	if test x$g_mutex_has_default = xyes; then
2211	cat >>$outfile <<_______EOF
2212	$g_enable_threads_def G_THREADS_ENABLED
2213	#define G_THREADS_IMPL_$g_threads_impl_def
2214	typedef struct _GStaticMutex GStaticMutex;
2215	struct _GStaticMutex
2216	{
2217	struct _GMutex *runtime_mutex;
2218	union {
2219	char pad[[$g_mutex_sizeof]];
2220	double dummy_double;
2221	void *dummy_pointer;
2222	long dummy_long;
2223	} static_mutex;
2224	};
2225	#define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2226	#define g_static_mutex_get_mutex(mutex) \\
2227	(g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2228	g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2229	_______EOF
2230	else
2231	cat >>$outfile <<_______EOF
2232	$g_enable_threads_def G_THREADS_ENABLED
2233	#define G_THREADS_IMPL_$g_threads_impl_def
2234	typedef struct _GMutex* GStaticMutex;
2235	#define G_STATIC_MUTEX_INIT NULL
2236	#define g_static_mutex_get_mutex(mutex) \\
2237	(g_static_mutex_get_mutex_impl_shortcut (mutex))
2238	_______EOF
2239	fi
2240
2241	cat >>$outfile <<_______EOF
2242	/* This represents a system thread as used by the implementation. An
2243	* alien implementaion, as loaded by g_thread_init can only count on
2244	* "sizeof (gpointer)" bytes to store their info. We however need more
2245	* for some of our native implementations. */
2246	typedef union _GSystemThread GSystemThread;
2247	union _GSystemThread
2248	{
2249	char data[[$g_system_thread_sizeof]];
2250	double dummy_double;
2251	void *dummy_pointer;
2252	long dummy_long;
2253	};
2254	_______EOF
2255	if test x"$g_memory_barrier_needed" != xno; then
2256	echo >>$outfile
2257	echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2258	fi
2259
2260	echo >>$outfile
2261	g_bit_sizes="16 32 64"
2262	for bits in $g_bit_sizes; do
2263	cat >>$outfile <<_______EOF
2264	#define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2265	#define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2266	#define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2267	#define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2268	_______EOF
2269	done
2270
2271	cat >>$outfile <<_______EOF
2272	#define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2273	#define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2274	#define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2275	#define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2276	#define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2277	#define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2278	#define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2279	#define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2280	#define G_BYTE_ORDER $g_byte_order
2281
2282	#define GLIB_SYSDEF_POLLIN =$g_pollin
2283	#define GLIB_SYSDEF_POLLOUT =$g_pollout
2284	#define GLIB_SYSDEF_POLLPRI =$g_pollpri
2285	#define GLIB_SYSDEF_POLLHUP =$g_pollhup
2286	#define GLIB_SYSDEF_POLLERR =$g_pollerr
2287	#define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2288
2289	#define G_MODULE_SUFFIX "$g_module_suffix"
2290
2291	typedef $g_pid_type GPid;
2292
2293	G_END_DECLS
2294
2295	#endif /* GLIBCONFIG_H */
2296	_______EOF
2297
2298
2299	if cmp -s $outfile glibconfig.h; then
2300	AC_MSG_NOTICE([glibconfig.h is unchanged])
2301	rm -f $outfile
2302	else
2303	mv $outfile glibconfig.h
2304	fi
2305	],[
2306
2307	# Note that if two cases are the same, case goes with the first one.
2308	# Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2309	# on variable expansion in case labels. Look at the generated config.status
2310	# for a hint.
2311
2312	if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2313	glib_header_alloca_h="$ac_cv_working_alloca_h"
2314	else
2315	glib_header_alloca_h="$ac_cv_header_alloca_h"
2316	fi
2317
2318	case xyes in
2319	x$ac_cv_header_float_h)
2320	glib_float_h=yes
2321	glib_mf=FLT_MIN glib_Mf=FLT_MAX
2322	glib_md=DBL_MIN glib_Md=DBL_MAX
2323	;;
2324	x$ac_cv_header_values_h)
2325	glib_values_h=yes
2326	glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2327	glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2328	;;
2329	esac
2330
2331	case xyes in
2332	x$ac_cv_header_limits_h)
2333	glib_limits_h=yes
2334	glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2335	glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2336	glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2337	;;
2338	x$ac_cv_header_values_h)
2339	glib_values_h=yes
2340	glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2341	glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2342	glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2343	;;
2344	esac
2345
2346	if test x$ac_cv_header_sys_poll_h = xyes ; then
2347	glib_sys_poll_h=yes
2348	fi
2349
2350	case 2 in
2351	$ac_cv_sizeof_short)
2352	gint16=short
2353	gint16_modifier='"h"'
2354	gint16_format='"hi"'
2355	guint16_format='"hu"'
2356	;;
2357	$ac_cv_sizeof_int)
2358	gint16=int
2359	gint16_modifier='""'
2360	gint16_format='"i"'
2361	guint16_format='"u"'
2362	;;
2363	esac
2364	case 4 in
2365	$ac_cv_sizeof_short)
2366	gint32=short
2367	gint32_modifier='"h"'
2368	gint32_format='"hi"'
2369	guint32_format='"hu"'
2370	;;
2371	$ac_cv_sizeof_int)
2372	gint32=int
2373	gint32_modifier='""'
2374	gint32_format='"i"'
2375	guint32_format='"u"'
2376	;;
2377	$ac_cv_sizeof_long)
2378	gint32=long
2379	gint32_modifier='"l"'
2380	gint32_format='"li"'
2381	guint32_format='"lu"'
2382	;;
2383	esac
2384	case 8 in
2385	$ac_cv_sizeof_int)
2386	gint64=int
2387	gint64_modifier='""'
2388	gint64_format='"i"'
2389	guint64_format='"u"'
2390	glib_extension=
2391	gint64_constant='(val)'
2392	;;
2393	$ac_cv_sizeof_long)
2394	gint64=long
2395	gint64_modifier='"l"'
2396	gint64_format='"li"'
2397	guint64_format='"lu"'
2398	glib_extension=
2399	gint64_constant='(val##L)'
2400	;;
2401	$ac_cv_sizeof_long_long)
2402	gint64='long long'
2403	if test -n "$glib_cv_long_long_format"; then
2404	gint64_modifier='"'$glib_cv_long_long_format'"'
2405	gint64_format='"'$glib_cv_long_long_format'i"'
2406	guint64_format='"'$glib_cv_long_long_format'u"'
2407	fi
2408	glib_extension='G_GNUC_EXTENSION '
2409	gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2410	;;
2411	$ac_cv_sizeof___int64)
2412	gint64='__int64'
2413	if test -n "$glib_cv_long_long_format"; then
2414	gint64_modifier='"'$glib_cv_long_long_format'"'
2415	gint64_format='"'$glib_cv_long_long_format'i"'
2416	guint64_format='"'$glib_cv_long_long_format'u"'
2417	fi
2418	glib_extension=
2419	gint64_constant='(val##i64)'
2420	;;
2421	esac
2422	glib_size_t=$ac_cv_sizeof_size_t
2423	glib_size_type_define=$glib_size_type
2424	glib_void_p=$ac_cv_sizeof_long
2425	glib_long=$ac_cv_sizeof_void_p
2426
2427	case $glib_size_type in
2428	short)
2429	gsize_modifier='"h"'
2430	gsize_format='"hu"'
2431	gssize_format='"hi"'
2432	glib_msize_type='SHRT'
2433	;;
2434	int)
2435	gsize_modifier='""'
2436	gsize_format='"u"'
2437	gssize_format='"i"'
2438	glib_msize_type='INT'
2439	;;
2440	long)
2441	gsize_modifier='"l"'
2442	gsize_format='"lu"'
2443	gssize_format='"li"'
2444	glib_msize_type='LONG'
2445	;;
2446	esac
2447
2448	gintbits=`expr $ac_cv_sizeof_int \* 8`
2449	glongbits=`expr $ac_cv_sizeof_long \* 8`
2450
2451
2452	case $ac_cv_sizeof_void_p in
2453	$ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
2454	$ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2455	*) glib_unknown_void_p=yes ;;
2456	esac
2457
2458
2459	case xyes in
2460	x$ac_cv_func_atexit)
2461	glib_atexit="
2462	#ifdef NeXT /* @#%@! NeXTStep */
2463	# define g_ATEXIT(proc) (!atexit (proc))
2464	#else
2465	# define g_ATEXIT(proc) (atexit (proc))
2466	#endif"
2467	;;
2468	x$ac_cv_func_on_exit)
2469	glib_atexit="
2470	#define g_ATEXIT(proc) (on_exit ((void ()(int, void))(proc), NULL))"
2471	;;
2472	esac
2473
2474	case xyes in
2475	x$ac_cv_func_memmove)
2476	glib_memmove='
2477	#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2478	;;
2479	x$glib_cv_working_bcopy)
2480	glib_memmove="
2481	/* memmove isn't available, but bcopy can copy overlapping memory regions */
2482	#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2483	;;
2484	*)
2485	glib_memmove="
2486	/* memmove isn't found and bcopy can't copy overlapping memory regions,
2487	* so we have to roll our own copy routine. */
2488	void g_memmove (void* dest, const void * src, unsigned long len);"
2489	;;
2490	esac
2491
2492	glib_defines="
2493	#define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2494	#define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2495	#define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2496	"
2497
2498	case xyes in
2499	x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
2500	x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
2501	*) glib_vacopy=''
2502	esac
2503
2504	if test x$glib_cv_va_val_copy = xno; then
2505	glib_vacopy="\$glib_vacopy
2506	#define G_VA_COPY_AS_ARRAY 1"
2507	fi
2508
2509	if test x$glib_cv_hasinline = xyes; then
2510	glib_inline='#define G_HAVE_INLINE 1'
2511	fi
2512	if test x$glib_cv_has__inline = xyes; then
2513	glib_inline="\$glib_inline
2514	#define G_HAVE___INLINE 1"
2515	fi
2516	if test x$glib_cv_has__inline__ = xyes; then
2517	glib_inline="\$glib_inline
2518	#define G_HAVE___INLINE__ 1"
2519	fi
2520
2521	g_have_gnuc_varargs=$g_have_gnuc_varargs
2522	g_have_iso_c_varargs=$g_have_iso_c_varargs
2523	g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2524
2525	case xyes in
2526	x$ac_cv_c_bigendian)
2527	g_byte_order=G_BIG_ENDIAN
2528	g_bs_native=BE
2529	g_bs_alien=LE
2530	;;
2531	*)
2532	g_byte_order=G_LITTLE_ENDIAN
2533	g_bs_native=LE
2534	g_bs_alien=BE
2535	;;
2536	esac
2537
2538	g_pollin=$glib_cv_value_POLLIN
2539	g_pollout=$glib_cv_value_POLLOUT
2540	g_pollpri=$glib_cv_value_POLLPRI
2541	g_pollhup=$glib_cv_value_POLLHUP
2542	g_pollerr=$glib_cv_value_POLLERR
2543	g_pollnval=$glib_cv_value_POLLNVAL
2544
2545	g_stack_grows=$glib_cv_stack_grows
2546
2547	g_have_eilseq=$have_eilseq
2548
2549	case x$have_threads in
2550	xno) g_enable_threads_def="#undef";;
2551	*) g_enable_threads_def="#define";;
2552	esac
2553
2554	g_threads_impl_def=$g_threads_impl
2555
2556	g_mutex_has_default="$mutex_has_default"
2557	g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2558	g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2559	g_mutex_contents="$glib_cv_byte_contents_gmutex"
2560
2561	g_memory_barrier_needed="$glib_memory_barrier_needed"
2562
2563	g_module_suffix="$glib_gmodule_suffix"
2564
2565	g_pid_type="$glib_pid_type"
2566	case $host in
2567	--beos*)
2568	glib_os="#define G_OS_BEOS"
2569	;;
2570	--cygwin*)
2571	glib_os="#define G_OS_UNIX
2572	#define G_PLATFORM_WIN32
2573	#define G_WITH_CYGWIN"
2574	;;
2575	--mingw*)
2576	glib_os="#define G_OS_WIN32
2577	#define G_PLATFORM_WIN32"
2578	;;
2579	*)
2580	glib_os="#define G_OS_UNIX"
2581	;;
2582	esac
2583	])
2584
2585	AC_CONFIG_FILES([
2586	glib-2.0.pc
2587	glib-2.0-uninstalled.pc
2588	gmodule-2.0.pc
2589	gmodule-2.0-uninstalled.pc
2590	gthread-2.0.pc
2591	gthread-2.0-uninstalled.pc
2592	gobject-2.0.pc
2593	gobject-2.0-uninstalled.pc
2594	glib-zip
2595	glib-gettextize
2596	Makefile
2597	build/Makefile
2598	build/win32/Makefile
2599	build/win32/dirent/Makefile
2600	glib/Makefile
2601	glib/libcharset/Makefile
2602	glib/gnulib/Makefile
2603	gmodule/Makefile
2604	gmodule/gmoduleconf.h
2605	gobject/Makefile
2606	gobject/glib-mkenums
2607	gthread/Makefile
2608	po/Makefile.in
2609	docs/Makefile
2610	docs/reference/Makefile
2611	docs/reference/glib/Makefile
2612	docs/reference/glib/version.xml
2613	docs/reference/gobject/Makefile
2614	docs/reference/gobject/version.xml
2615	tests/Makefile
2616	tests/gobject/Makefile
2617	m4macros/Makefile
2618	])
2619
2620	AC_CONFIG_COMMANDS([chmod-scripts],
2621	[chmod 0755 glib-zip
2622	chmod 0755 glib-gettextize
2623	chmod 0755 gobject/glib-mkenums])
2624
2625	# we want to invoke this macro solely so that the config.status script
2626	# and automake generated makefiles know about these generated files.
2627	# They are only needed to distcheck the package
2628	if false; then
2629	AC_CONFIG_FILES([
2630	INSTALL
2631	README
2632	config.h.win32
2633	glibconfig.h.win32
2634	glib/makefile.msc
2635	glib/glib.rc
2636	gmodule/makefile.msc
2637	gmodule/gmodule.rc
2638	gobject/makefile.msc
2639	gobject/gobject.rc
2640	gthread/makefile.msc
2641	gthread/gthread.rc
2642	tests/makefile.msc
2643	])
2644	fi
2645
2646	AC_OUTPUT

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format