Context Navigation

configure.in @ 18780

Visit:

Revision 18780, 67.8 KB checked in by ghudson, 22 years ago (diff)
Merge with glib 2.2.1.

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

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

Download in other formats:

Original Format