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