1 # Process this file with autoconf to produce a configure script.
2 # require autoconf 2.54
5 dnl ***********************************
6 dnl *** include special GLib macros ***
7 dnl ***********************************
9 m4_define(glib_configure_in)
12 # The following version number definitions apply to GLib, GModule, GObject
13 # and GThread as a whole, so if changes occoured in any of them, they are all
14 # treated with the same interface and binary age.
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.
24 m4_define([glib_major_version], [2])
25 m4_define([glib_minor_version], [17])
26 m4_define([glib_micro_version], [3])
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])
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)])
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
48 AC_INIT(glib, [glib_version],
49 [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
51 AC_CONFIG_SRCDIR([glib/glib.h])
53 # Save this value here, since automake will set cflags later
54 cflags_set=${CFLAGS+set}
56 AM_INIT_AUTOMAKE([no-define])
58 # Specify a configuration file
59 AM_CONFIG_HEADER([config.h])
62 GLIB_MAJOR_VERSION=glib_major_version
63 GLIB_MINOR_VERSION=glib_minor_version
64 GLIB_MICRO_VERSION=glib_micro_version
65 GLIB_INTERFACE_AGE=glib_interface_age
66 GLIB_BINARY_AGE=glib_binary_age
67 GLIB_VERSION=glib_version
69 AC_SUBST(GLIB_MAJOR_VERSION)
70 AC_SUBST(GLIB_MINOR_VERSION)
71 AC_SUBST(GLIB_MICRO_VERSION)
72 AC_SUBST(GLIB_VERSION)
73 AC_SUBST(GLIB_INTERFACE_AGE)
74 AC_SUBST(GLIB_BINARY_AGE)
76 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
77 [Define to the GLIB major version])
78 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
79 [Define to the GLIB minor version])
80 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
81 [Define to the GLIB micro version])
82 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
83 [Define to the GLIB interface age])
84 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
85 [Define to the GLIB binary age])
88 LT_RELEASE=glib_lt_release
89 LT_CURRENT=glib_lt_current
90 LT_REVISION=glib_lt_revision
92 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
97 AC_SUBST(LT_CURRENT_MINUS_AGE)
99 dnl Initialize maintainer mode
104 AC_MSG_CHECKING([for the BeOS])
107 glib_native_beos="yes"
110 glib_native_beos="no"
113 AC_MSG_RESULT([$glib_native_beos])
117 AC_MSG_CHECKING([for Win32])
120 glib_native_win32=yes
121 glib_pid_type='void *'
122 # Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
123 # don't seem to be quite good enough, at least not in mingw-runtime-3.14.
124 # (Sorry, I don't know exactly what is the problem, but it is related to
125 # floating point formatting and decimal point vs. comma.)
126 # The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
127 # rigorous enough to notice, though.
128 # So preset the autoconf cache variables.
129 ac_cv_func_vsnprintf_c99=no
130 ac_cv_func_snprintf_c99=no
143 AC_MSG_RESULT([$glib_native_win32])
146 AC_MSG_CHECKING([for Mac OS X Carbon support])
148 #include <Carbon/Carbon.h>
149 #include <CoreServices/CoreServices.h>
150 ], glib_have_carbon=yes)
152 AC_MSG_RESULT([$glib_have_carbon])
154 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
155 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
156 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
157 AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
159 if test "$glib_native_win32" = "yes"; then
160 AC_CHECK_TOOL(WINDRES, windres, no)
161 if test "$WINDRES" = no; then
162 AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
164 AC_CHECK_TOOL(NM, nm, no)
165 if test "$NM" = no; then
166 AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
168 AC_CHECK_TOOL(RANLIB, ranlib, :)
169 AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
171 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
173 if test "$glib_native_win32" != yes; then
174 # libtool option to control which symbols are exported
175 # right now, symbols starting with _ are not exported
176 LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
178 # We currently use .def files on Windows
179 LIBTOOL_EXPORT_OPTIONS=
181 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
183 if test "x$glib_have_carbon" = "xyes"; then
184 AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
185 LDFLAGS="$LDFLAGS -framework Carbon"
189 dnl declare --enable-* args and collect ac_help strings
191 AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
192 [turn on debugging @<:@default=glib_debug_default@:>@]),,
193 enable_debug=glib_debug_default)
195 AC_ARG_ENABLE(gc_friendly,
196 [AC_HELP_STRING([--enable-gc-friendly],
197 [turn on garbage collector friendliness [default=no]])],,
198 [enable_gc_friendly=no])
199 AC_ARG_ENABLE(mem_pools,
200 [AC_HELP_STRING([--disable-mem-pools],
201 [disable all glib memory pools])],,
202 [disable_mem_pools=no])
203 AC_ARG_ENABLE(threads,
204 [AC_HELP_STRING([--enable-threads],
205 [turn on basic thread support [default=yes]
206 ([=no] will override --with-threads)])],,
207 [enable_threads=yes])
208 AC_ARG_ENABLE(rebuilds,
209 [AC_HELP_STRING([--disable-rebuilds],
210 [disable all source autogeneration rules])],,
211 [enable_rebuilds=yes])
212 AC_ARG_ENABLE(visibility,
213 [AC_HELP_STRING([--disable-visibility],
214 [don't use ELF visibility attributes])],,
215 [enable_visibility=yes])
217 if test "x$enable_threads" != "xyes"; then
221 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
222 if test "x$enable_gc_friendly" = "xyes"; then
223 AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
229 AC_MSG_CHECKING([whether to disable memory pools])
230 if test "x$disable_mem_pools" = "xno"; then
233 AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
234 AC_SUBST(DISABLE_MEM_POOLS)
238 dnl Checks for programs.
241 dnl Check for a working C++ compiler, but do not bail out, if none is found.
242 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
245 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
246 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
258 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
259 if test x$PKG_CONFIG = xno ; then
260 AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
263 if $PKG_CONFIG --atleast-pkgconfig-version 0.16 ; then
266 AC_MSG_ERROR([*** pkg-config too old; version 0.16 or better required.])
269 if test "x$enable_debug" = "xyes"; then
270 if test x$cflags_set != xset ; then
272 *[[\ \ ]]-g[[\ \ ]]*) ;;
273 *) CFLAGS="$CFLAGS -g" ;;
277 GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
279 GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
281 if test "x$enable_debug" = "xno"; then
282 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
286 if test "x$enable_visibility" = "xno"; then
287 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
290 # Ensure MSVC-compatible struct packing convention is used when
291 # compiling for Win32 with gcc.
292 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
293 # gcc2 uses "-fnative-struct".
294 if test x"$glib_native_win32" = xyes; then
295 if test x"$GCC" = xyes; then
297 AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
298 if test -z "$ac_cv_prog_CC"; then
301 our_gcc="$ac_cv_prog_CC"
303 case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
305 if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
306 msnative_struct='-fnative-struct'
310 if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
311 msnative_struct='-mms-bitfields'
315 if test x"$msnative_struct" = x ; then
316 AC_MSG_RESULT([no way])
317 AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
319 CFLAGS="$CFLAGS $msnative_struct"
320 AC_MSG_RESULT([${msnative_struct}])
324 GLIB_EXTRA_CFLAGS="${msnative_struct}"
325 AC_SUBST(GLIB_EXTRA_CFLAGS)
329 # define a MAINT-like variable REBUILD which is set if Perl
330 # and awk are found, so autogenerated sources can be rebuilt
332 AC_CHECK_PROGS(PERL, [perl5 perl])
333 # We would like indent, but don't require it.
334 AC_CHECK_PROG(INDENT, indent, indent)
336 if test "x$enable_rebuilds" = "xyes" && \
338 $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
339 test -n "$AWK" ; then
344 # Need full path to Perl for glib-mkenums
346 if test "x$PERL" != x ; then
347 AC_PATH_PROG(PERL_PATH, [$PERL])
349 if test "x$PERL_PATH" = x ; then
350 PERL_PATH="/usr/bin/env perl"
354 # Need suitable python path for greport
355 AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
358 dnl ***********************
359 dnl *** Tests for iconv ***
360 dnl ***********************
362 dnl We do this before the gettext checks, to avoid distortion
364 dnl On Windows we use a native implementation
366 if test x"$glib_native_win32" = xyes; then
369 AC_ARG_WITH(libiconv,
370 [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
371 [use the libiconv library])],,
372 [with_libiconv=maybe])
375 case $with_libiconv in
377 # Check in the C library first
378 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
379 # Check if we have GNU libiconv
380 if test $found_iconv = "no"; then
381 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
383 # Check if we have a iconv in -liconv, possibly from vendor
384 if test $found_iconv = "no"; then
385 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
389 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
392 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
395 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
399 if test "x$found_iconv" = "xno" ; then
400 AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
405 AC_ARG_ENABLE(iconv-cache,
406 [AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
407 [cache iconv descriptors [default=auto]])],,
408 [enable_iconv_cache=auto])
410 AC_MSG_CHECKING([Whether to cache iconv descriptors])
411 case $enable_iconv_cache in
413 if test $ac_cv_gnu_library_2_1 = yes; then
414 enable_iconv_cache=no
416 enable_iconv_cache=yes
421 *) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
425 if test $enable_iconv_cache = yes; then
426 AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
429 AC_MSG_RESULT($enable_iconv_cache)
436 ALL_LINGUAS="`grep -v '^#' "$srcdir/po/LINGUAS" | tr '\n' ' '`"
437 AC_SUBST([CONFIG_STATUS_DEPENDENCIES],['$(top_srcdir)/po/LINGUAS'])
440 if test "$gt_cv_have_gettext" != "yes" ; then
442 *** You must have either have gettext support in your C library, or use the
443 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
447 LIBS="$INTLLIBS $LIBS"
449 GETTEXT_PACKAGE=glib20
450 AC_SUBST(GETTEXT_PACKAGE)
451 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
452 [Define the gettext package to be used])
454 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
457 dnl Now we are done with gettext checks, figure out ICONV_LIBS
460 if test x"$glib_native_win32" != xyes; then
461 if test x$with_libiconv != xno ; then
462 case " $INTLLIBS " in
463 *[[\ \ ]]-liconv[[\ \ ]]*) ;;
464 *) ICONV_LIBS="-liconv" ;;
470 case $with_libiconv in
472 AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
475 AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
479 dnl Initialize libtool
484 if test "x$GCC" = "xyes"; then
486 *[[\ \ ]]-Wall[[\ \ ]]*) ;;
487 *) CFLAGS="$CFLAGS -Wall" ;;
491 CPPFLAGS="$CPPFLAGS -DG_DISABLE_SINGLE_INCLUDES"
493 if test "$glib_native_win32" = "yes"; then
494 if test x$enable_static = xyes -a x$enable_shared = xyes; then
495 AC_MSG_ERROR([Can not build both shared and static at the same time on Windows.])
497 if test x$enable_static = xyes; then
498 glib_win32_static_compilation=yes
499 GLIB_WIN32_STATIC_COMPILATION_DEFINE="#define GLIB_STATIC_COMPILATION 1
500 #define GOBJECT_STATIC_COMPILATION 1"
501 AC_SUBST(GLIB_WIN32_STATIC_COMPILATION_DEFINE)
504 AM_CONDITIONAL(OS_WIN32_AND_DLL_COMPILATION, [test x$glib_native_win32 = xyes -a x$glib_win32_static_compilation != xyes])
507 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
509 if test $cross_compiling != yes ; then
510 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
513 AC_TRY_RUN([#include <math.h>
514 int main (void) { return (log(1) != log(1.)); }],
515 AC_MSG_RESULT(none needed),
516 glib_save_CFLAGS=$CFLAGS
517 CFLAGS="$CFLAGS -std1"
518 AC_TRY_RUN([#include <math.h>
519 int main (void) { return (log(1) != log(1.)); }],
520 AC_MSG_RESULT(-std1),
522 CFLAGS=$glib_save_CFLAGS
524 [No ANSI prototypes found in library. (-std1 didn't work.)])
530 dnl NeXTStep cc seems to need this
531 AC_MSG_CHECKING([for extra flags for POSIX compliance])
532 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
533 AC_MSG_RESULT(none needed),
534 glib_save_CFLAGS=$CFLAGS
535 CFLAGS="$CFLAGS -posix"
536 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
537 AC_MSG_RESULT(-posix),
539 CFLAGS=$glib_save_CFLAGS
540 AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
542 # Checks for header files.
545 # Checks for library functions.
549 AC_CHECK_FUNCS(posix_memalign)
550 AC_CHECK_FUNCS(memalign)
551 AC_CHECK_FUNCS(valloc)
553 AC_CHECK_FUNCS(atexit on_exit)
555 AC_CHECK_FUNCS(timegm gmtime_r)
557 AC_CHECK_SIZEOF(char)
558 AC_CHECK_SIZEOF(short)
559 AC_CHECK_SIZEOF(long)
561 AC_CHECK_SIZEOF(void *)
562 AC_CHECK_SIZEOF(long long)
563 AC_CHECK_SIZEOF(__int64)
565 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
569 *** GLib requires a 64 bit type. You might want to consider
570 *** using the GNU C compiler.
574 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
575 # long long is a 64 bit integer.
576 AC_MSG_CHECKING(for format to printf and scanf a guint64)
577 AC_CACHE_VAL(glib_cv_long_long_format,[
578 for format in ll q I64; do
579 AC_TRY_RUN([#include <stdio.h>
582 long long b, a = -0x3AFAFAFAFAFAFAFALL;
584 sprintf (buffer, "%${format}u", a);
585 sscanf (buffer, "%${format}u", &b);
589 [glib_cv_long_long_format=${format}
593 if test -n "$glib_cv_long_long_format"; then
594 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
595 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
596 if test x"$glib_cv_long_long_format" = xI64; then
597 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
602 elif test x$ac_cv_sizeof___int64 = x8; then
603 # __int64 is a 64 bit integer.
604 AC_MSG_CHECKING(for format to printf and scanf a guint64)
605 # We know this is MSVCRT.DLL, and what the formats are
606 glib_cv_long_long_format=I64
607 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
608 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
609 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
612 dnl long doubles were not used, and a portability problem
616 dnl ok, here we try to check whether the systems prototypes for
617 dnl malloc and friends actually match the prototypes provided
618 dnl by gmem.h (keep in sync). i currently only know how to check
619 dnl this reliably with gcc (-Werror), improvements for other
620 dnl compilers are apprechiated.
621 SANE_MALLOC_PROTOS=no
622 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
623 glib_save_CFLAGS=$CFLAGS
624 if test "x$GCC" = "xyes"; then
625 CFLAGS="$CFLAGS -Werror"
626 AC_TRY_COMPILE([#include <stdlib.h>], [
627 void* (*my_calloc_p) (size_t, size_t) = calloc;
628 void* (*my_malloc_p) (size_t) = malloc;
629 void (*my_free_p) (void*) = free;
630 void* (*my_realloc_p) (void*, size_t) = realloc;
636 AC_DEFINE(SANE_MALLOC_PROTOS, 1,
637 [Define if you have correct malloc prototypes])
638 SANE_MALLOC_PROTOS=yes)
640 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
641 CFLAGS=$glib_save_CFLAGS
644 dnl check in which direction the stack grows
646 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
648 volatile int *a = 0, *b = 0;
650 int main () { volatile int y = 7; a = &y; foo (); return b > a; }
651 void foo (void) { volatile int x = 5; b = &x; }
653 glib_cv_stack_grows=no
655 glib_cv_stack_grows=yes
659 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
660 dnl truely know which ones of `inline', `__inline' and `__inline__' are
661 dnl actually supported.
662 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
664 __inline int foo () { return 0; }
665 int main () { return foo (); }
667 glib_cv_has__inline=yes
669 glib_cv_has__inline=no
672 case x$glib_cv_has__inline in
673 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
675 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
677 __inline__ int foo () { return 0; }
678 int main () { return foo (); }
680 glib_cv_has__inline__=yes
682 glib_cv_has__inline__=no
685 case x$glib_cv_has__inline__ in
686 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
688 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
691 inline int foo () { return 0; }
692 int main () { return foo (); }
694 glib_cv_hasinline=yes
699 case x$glib_cv_hasinline in
700 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
703 # if we can use inline functions in headers
704 AC_MSG_CHECKING(if inline functions in headers work)
706 #if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
708 # define inline __inline__
709 #elif !defined (G_HAVE_INLINE)
711 # if defined (G_HAVE___INLINE__)
712 # define inline __inline__
713 # elif defined (G_HAVE___INLINE)
714 # define inline __inline
718 int glib_test_func2 (int);
721 glib_test_func1 (void) {
722 return glib_test_func2 (1);
728 }],[g_can_inline=yes],[g_can_inline=no])
729 AC_MSG_RESULT($g_can_inline)
731 dnl *** check for working do while(0) macros ***
732 AC_CACHE_CHECK([for working do while(0) macros], g_cv_support_dowhile_macros, [
734 #define STMT_START do
735 #define STMT_END while(0)
736 #define STMT_TEST STMT_START { i = 0; } STMT_END
737 int main(void) { int i = 1; STMT_TEST; return i; }],
738 [g_cv_support_dowhile_macros=yes],
739 [g_cv_support_dowhile_macros=no],
740 [g_cv_support_dowhile_macros=yes])
742 if test x$g_cv_support_dowhile_macros = xyes; then
743 AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
746 # check for flavours of varargs macros
747 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
749 int a(int p1, int p2, int p3);
750 #define call_a(...) a(1,__VA_ARGS__)
752 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
753 AC_MSG_RESULT($g_have_iso_c_varargs)
755 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
756 if test "$CXX" = ""; then
758 g_have_iso_cxx_varargs=no
762 int a(int p1, int p2, int p3);
763 #define call_a(...) a(1,__VA_ARGS__)
765 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
768 AC_MSG_RESULT($g_have_iso_cxx_varargs)
770 AC_MSG_CHECKING(for GNUC varargs macros)
772 int a(int p1, int p2, int p3);
773 #define call_a(params...) a(1,params)
775 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
776 AC_MSG_RESULT($g_have_gnuc_varargs)
778 # check for GNUC visibility support
779 AC_MSG_CHECKING(for GNUC visibility attribute)
780 GLIB_CHECK_COMPILE_WARNINGS([
782 __attribute__ ((visibility ("hidden")))
787 __attribute__ ((visibility ("internal")))
792 __attribute__ ((visibility ("protected")))
797 __attribute__ ((visibility ("default")))
801 int main (int argc, char **argv)
809 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
810 AC_MSG_RESULT($g_have_gnuc_visibility)
811 AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
813 AC_MSG_CHECKING([whether using Sun Studio C compiler])
814 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
816 # include "error: this is not Sun Studio."
818 ]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
819 AC_MSG_RESULT($g_have_sunstudio_visibility)
820 AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
822 # check for bytesex stuff
825 # check for header files
826 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h grp.h sys/param.h sys/poll.h sys/resource.h])
827 AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
828 AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h sched.h malloc.h])
829 AC_CHECK_HEADERS([sys/vfs.h sys/mount.h sys/vmount.h sys/statfs.h sys/statvfs.h])
830 AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h sys/sysctl.h fstab.h])
832 # check for structure fields
833 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])
834 AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename],,, [#include <sys/types.h>
835 #include <sys/stat.h>
837 #ifdef HAVE_SYS_PARAM_H
838 #include <sys/param.h>
840 #ifdef HAVE_SYS_MOUNT_H
841 #include <sys/mount.h>
843 # struct statvfs.f_basetype is available on Solaris but not for Linux.
844 AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
846 # Checks for libcharset
849 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
850 AC_CHECK_FUNCS(setlocale)
852 # check additional type sizes
853 AC_CHECK_SIZEOF(size_t)
855 dnl Try to figure out whether gsize, gssize should be long or int
856 AC_MSG_CHECKING([for the appropriate definition for size_t])
858 case $ac_cv_sizeof_size_t in
868 *) AC_MSG_ERROR([No type matching size_t in size])
872 dnl If int/long are the same size, we see which one produces
873 dnl warnings when used in the location as size_t. (This matters
876 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
877 test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
878 GLIB_CHECK_COMPILE_WARNINGS([
879 #if defined(_AIX) && !defined(__GNUC__)
880 #pragma options langlvl=stdc89
886 unsigned int *size_int = &s;
887 return (int)*size_int;
889 ],glib_size_type=int,
890 [GLIB_CHECK_COMPILE_WARNINGS([
891 #if defined(_AIX) && !defined(__GNUC__)
892 #pragma options langlvl=stdc89
898 unsigned long *size_long = &s;
899 return (int)*size_long;
901 ],glib_size_type=long)])
904 AC_MSG_RESULT(unsigned $glib_size_type)
906 # Check for some functions
907 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk)
908 AC_CHECK_FUNCS(chown lchown fchmod fchown link statvfs statfs utimes getgrgid getpwuid)
909 AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getmntinfo)
910 # Check for high-resolution sleep functions
911 AC_CHECK_FUNCS(nanosleep nsleep)
913 AC_CHECK_HEADERS(crt_externs.h)
914 AC_CHECK_FUNCS(_NSGetEnviron)
916 AC_FUNC_VSNPRINTF_C99
917 AC_FUNC_PRINTF_UNIX98
920 dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
922 if test "$ac_cv_func_statfs" = yes ; then
923 AC_MSG_CHECKING([number of arguments to statfs()])
924 AC_TRY_COMPILE([#include <unistd.h>
925 #ifdef HAVE_SYS_PARAM_H
926 #include <sys/param.h>
928 #ifdef HAVE_SYS_VFS_H
931 #ifdef HAVE_SYS_MOUNT_H
932 #include <sys/mount.h>
934 #ifdef HAVE_SYS_STATFS_H
935 #include <sys/statfs.h>
936 #endif], [struct statfs st;
937 statfs(NULL, &st);],[
939 AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
940 AC_TRY_COMPILE([#include <unistd.h>
941 #ifdef HAVE_SYS_PARAM_H
942 #include <sys/param.h>
944 #ifdef HAVE_SYS_VFS_H
947 #ifdef HAVE_SYS_MOUNT_H
948 #include <sys/mount.h>
950 #ifdef HAVE_SYS_STATFS_H
951 #include <sys/statfs.h>
952 #endif], [struct statfs st;
953 statfs(NULL, &st, sizeof (st), 0);],[
955 AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
956 AC_MSG_RESULT(unknown)
957 AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
961 # Check whether to use an included printf
964 AC_ARG_ENABLE(included-printf,
965 [AC_HELP_STRING([--enable-included-printf],
966 [use included printf [default=auto]])],
967 enable_included_printf="$enableval")
969 need_included_printf=no
970 if test "x$enable_included_printf" = "xyes" ; then
971 need_included_printf=yes
973 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
974 need_included_printf=yes
976 if test "$ac_cv_func_printf_unix98" != "yes" ; then
977 need_included_printf=yes
979 if test "x$ac_cv_sizeof_long_long" = "x8" &&
980 test -z "$glib_cv_long_long_format" ; then
981 need_included_printf=yes
984 if test "x$enable_included_printf" = "xno" &&
985 test "x$need_included_printf" = "xyes" ; then
987 *** Your C library's printf doesn't appear to have the features that
988 *** GLib needs, but you specified --enable-included-printf=no.])
991 enable_included_printf=$need_included_printf
993 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
994 if test "$enable_included_printf" != "yes" ; then
995 AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
997 if test -z "$glib_cv_long_long_format" ; then
998 glib_cv_long_long_format="ll"
1000 AC_DEFINE(HAVE_VASPRINTF,1)
1003 # Checks needed for gnulib vasnprintf
1005 jm_AC_TYPE_LONG_LONG
1010 AC_CHECK_TYPES(ptrdiff_t)
1012 AC_CHECK_FUNCS([snprintf wcslen])
1013 AC_FUNC_SNPRINTF_C99
1015 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
1016 # The check is borrowed from the PERL Configure script.
1017 if test "$ac_cv_func_memmove" != "yes"; then
1018 AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
1019 glib_cv_working_bcopy,[AC_TRY_RUN([
1021 char buf[128], abc[128], *b;
1022 int len, off, align;
1023 bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
1024 for (align = 7; align >= 0; align--) {
1025 for (len = 36; len; len--) {
1026 b = buf+align; bcopy(abc, b, len);
1027 for (off = 1; off <= len; off++) {
1028 bcopy(b, b+off, len); bcopy(b+off, b, len);
1029 if (bcmp(b, abc, len)) return(1);
1034 }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
1036 GLIB_ASSERT_SET(glib_cv_working_bcopy)
1037 if test "$glib_cv_working_bcopy" = "yes"; then
1038 AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
1042 # Check for sys_errlist
1043 AC_MSG_CHECKING(for sys_errlist)
1045 extern char *sys_errlist[];
1046 extern int sys_nerr;
1047 sys_errlist[sys_nerr-1][0] = 0;
1048 ], glib_ok=yes, glib_ok=no)
1049 AC_MSG_RESULT($glib_ok)
1050 if test "$glib_ok" = "no"; then
1051 AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
1054 # Check for sys_siglist
1055 AC_MSG_CHECKING(for sys_siglist)
1057 extern char *sys_siglist[];
1058 exit (sys_siglist[0]);
1059 ], glib_ok=yes, glib_ok=no)
1060 AC_MSG_RESULT($glib_ok)
1061 if test "$glib_ok" = "no"; then
1062 AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
1065 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
1066 AC_MSG_CHECKING(for sys_siglist declaration)
1067 AC_TRY_COMPILE([#include <signal.h>], [
1068 strlen (sys_siglist[0]);
1069 ], glib_ok=yes, glib_ok=no)
1070 AC_MSG_RESULT($glib_ok)
1071 if test "$glib_ok" = "no"; then
1072 AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1075 # Check if <sys/select.h> needs to be included for fd_set
1076 AC_MSG_CHECKING([for fd_set])
1077 AC_TRY_COMPILE([#include <sys/types.h>],
1078 [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1079 if test "$gtk_ok" = "yes"; then
1080 AC_MSG_RESULT([yes, found in sys/types.h])
1082 AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1083 if test "$gtk_ok" = "yes"; then
1084 # *** FIXME: give it a different name
1085 AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1086 AC_MSG_RESULT([yes, found in sys/select.h])
1088 AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1093 dnl *** check for sane realloc() ***
1094 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1095 AC_TRY_RUN([#include <stdlib.h>
1097 return realloc (0, sizeof (int)) == 0;
1099 [glib_cv_sane_realloc=yes],
1100 [glib_cv_sane_realloc=no],
1101 [glib_cv_sane_realloc=yes])
1103 if test x$glib_cv_sane_realloc = xyes; then
1104 AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1107 dnl Check for nl_langinfo and CODESET
1108 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1109 AC_TRY_COMPILE([#include <langinfo.h>],
1110 [char *codeset = nl_langinfo (CODESET);],
1111 [glib_cv_langinfo_codeset=yes],
1112 [glib_cv_langinfo_codeset=no])])
1113 if test x$glib_cv_langinfo_codeset = xyes; then
1114 AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1117 dnl ****************************************
1118 dnl *** posix_memalign ***
1119 dnl ****************************************
1120 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1121 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1122 glib_cv_compliant_posix_memalign=0
1123 if test "$ac_cv_func_posix_memalign" = "yes" ; then
1125 #define _XOPEN_SOURCE 600
1126 #include <stdlib.h> /* posix_memalign() should be defined here */
1127 /* some systems break if #include <malloc.h> used */
1128 static void test_memalign (size_t boundary, size_t size) {
1130 if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1136 test_memalign ( 128, 128 - 2 * sizeof (void*));
1137 test_memalign ( 256, 256 - 2 * sizeof (void*));
1138 test_memalign ( 512, 512 - 2 * sizeof (void*));
1139 test_memalign ( 1024, 1024 - 2 * sizeof (void*));
1140 test_memalign ( 2048, 2048 - 2 * sizeof (void*));
1141 test_memalign ( 4096, 4096 - 2 * sizeof (void*));
1142 test_memalign ( 8192, 8192 - 2 * sizeof (void*));
1143 test_memalign (16384, 16384 - 2 * sizeof (void*));
1144 test_memalign (32768, 32768 - 2 * sizeof (void*));
1145 exit (0); /* success */
1148 [glib_cv_compliant_posix_memalign=1], [], [:])
1152 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1154 AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1160 dnl ****************************************
1161 dnl *** strlcpy/strlcat ***
1162 dnl ****************************************
1164 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1165 AC_TRY_RUN([#include <stdlib.h>
1169 (void) strlcpy (p, "hi", 10);
1170 if (strlcat (p, "bye", 0) != 3)
1173 }], glib_cv_have_strlcpy=yes,
1174 glib_cv_have_strlcpy=no,
1175 glib_cv_have_strlcpy=no)])
1176 if test "$glib_cv_have_strlcpy" = "yes"; then
1177 AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1181 dnl **********************
1182 dnl *** va_copy checks ***
1183 dnl **********************
1184 dnl we currently check for all three va_copy possibilities, so we get
1185 dnl all results in config.log for bug reports.
1186 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1187 AC_LINK_IFELSE([#include <stdarg.h>
1189 void f (int i, ...) {
1190 va_list args1, args2;
1191 va_start (args1, i);
1192 va_copy (args2, args1);
1193 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1195 va_end (args1); va_end (args2);
1201 [glib_cv_va_copy=yes],
1202 [glib_cv_va_copy=no])
1204 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1205 AC_LINK_IFELSE([#include <stdarg.h>
1207 void f (int i, ...) {
1208 va_list args1, args2;
1209 va_start (args1, i);
1210 __va_copy (args2, args1);
1211 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1213 va_end (args1); va_end (args2);
1219 [glib_cv___va_copy=yes],
1220 [glib_cv___va_copy=no])
1223 if test "x$glib_cv_va_copy" = "xyes"; then
1224 g_va_copy_func=va_copy
1225 else if test "x$glib_cv___va_copy" = "xyes"; then
1226 g_va_copy_func=__va_copy
1230 if test -n "$g_va_copy_func"; then
1231 AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1234 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1235 AC_TRY_RUN([#include <stdarg.h>
1237 void f (int i, ...) {
1238 va_list args1, args2;
1239 va_start (args1, i);
1241 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1243 va_end (args1); va_end (args2);
1249 [glib_cv_va_val_copy=yes],
1250 [glib_cv_va_val_copy=no],
1251 [glib_cv_va_val_copy=yes])
1254 if test "x$glib_cv_va_val_copy" = "xno"; then
1255 AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1258 dnl ***********************
1259 dnl *** g_module checks ***
1260 dnl ***********************
1262 G_MODULE_LIBS_EXTRA=
1263 G_MODULE_PLUGIN_LIBS=
1264 if test x"$glib_native_win32" = xyes; then
1265 dnl No use for this on Win32
1269 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1271 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1272 G_MODULE_NEED_USCORE=0
1273 G_MODULE_BROKEN_RTLD_GLOBAL=0
1274 G_MODULE_HAVE_DLERROR=0
1275 dnl *** force native WIN32 shared lib loader
1276 if test -z "$G_MODULE_IMPL"; then
1278 *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1281 dnl *** force native AIX library loader
1282 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1283 if test -z "$G_MODULE_IMPL"; then
1285 *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1288 dnl *** dlopen() and dlsym() in system libraries
1289 if test -z "$G_MODULE_IMPL"; then
1290 AC_CHECK_FUNC(dlopen,
1291 [AC_CHECK_FUNC(dlsym,
1292 [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1295 dnl *** load_image (BeOS)
1296 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1297 AC_CHECK_LIB(root, load_image,
1298 [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1299 G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1300 G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1301 G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1304 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1305 if test -z "$G_MODULE_IMPL"; then
1306 AC_CHECK_FUNC(NSLinkModule,
1307 [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1308 G_MODULE_NEED_USCORE=1],
1311 dnl *** dlopen() and dlsym() in libdl
1312 if test -z "$G_MODULE_IMPL"; then
1313 AC_CHECK_LIB(dl, dlopen,
1314 [AC_CHECK_LIB(dl, dlsym,
1316 G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1319 dnl *** shl_load() in libdld (HP-UX)
1320 if test -z "$G_MODULE_IMPL"; then
1321 AC_CHECK_LIB(dld, shl_load,
1322 [G_MODULE_LIBS=-ldld
1323 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1326 dnl *** additional checks for G_MODULE_IMPL_DL
1327 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1329 LDFLAGS_orig="$LDFLAGS"
1330 LIBS="$G_MODULE_LIBS $LIBS"
1331 LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1332 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1333 echo "void glib_plugin_test(void) { }" > plugin.c
1334 ${SHELL} ./libtool --mode=compile ${CC} -shared \
1335 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1336 AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1337 glib_cv_rtldglobal_broken,[
1341 # define RTLD_GLOBAL 0
1344 # define RTLD_LAZY 0
1346 int glib_plugin_test;
1348 void *handle, *global, *local;
1349 global = &glib_plugin_test;
1350 handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1351 if (!handle) return 0;
1352 local = dlsym (handle, "glib_plugin_test");
1353 return global == local;
1355 [glib_cv_rtldglobal_broken=no],
1356 [glib_cv_rtldglobal_broken=yes],
1357 [glib_cv_rtldglobal_broken=no])
1358 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1359 rmdir .libs 2>/dev/null
1361 if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1362 G_MODULE_BROKEN_RTLD_GLOBAL=1
1364 G_MODULE_BROKEN_RTLD_GLOBAL=0
1366 dnl *** check whether we need preceeding underscores
1367 AC_CACHE_CHECK([for preceeding underscore in symbols],
1369 AC_TRY_RUN([#include <dlfcn.h>
1370 int glib_underscore_test (void) { return 42; }
1372 void *f1 = (void*)0, *f2 = (void*)0, *handle;
1373 handle = dlopen ((void*)0, 0);
1375 f1 = dlsym (handle, "glib_underscore_test");
1376 f2 = dlsym (handle, "_glib_underscore_test");
1377 } return (!f2 || f1);
1379 [glib_cv_uscore=yes],
1380 [glib_cv_uscore=no],
1382 rm -f plugin.c plugin.$ac_objext plugin.lo
1384 GLIB_ASSERT_SET(glib_cv_uscore)
1385 if test "x$glib_cv_uscore" = "xyes"; then
1386 G_MODULE_NEED_USCORE=1
1388 G_MODULE_NEED_USCORE=0
1391 LDFLAGS="$LDFLAGS_orig"
1392 dnl *** check for having dlerror()
1393 AC_CHECK_FUNC(dlerror,
1394 [G_MODULE_HAVE_DLERROR=1],
1395 [G_MODULE_HAVE_DLERROR=0])
1398 dnl *** done, have we got an implementation?
1399 if test -z "$G_MODULE_IMPL"; then
1401 G_MODULE_SUPPORTED=false
1403 G_MODULE_SUPPORTED=true
1406 AC_MSG_CHECKING(for the suffix of shared libraries)
1408 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1410 module=yes eval std_shrext=$shrext_cmds
1411 # chop the initial dot
1412 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1413 AC_MSG_RESULT(.$glib_gmodule_suffix)
1414 # any reason it may fail?
1415 if test "x$glib_gmodule_suffix" = x; then
1416 AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1419 AC_SUBST(G_MODULE_SUPPORTED)
1420 AC_SUBST(G_MODULE_IMPL)
1421 AC_SUBST(G_MODULE_LIBS)
1422 AC_SUBST(G_MODULE_LIBS_EXTRA)
1423 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1424 AC_SUBST(G_MODULE_LDFLAGS)
1425 AC_SUBST(G_MODULE_HAVE_DLERROR)
1426 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1427 AC_SUBST(G_MODULE_NEED_USCORE)
1428 AC_SUBST(GLIB_DEBUG_FLAGS)
1430 dnl **********************
1431 dnl *** g_spawn checks ***
1432 dnl **********************
1434 AC_MSG_CHECKING(for gspawn implementation)
1437 GSPAWN=gspawn-win32.lo
1443 AC_MSG_RESULT($GSPAWN)
1446 dnl *************************
1447 dnl *** GIOChannel checks ***
1448 dnl *************************
1450 AC_MSG_CHECKING(for GIOChannel implementation)
1462 dnl *********************************
1463 dnl *** Directory for GIO modules ***
1464 dnl *********************************
1466 AC_ARG_WITH(gio-module-dir,
1467 [AC_HELP_STRING([--with-gio-module-dir=PATH],
1468 [Load gio modules from this directory [LIBDIR/gio/modules]])],
1470 [with_gio_module_dir='${libdir}/gio/modules'])
1471 GIO_MODULE_DIR=$with_gio_module_dir
1472 AC_SUBST(GIO_MODULE_DIR)
1474 dnl **********************************
1475 dnl *** Check for libselinux (GIO) ***
1476 dnl **********************************
1477 AC_ARG_ENABLE(selinux, [ --disable-selinux build without selinux support])
1480 if test "x$enable_selinux" != "xno"; then
1482 AC_CHECK_LIB(selinux, is_selinux_enabled,
1483 [AC_CHECK_HEADERS(selinux/selinux.h,
1484 [AC_SEARCH_LIBS(lgetfilecon_raw, selinux,
1485 [AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
1486 SELINUX_LIBS="-lselinux"
1491 AC_SUBST(SELINUX_LIBS)
1493 dnl *****************************
1494 dnl ** Check for inotify (GIO) **
1495 dnl *****************************
1497 AC_CHECK_HEADERS([sys/inotify.h],
1502 AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
1504 dnl *********************************
1505 dnl ** Check for Solaris FEN (GIO) **
1506 dnl *********************************
1510 #ifndef PORT_SOURCE_FILE
1511 #error "Please upgrade to Nevada 72 or above to suppoert FEN"
1513 int main() { return 0; } ],
1518 AM_CONDITIONAL(HAVE_FEN, [test "$fen_support" = "yes"])
1520 dnl ****************************
1521 dnl *** Checks for FAM (GIO) ***
1522 dnl ****************************
1524 should_disable_fam=no
1526 AC_ARG_ENABLE(fam, [ --disable-fam build without enabling fam for file system monitoring],
1528 if test "x$enable_fam" = "xno"; then
1529 should_disable_fam=yes
1530 echo "Not building FAM support"
1536 if test "x$should_disable_fam" = "xno"; then
1537 AC_CHECK_LIB(fam, FAMOpen,
1538 [AC_CHECK_HEADERS(fam.h,
1539 [AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
1540 AC_CHECK_LIB(fam, FAMNoExists,
1541 AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
1544 AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
1545 AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
1548 AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
1551 dnl *****************************
1552 dnl *** Check for xattr (GIO) ***
1553 dnl *****************************
1554 AC_ARG_ENABLE(xattr, [ --disable-xattr build without xattr support])
1557 if test "x$enable_xattr" != "xno"; then
1559 dnl either glibc or libattr can provide xattr support
1561 dnl for both of them, we check for getxattr being in
1562 dnl the library and a valid xattr header.
1565 AC_CHECK_LIB(c, getxattr,
1566 [AC_CHECK_HEADERS(sys/xattr.h,
1567 [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1571 if test "x$msg_xattr" != "xyes"; then
1572 dnl failure. try libattr
1573 AC_CHECK_LIB(attr, getxattr,
1574 [AC_CHECK_HEADERS(attr/xattr.h,
1575 [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1581 if test "x$msg_xattr" = "xyes"; then
1582 AC_MSG_CHECKING([for XATTR_NOFOLLOW])
1585 #ifdef HAVE_SYS_TYPES_H
1586 #include <sys/types.h>
1588 #ifdef HAVE_SYS_XATTR_H
1589 #include <sys/xattr.h>
1590 #elif HAVE_ATTR_XATTR_H
1591 #include <attr/xattr.h>
1594 [ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
1596 AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
1597 AC_MSG_RESULT([yes])
1599 [AC_MSG_RESULT([no])]
1604 AC_SUBST(XATTR_LIBS)
1606 dnl ****************************************
1607 dnl *** platform dependent source checks ***
1608 dnl ****************************************
1610 AC_MSG_CHECKING(for platform-dependent source)
1612 *-*-cygwin*|*-*-mingw*)
1613 PLATFORMDEP=gwin32.lo
1619 AC_MSG_RESULT($PLATFORMDEP)
1620 AC_SUBST(PLATFORMDEP)
1622 AC_MSG_CHECKING([whether to compile timeloop])
1624 *-*-cygwin*|*-*-mingw*|*-*-minix)
1631 AC_MSG_RESULT($enable_timeloop)
1632 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1634 AC_MSG_CHECKING([if building for some Win32 platform])
1636 *-*-mingw*|*-*-cygwin*)
1643 AC_MSG_RESULT($platform_win32)
1644 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1646 dnl ***********************
1647 dnl *** g_thread checks ***
1648 dnl ***********************
1650 AC_ARG_WITH(threads,
1651 [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1652 [specify a thread implementation to use])],
1653 [if test "x$with_threads" = x; then
1656 want_threads=$with_threads
1659 if test "x$enable_threads" = "xno"; then
1663 dnl error and warning message
1664 dnl *************************
1666 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1667 computer. GLib will not have a default thread implementation."
1669 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1670 platform (normally it's "_REENTRANT"). I'll not use any flag on
1671 compilation now, but then your programs might not work.
1672 Please provide information on how it is done on your system."
1674 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1677 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1678 provide information on your thread implementation.
1679 You can also run 'configure --disable-threads'
1680 to compile without thread support."
1682 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1683 functions will not be MT-safe during their first call because
1684 there is no working 'getpwuid_r' on your system."
1686 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1687 because there is no 'localtime_r' on your system."
1689 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1690 crude surrogate will be used. If you happen to know a
1691 yield function for your system, please inform the GLib
1694 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1695 threads on your system. Thus threads can only have the default
1696 priority. If you happen to know these main/max
1697 priorities, please inform the GLib developers."
1699 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1700 linking threaded applications. As GLib cannot do that
1701 automatically, you will get an linkg error everytime you are
1702 not using the right compiler. In that case you have to relink
1703 with the right compiler. Ususally just '_r' is appended
1704 to the compiler name."
1706 dnl determination of thread implementation
1707 dnl ***************************************
1709 # have_threads=no means no thread support
1710 # have_threads=none means no default thread implementation
1713 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1714 || test "x$want_threads" = xdce; then
1715 # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1716 # -U_OSF_SOURCE is for Digital UNIX 4.0d
1717 GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1718 glib_save_CPPFLAGS="$CPPFLAGS"
1719 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1720 if test "x$have_threads" = xno; then
1721 AC_TRY_COMPILE([#include <pthread.h>],
1722 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1725 if test "x$have_threads" = xno; then
1726 AC_TRY_COMPILE([#include <pthread.h>],
1728 pthread_mutex_init (&m, pthread_mutexattr_default);],
1731 # Tru64Unix requires -pthread to find pthread.h. See #103020
1732 CPPFLAGS="$CPPFLAGS -pthread"
1733 if test "x$have_threads" = xno; then
1734 AC_TRY_COMPILE([#include <pthread.h>],
1735 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1738 CPPFLAGS="$glib_save_CPPFLAGS"
1740 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1747 if test "x$want_threads" = xnone; then
1751 AC_MSG_CHECKING(for thread implementation)
1753 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1754 AC_MSG_RESULT(none available)
1755 AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1757 AC_MSG_RESULT($have_threads)
1761 dnl determination of G_THREAD_CFLAGS
1762 dnl ********************************
1765 G_THREAD_LIBS_EXTRA=
1769 dnl Test program for basic POSIX threads functionality
1771 m4_define([glib_thread_test],[
1772 #include <pthread.h>
1774 void* func(void* data) {check_me = 42; return &check_me;}
1778 pthread_create (&t, $1, func, 0);
1779 pthread_join (t, &ret);
1780 return (check_me != 42 || ret != &check_me);
1784 dnl Test program for sched_get_priority_min()
1786 m4_define([glib_sched_priority_test],[
1791 return sched_get_priority_min(SCHED_OTHER)==-1
1795 if test x"$have_threads" != xno; then
1797 if test x"$have_threads" = xposix; then
1798 # First we test for posix, whether -pthread or -pthreads do the trick as
1799 # both CPPFLAG and LIBS.
1800 # One of them does for most gcc versions and some other platforms/compilers
1801 # too and could be considered as the canonical way to go.
1803 *-*-cygwin*|*-*-darwin*)
1804 # skip cygwin and darwin -pthread or -pthreads test
1807 # These compiler/linker flags work with both Sun Studio and gcc
1808 # Sun Studio expands -mt to -D_REENTRANT and -lthread
1809 # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1810 G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1811 G_THREAD_LIBS="-lpthread -lthread"
1814 for flag in pthread pthreads mt; do
1815 glib_save_CFLAGS="$CFLAGS"
1816 CFLAGS="$CFLAGS -$flag"
1817 AC_TRY_RUN(glib_thread_test(0),
1818 glib_flag_works=yes,
1820 [AC_LINK_IFELSE(glib_thread_test(0),
1821 glib_flag_works=yes,
1822 glib_flag_works=no)])
1823 CFLAGS="$glib_save_CFLAGS"
1824 if test $glib_flag_works = yes ; then
1825 G_THREAD_CFLAGS=-$flag
1826 G_THREAD_LIBS=-$flag
1834 if test x"$G_THREAD_CFLAGS" = x; then
1836 # The canonical -pthread[s] does not work. Try something different.
1840 if test x"$GCC" = xyes; then
1841 # GCC 3.0 and above needs -pthread.
1842 # Should be coverd by the case above.
1843 # GCC 2.x and below needs -mthreads
1844 G_THREAD_CFLAGS="-mthreads"
1845 G_THREAD_LIBS=$G_THREAD_CFLAGS
1847 # We are probably using the aix compiler. Normaly a
1848 # program would have to be compiled with the _r variant
1849 # of the corresponding compiler, but we as GLib cannot
1850 # do that: but the good news is that for compiling the
1851 # only difference is the added -D_THREAD_SAFE compile
1852 # option. This is according to the "C for AIX User's
1854 G_THREAD_CFLAGS="-D_THREAD_SAFE"
1858 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1861 # So we are using dce threads. posix threads are already
1863 G_THREAD_CFLAGS="-threads"
1864 G_THREAD_LIBS=$G_THREAD_CFLAGS
1866 *-sysv5uw7*) # UnixWare 7
1867 # We are not using gcc with -pthread. Catched above.
1868 G_THREAD_CFLAGS="-Kthread"
1869 G_THREAD_LIBS=$G_THREAD_CFLAGS
1872 # No flag needed when using MSVCRT.DLL
1876 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1882 # if we are not finding the localtime_r function, then we probably are
1883 # not using the proper multithread flag
1885 glib_save_CPPFLAGS="$CPPFLAGS"
1886 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1888 # First we test, whether localtime_r is declared in time.h
1889 # directly. Then we test whether a macro localtime_r exists, in
1890 # which case localtime_r in the test program is replaced and thus
1891 # if we still find localtime_r in the output, it is not defined as
1894 AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1895 [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1897 AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1899 CPPFLAGS="$glib_save_CPPFLAGS"
1901 AC_MSG_CHECKING(thread related cflags)
1902 AC_MSG_RESULT($G_THREAD_CFLAGS)
1903 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1906 dnl determination of G_THREAD_LIBS
1907 dnl ******************************
1909 mutex_has_default=no
1910 case $have_threads in
1912 glib_save_CPPFLAGS="$CPPFLAGS"
1913 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1914 if test x"$G_THREAD_LIBS" = x; then
1917 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1918 # probably using the aix compiler.
1919 AC_MSG_WARN($AIX_COMPILE_INFO)
1923 glib_save_LIBS="$LIBS"
1924 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1925 if test x"$thread_lib" = x; then
1929 add_thread_lib="-l$thread_lib"
1930 IN=" in -l$thread_lib"
1932 if test x"$have_threads" = xposix; then
1935 defattr=pthread_attr_default
1938 LIBS="$add_thread_lib $glib_save_LIBS"
1940 AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1941 AC_TRY_RUN(glib_thread_test($defattr),
1944 [AC_LINK_IFELSE(glib_thread_test($defattr),
1947 AC_MSG_RESULT($glib_result)
1949 if test "$glib_result" = "yes" ; then
1950 G_THREAD_LIBS="$add_thread_lib"
1954 if test "x$G_THREAD_LIBS" = xerror; then
1955 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1957 LIBS="$glib_save_LIBS"
1962 glib_save_LIBS="$LIBS"
1963 for thread_lib in "" rt rte; do
1964 if test x"$thread_lib" = x; then
1968 add_thread_lib="-l$thread_lib"
1969 IN=" in -l$thread_lib"
1971 LIBS="$add_thread_lib $glib_save_LIBS"
1973 AC_MSG_CHECKING(for sched_get_priority_min$IN)
1974 AC_TRY_RUN(glib_sched_priority_test,
1977 [AC_LINK_IFELSE(glib_sched_priority_test,
1980 AC_MSG_RESULT($glib_result)
1982 if test "$glib_result" = "yes" ; then
1983 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1984 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1985 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1989 LIBS="$glib_save_LIBS"
1990 mutex_has_default=yes
1991 mutex_default_type='pthread_mutex_t'
1992 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1993 mutex_header_file='pthread.h'
1994 if test "x$have_threads" = "xposix"; then
1995 g_threads_impl="POSIX"
1997 g_threads_impl="DCE"
1998 have_threads="posix"
2000 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
2001 CPPFLAGS="$glib_save_CPPFLAGS"
2004 g_threads_impl="WIN32"
2007 g_threads_impl="NONE"
2010 g_threads_impl="NONE"
2015 if test "x$G_THREAD_LIBS" = xerror; then
2016 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2021 G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
2022 G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
2028 AC_MSG_CHECKING(thread related libraries)
2029 AC_MSG_RESULT($G_THREAD_LIBS)
2031 dnl check for mt safe function variants and some posix functions
2032 dnl ************************************************************
2034 if test x"$have_threads" != xno; then
2035 glib_save_LIBS="$LIBS"
2036 # we are not doing the following for now, as this might require glib
2037 # to always be linked with the thread libs on some platforms.
2038 # LIBS="$LIBS $G_THREAD_LIBS"
2039 AC_CHECK_FUNCS(localtime_r gmtime_r)
2040 if test "$ac_cv_header_pwd_h" = "yes"; then
2041 AC_CACHE_CHECK([for posix getpwuid_r],
2042 ac_cv_func_posix_getpwuid_r,
2048 struct passwd pwd, *pwptr = &pwd;
2051 error = getpwuid_r (0, &pwd, buffer,
2052 sizeof (buffer), &pwptr);
2053 return (error < 0 && errno == ENOSYS)
2056 [ac_cv_func_posix_getpwuid_r=yes],
2057 [ac_cv_func_posix_getpwuid_r=no])])
2058 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
2059 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
2060 AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
2061 [Have POSIX function getpwuid_r])
2063 AC_CACHE_CHECK([for nonposix getpwuid_r],
2064 ac_cv_func_nonposix_getpwuid_r,
2065 [AC_TRY_LINK([#include <pwd.h>],
2066 [char buffer[10000];
2068 getpwuid_r (0, &pwd, buffer,
2070 [ac_cv_func_nonposix_getpwuid_r=yes],
2071 [ac_cv_func_nonposix_getpwuid_r=no])])
2072 GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
2073 if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
2074 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
2075 [Have non-POSIX function getpwuid_r])
2079 if test "$ac_cv_header_grp_h" = "yes"; then
2080 AC_CACHE_CHECK([for posix getgrgid_r],
2081 ac_cv_func_posix_getgrgid_r,
2087 struct group grp, *grpptr = &grp;
2090 error = getgrgid_r (0, &grp, buffer,
2091 sizeof (buffer), &grpptr);
2092 return (error < 0 && errno == ENOSYS)
2095 [ac_cv_func_posix_getgrgid_r=yes],
2096 [ac_cv_func_posix_getgrgid_r=no])])
2097 GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
2098 if test "$ac_cv_func_posix_getgrgid_r" = yes; then
2099 AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
2100 [Have POSIX function getgrgid_r])
2102 AC_CACHE_CHECK([for nonposix getgrgid_r],
2103 ac_cv_func_nonposix_getgrgid_r,
2104 [AC_TRY_LINK([#include <grp.h>],
2105 [char buffer[10000];
2107 getgrgid_r (0, &grp, buffer,
2109 [ac_cv_func_nonposix_getgrgid_r=yes],
2110 [ac_cv_func_nonposix_getgrgid_r=no])])
2111 GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
2112 if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
2113 AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
2114 [Have non-POSIX function getgrgid_r])
2118 LIBS="$G_THREAD_LIBS $LIBS"
2119 if test x"$have_threads" = xposix; then
2120 glib_save_CPPFLAGS="$CPPFLAGS"
2121 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2122 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
2123 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
2124 # This is not AC_CHECK_FUNC to also work with function
2125 # name mangling in header files.
2126 AC_MSG_CHECKING(for pthread_attr_setstacksize)
2127 AC_TRY_LINK([#include <pthread.h>],
2128 [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
2130 AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
2131 [Have function pthread_attr_setstacksize])],
2132 [AC_MSG_RESULT(no)])
2133 AC_MSG_CHECKING(for minimal/maximal thread priority)
2134 if test x"$posix_priority_min" = x; then
2135 AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
2137 posix_priority_min=PX_PRIO_MIN
2138 posix_priority_max=PX_PRIO_MAX])
2140 if test x"$posix_priority_min" = x; then
2142 AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
2143 PTHREAD_PRIO_MIN],,[
2144 posix_priority_min=PTHREAD_PRIO_MIN
2145 posix_priority_max=PTHREAD_PRIO_MAX])
2147 if test x"$posix_priority_min" = x; then
2148 AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
2150 posix_priority_min=PRI_OTHER_MIN
2151 posix_priority_max=PRI_OTHER_MAX])
2153 if test x"$posix_priority_min" = x; then
2154 AC_MSG_RESULT(none found)
2155 AC_MSG_WARN($POSIX_NO_PRIORITIES)
2156 posix_priority_min=-1
2157 posix_priority_max=-1
2159 AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
2160 AC_MSG_CHECKING(for pthread_setschedparam)
2161 AC_TRY_LINK([#include <pthread.h>],
2162 [pthread_t t; pthread_setschedparam(t, 0, NULL)],
2164 AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
2165 AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
2167 AC_MSG_WARN($POSIX_NO_PRIORITIES)])
2169 posix_yield_func=none
2170 AC_MSG_CHECKING(for posix yield function)
2171 for yield_func in sched_yield pthread_yield_np pthread_yield \
2173 AC_TRY_LINK([#include <pthread.h>],
2175 [posix_yield_func="$yield_func"
2178 if test x"$posix_yield_func" = xnone; then
2179 AC_MSG_RESULT(none found)
2180 AC_MSG_WARN($POSIX_NO_YIELD)
2181 posix_yield_func="g_usleep(1000)"
2183 AC_MSG_RESULT($posix_yield_func)
2184 posix_yield_func="$posix_yield_func()"
2186 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
2187 CPPFLAGS="$glib_save_CPPFLAGS"
2189 elif test x"$have_threads" = xwin32; then
2190 # It's a pointer to a private struct
2191 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
2194 LIBS="$glib_save_LIBS"
2196 # now spit out all the warnings.
2197 if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
2198 test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
2199 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
2201 if test "$ac_cv_func_localtime_r" != "yes"; then
2202 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
2206 if test x"$glib_cv_sizeof_system_thread" = x; then
2207 # use a pointer as a fallback.
2208 GLIB_SIZEOF(,void *, system_thread)
2212 # Hack to deal with:
2214 # a) GCC < 3.3 for Linux doesn't include -lpthread when
2215 # building shared libraries with linux.
2216 # b) FreeBSD doesn't do this either.
2219 *-*-freebsd*|*-*-linux*)
2220 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
2223 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2227 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
2228 [Source file containing theread implementation])
2229 AC_SUBST(G_THREAD_CFLAGS)
2230 AC_SUBST(G_THREAD_LIBS)
2231 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2232 AC_SUBST(G_THREAD_LIBS_EXTRA)
2234 dnl **********************************************
2235 dnl *** GDefaultMutex setup and initialization ***
2236 dnl **********************************************
2238 dnl if mutex_has_default = yes, we also got
2239 dnl mutex_default_type, mutex_default_init and mutex_header_file
2240 if test $mutex_has_default = yes ; then
2241 glib_save_CPPFLAGS="$CPPFLAGS"
2242 glib_save_LIBS="$LIBS"
2243 LIBS="$G_THREAD_LIBS $LIBS"
2244 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2245 GLIB_SIZEOF([#include <$mutex_header_file>],
2246 $mutex_default_type,
2248 GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
2249 $mutex_default_type,
2251 $glib_cv_sizeof_gmutex,
2252 $mutex_default_init)
2253 if test x"$glib_cv_byte_contents_gmutex" = xno; then
2254 mutex_has_default=no
2256 CPPFLAGS="$glib_save_CPPFLAGS"
2257 LIBS="$glib_save_LIBS"
2260 AC_CHECK_FUNCS(clock_gettime, [], [
2261 AC_CHECK_LIB(rt, clock_gettime, [
2262 AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2263 G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2264 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2268 AC_CACHE_CHECK(for monotonic clocks,
2269 glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2273 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2274 #error No monotonic clock
2278 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2279 if test "$glib_cv_monotonic_clock" = "yes"; then
2280 AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2284 dnl ********************************
2285 dnl *** g_atomic_* tests for gcc ***
2286 dnl ********************************
2288 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2290 if test x"$GCC" = xyes; then
2293 AC_MSG_RESULT([none])
2294 glib_memory_barrier_needed=no
2297 AC_MSG_RESULT([i486])
2298 AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2299 [i486 atomic implementation])
2300 glib_memory_barrier_needed=no
2303 SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2304 when you are using a sparc with v9 instruction set (most
2305 sparcs nowadays). This will make the code for atomic
2306 operations much faster. The resulting code will not run
2307 on very old sparcs though."
2312 int tmp1, tmp2, tmp3;
2313 __asm__ __volatile__("casx [%2], %0, %1"
2314 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2316 AC_MSG_RESULT([sparcv9])
2317 AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2318 [sparcv9 atomic implementation]),
2320 AC_MSG_WARN([[$SPARCV9_WARNING]]))
2321 glib_memory_barrier_needed=yes
2324 AC_MSG_RESULT([alpha])
2325 AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2326 [alpha atomic implementation])
2327 glib_memory_barrier_needed=yes
2330 AC_MSG_RESULT([x86_64])
2331 AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2332 [x86_64 atomic implementation])
2333 glib_memory_barrier_needed=no
2336 AC_MSG_RESULT([powerpc])
2337 AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2338 [powerpc atomic implementation])
2339 glib_memory_barrier_needed=yes
2340 AC_MSG_CHECKING([whether asm supports numbered local labels])
2343 __asm__ __volatile__ ("1: nop\n"
2346 AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2347 AC_MSG_RESULT([yes])
2353 AC_MSG_RESULT([ia64])
2354 AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2355 [ia64 atomic implementation])
2356 glib_memory_barrier_needed=yes
2359 AC_MSG_RESULT([s390])
2360 AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2361 [s390 atomic implementation])
2362 glib_memory_barrier_needed=no
2365 AC_MSG_RESULT([arm])
2366 AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2367 [arm atomic implementation])
2368 glib_memory_barrier_needed=no
2371 AC_MSG_RESULT([none])
2372 glib_memory_barrier_needed=yes
2376 if test $glib_native_win32 = yes; then
2377 # For Windows but not using gcc. No barriers needed then either.
2378 glib_memory_barrier_needed=no
2382 dnl ****************************************
2383 dnl *** GLib POLL* compatibility defines ***
2384 dnl ****************************************
2386 glib_poll_includes=["
2387 #include <sys/types.h>
2388 #include <sys/poll.h>
2391 if test $ac_cv_header_sys_types_h = yes &&
2392 test $ac_cv_header_sys_poll_h = yes ; then
2394 GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2395 GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2396 GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2397 GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2398 GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2399 GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2400 if $glib_failed ; then
2401 AC_MSG_ERROR([Could not determine values for POLL* constants])
2404 glib_cv_value_POLLIN=1
2405 glib_cv_value_POLLOUT=4
2406 glib_cv_value_POLLPRI=2
2407 glib_cv_value_POLLERR=8
2408 glib_cv_value_POLLHUP=16
2409 glib_cv_value_POLLNVAL=32
2412 AC_MSG_CHECKING([for broken poll])
2413 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2417 #ifdef HAVE_SYS_POLL_H
2418 #include <sys/poll.h>
2421 struct pollfd fds[1];
2423 fd = open("/dev/null", 1);
2425 fds[0].events = POLLIN;
2427 if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2428 exit(1); /* Does not work for devices -- fail */
2434 AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2435 [broken_poll="no (cross compiling)"])
2436 AC_MSG_RESULT($broken_poll)
2438 dnl *********************
2439 dnl *** GRegex checks ***
2440 dnl *********************
2441 PCRE_REQUIRED_VERSION=7.2
2443 # Check if we should compile GRegex
2444 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2445 [disable the compilation of GRegex]),
2446 [case "${enableval}" in
2447 yes) enable_regex=true ;;
2448 no) enable_regex=false ;;
2449 *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2451 [enable_regex=true])
2453 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2455 if test x$enable_regex = xtrue; then
2456 # Check if we should use the internal or the system-supplied pcre
2458 [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2459 [specify whether to use the internal or the
2460 system-supplied PCRE library])])
2462 AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2464 if test "x$with_pcre" = xsystem; then
2465 PKG_CHECK_MODULES(PCRE,
2466 libpcre >= $PCRE_REQUIRED_VERSION)
2467 AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2468 glib_save_CFLAGS="$CFLAGS"
2469 glib_save_LIBS="$LIBS"
2470 CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2471 AC_TRY_RUN([#include <pcre.h>
2474 pcre_config (PCRE_CONFIG_UTF8, &support);
2477 pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2482 glib_cv_pcre_has_unicode=yes,
2483 glib_cv_pcre_has_unicode=no,
2484 glib_cv_pcre_has_unicode=yes)
2485 CFLAGS="$glib_save_CFLAGS"
2486 LIBS="$glib_save_LIBS"
2488 if test "$glib_cv_pcre_has_unicode" = "no"; then
2489 AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2491 AC_SUBST(PCRE_CFLAGS)
2493 AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2494 PCRE_REQUIRES=libpcre
2495 AC_SUBST(PCRE_REQUIRES)
2497 # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2498 if test x"$GCC" = xyes; then
2499 AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2500 save_CFLAGS="$CFLAGS"
2501 CFLAGS="$CFLAGS -Wno-pointer-sign"
2502 AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2503 AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2504 CFLAGS="$save_CFLAGS"
2507 AC_SUBST(PCRE_WARN_CFLAGS)
2509 AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2512 dnl **********************
2513 dnl *** Win32 API libs ***
2514 dnl **********************
2518 G_LIBS_EXTRA="-luser32 -lkernel32"
2521 G_LIBS_EXTRA="-lws2_32 -lole32"
2527 AC_SUBST(G_LIBS_EXTRA)
2529 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2530 dnl since we need it for g_iconv()
2532 AC_MSG_CHECKING([for EILSEQ])
2538 ], have_eilseq=yes, have_eilseq=no);
2539 AC_MSG_RESULT($have_eilseq)
2541 dnl ******************************************************************
2542 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2543 dnl ******************************************************************
2545 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2547 if test $cross_compiling = yes; then
2548 AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2549 if test x$GLIB_GENMARSHAL = xno; then
2550 AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2554 dnl **************************
2555 dnl *** Checks for gtk-doc ***
2556 dnl **************************
2558 GTK_DOC_CHECK([1.8])
2561 [AC_HELP_STRING([--enable-man],
2562 [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2565 if test "${enable_man}" != no; then
2567 dnl Check for xsltproc
2569 AC_PATH_PROG([XSLTPROC], [xsltproc])
2570 if test -z "$XSLTPROC"; then
2574 dnl check for DocBook DTD and stylesheets in the local catalog.
2575 JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2576 [DocBook XML DTD V4.1.2],,enable_man=no)
2577 JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2578 [DocBook XSL Stylesheets],,enable_man=no)
2581 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2583 dnl ******************************
2584 dnl *** output the whole stuff ***
2585 dnl ******************************
2587 dnl this section will only be run if config.status is invoked with no
2588 dnl arguments, or with "glibconfig.h" as an argument.
2589 AC_CONFIG_COMMANDS([glibconfig.h],
2591 outfile=glibconfig.h-tmp
2592 cat > $outfile <<\_______EOF
2595 * This is a generated file. Please modify 'configure.in'
2598 #ifndef __G_LIBCONFIG_H__
2599 #define __G_LIBCONFIG_H__
2601 #include <glib/gmacros.h>
2605 if test x$glib_limits_h = xyes; then
2606 echo '#include <limits.h>' >> $outfile
2608 if test x$glib_float_h = xyes; then
2609 echo '#include <float.h>' >> $outfile
2611 if test x$glib_values_h = xyes; then
2612 echo '#include <values.h>' >> $outfile
2614 if test "$glib_header_alloca_h" = "yes"; then
2615 echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2617 if test x$glib_sys_poll_h = xyes; then
2618 echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2620 if test x$enable_included_printf != xyes; then
2622 /* Specifies that GLib's g_print*() functions wrap the
2623 * system printf functions. This is useful to know, for example,
2624 * when using glibc's register_printf_function().
2626 echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2629 cat >> $outfile <<_______EOF
2633 #define G_MINFLOAT $glib_mf
2634 #define G_MAXFLOAT $glib_Mf
2635 #define G_MINDOUBLE $glib_md
2636 #define G_MAXDOUBLE $glib_Md
2637 #define G_MINSHORT $glib_ms
2638 #define G_MAXSHORT $glib_Ms
2639 #define G_MAXUSHORT $glib_Mus
2640 #define G_MININT $glib_mi
2641 #define G_MAXINT $glib_Mi
2642 #define G_MAXUINT $glib_Mui
2643 #define G_MINLONG $glib_ml
2644 #define G_MAXLONG $glib_Ml
2645 #define G_MAXULONG $glib_Mul
2650 ### this should always be true in a modern C/C++ compiler
2651 cat >>$outfile <<_______EOF
2652 typedef signed char gint8;
2653 typedef unsigned char guint8;
2657 if test -n "$gint16"; then
2658 cat >>$outfile <<_______EOF
2659 typedef signed $gint16 gint16;
2660 typedef unsigned $gint16 guint16;
2661 #define G_GINT16_MODIFIER $gint16_modifier
2662 #define G_GINT16_FORMAT $gint16_format
2663 #define G_GUINT16_FORMAT $guint16_format
2668 if test -n "$gint32"; then
2669 cat >>$outfile <<_______EOF
2670 typedef signed $gint32 gint32;
2671 typedef unsigned $gint32 guint32;
2672 #define G_GINT32_MODIFIER $gint32_modifier
2673 #define G_GINT32_FORMAT $gint32_format
2674 #define G_GUINT32_FORMAT $guint32_format
2678 cat >>$outfile <<_______EOF
2679 #define G_HAVE_GINT64 1 /* deprecated, always true */
2681 ${glib_extension}typedef signed $gint64 gint64;
2682 ${glib_extension}typedef unsigned $gint64 guint64;
2684 #define G_GINT64_CONSTANT(val) $gint64_constant
2685 #define G_GUINT64_CONSTANT(val) $guint64_constant
2688 if test x$gint64_format != x ; then
2689 cat >>$outfile <<_______EOF
2690 #define G_GINT64_MODIFIER $gint64_modifier
2691 #define G_GINT64_FORMAT $gint64_format
2692 #define G_GUINT64_FORMAT $guint64_format
2695 cat >>$outfile <<_______EOF
2696 #undef G_GINT64_MODIFIER
2697 #undef G_GINT64_FORMAT
2698 #undef G_GUINT64_FORMAT
2702 cat >>$outfile <<_______EOF
2704 #define GLIB_SIZEOF_VOID_P $glib_void_p
2705 #define GLIB_SIZEOF_LONG $glib_long
2706 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2710 cat >>$outfile <<_______EOF
2711 typedef signed $glib_size_type_define gssize;
2712 typedef unsigned $glib_size_type_define gsize;
2713 #define G_GSIZE_MODIFIER $gsize_modifier
2714 #define G_GSSIZE_FORMAT $gssize_format
2715 #define G_GSIZE_FORMAT $gsize_format
2717 #define G_MAXSIZE G_MAXU$glib_msize_type
2718 #define G_MINSSIZE G_MIN$glib_msize_type
2719 #define G_MAXSSIZE G_MAX$glib_msize_type
2721 typedef gint64 goffset;
2722 #define G_MINOFFSET G_MININT64
2723 #define G_MAXOFFSET G_MAXINT64
2727 if test -z "$glib_unknown_void_p"; then
2728 cat >>$outfile <<_______EOF
2730 #define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2731 #define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2733 #define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2734 #define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2737 echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2742 cat >>$outfile <<_______EOF
2747 $glib_static_compilation
2752 #define G_HAVE_INLINE 1
2753 #else /* !__cplusplus */
2755 #endif /* !__cplusplus */
2758 #define G_CAN_INLINE 1
2761 if test x$g_can_inline = xyes ; then
2762 cat >>$outfile <<_______EOF
2763 #else /* !__cplusplus */
2764 #define G_CAN_INLINE 1
2768 cat >>$outfile <<_______EOF
2773 if test x$g_have_iso_c_varargs = xyes ; then
2774 cat >>$outfile <<_______EOF
2776 # define G_HAVE_ISO_VARARGS 1
2780 if test x$g_have_iso_cxx_varargs = xyes ; then
2781 cat >>$outfile <<_______EOF
2783 # define G_HAVE_ISO_VARARGS 1
2787 if test x$g_have_gnuc_varargs = xyes ; then
2788 cat >>$outfile <<_______EOF
2790 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2791 * is passed ISO vararg support is turned off, and there is no work
2792 * around to turn it on, so we unconditionally turn it off.
2794 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2795 # undef G_HAVE_ISO_VARARGS
2798 #define G_HAVE_GNUC_VARARGS 1
2802 case x$g_stack_grows in
2803 xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2804 *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2809 if test x$g_have_eilseq = xno; then
2810 cat >>$outfile <<_______EOF
2812 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2813 * The correspondence between this and the corresponding definition
2814 * in libiconv is essential.
2816 # define EILSEQ ENOENT
2822 if test x$g_have_gnuc_visibility = xyes; then
2823 cat >>$outfile <<_______EOF
2824 #define G_HAVE_GNUC_VISIBILITY 1
2827 cat >>$outfile <<_______EOF
2828 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2829 #define G_GNUC_INTERNAL __hidden
2830 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2831 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2833 #define G_GNUC_INTERNAL
2839 if test x$g_mutex_has_default = xyes; then
2840 cat >>$outfile <<_______EOF
2841 $g_enable_threads_def G_THREADS_ENABLED
2842 #define G_THREADS_IMPL_$g_threads_impl_def
2843 typedef struct _GStaticMutex GStaticMutex;
2844 struct _GStaticMutex
2846 struct _GMutex *runtime_mutex;
2848 char pad[[$g_mutex_sizeof]];
2849 double dummy_double;
2850 void *dummy_pointer;
2854 #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2855 #define g_static_mutex_get_mutex(mutex) \\
2856 (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2857 g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2860 cat >>$outfile <<_______EOF
2861 $g_enable_threads_def G_THREADS_ENABLED
2862 #define G_THREADS_IMPL_$g_threads_impl_def
2863 typedef struct _GMutex* GStaticMutex;
2864 #define G_STATIC_MUTEX_INIT NULL
2865 #define g_static_mutex_get_mutex(mutex) \\
2866 (g_static_mutex_get_mutex_impl_shortcut (mutex))
2870 cat >>$outfile <<_______EOF
2871 /* This represents a system thread as used by the implementation. An
2872 * alien implementaion, as loaded by g_thread_init can only count on
2873 * "sizeof (gpointer)" bytes to store their info. We however need more
2874 * for some of our native implementations. */
2875 typedef union _GSystemThread GSystemThread;
2876 union _GSystemThread
2878 char data[[$g_system_thread_sizeof]];
2879 double dummy_double;
2880 void *dummy_pointer;
2884 if test x"$g_memory_barrier_needed" != xno; then
2886 echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2890 g_bit_sizes="16 32 64"
2891 for bits in $g_bit_sizes; do
2892 cat >>$outfile <<_______EOF
2893 #define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2894 #define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2895 #define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2896 #define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2900 cat >>$outfile <<_______EOF
2901 #define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2902 #define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2903 #define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2904 #define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2905 #define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2906 #define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2907 #define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2908 #define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2909 #define G_BYTE_ORDER $g_byte_order
2911 #define GLIB_SYSDEF_POLLIN =$g_pollin
2912 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2913 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2914 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2915 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2916 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2918 #define G_MODULE_SUFFIX "$g_module_suffix"
2920 typedef $g_pid_type GPid;
2924 #endif /* GLIBCONFIG_H */
2928 if cmp -s $outfile glibconfig.h; then
2929 AC_MSG_NOTICE([glibconfig.h is unchanged])
2932 mv $outfile glibconfig.h
2936 # Note that if two cases are the same, case goes with the first one.
2937 # Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2938 # on variable expansion in case labels. Look at the generated config.status
2941 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2942 glib_header_alloca_h="$ac_cv_working_alloca_h"
2944 glib_header_alloca_h="$ac_cv_header_alloca_h"
2948 x$ac_cv_header_float_h)
2950 glib_mf=FLT_MIN glib_Mf=FLT_MAX
2951 glib_md=DBL_MIN glib_Md=DBL_MAX
2953 x$ac_cv_header_values_h)
2955 glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2956 glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2961 x$ac_cv_header_limits_h)
2963 glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2964 glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2965 glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2967 x$ac_cv_header_values_h)
2969 glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2970 glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2971 glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2975 if test x$ac_cv_header_sys_poll_h = xyes ; then
2980 $ac_cv_sizeof_short)
2982 gint16_modifier='"h"'
2983 gint16_format='"hi"'
2984 guint16_format='"hu"'
2988 gint16_modifier='""'
2990 guint16_format='"u"'
2994 $ac_cv_sizeof_short)
2996 gint32_modifier='"h"'
2997 gint32_format='"hi"'
2998 guint32_format='"hu"'
3002 gint32_modifier='""'
3004 guint32_format='"u"'
3008 gint32_modifier='"l"'
3009 gint32_format='"li"'
3010 guint32_format='"lu"'
3016 gint64_modifier='""'
3018 guint64_format='"u"'
3020 gint64_constant='(val)'
3021 guint64_constant='(val)'
3025 gint64_modifier='"l"'
3026 gint64_format='"li"'
3027 guint64_format='"lu"'
3029 gint64_constant='(val##L)'
3030 guint64_constant='(val##UL)'
3032 $ac_cv_sizeof_long_long)
3034 if test -n "$glib_cv_long_long_format"; then
3035 gint64_modifier='"'$glib_cv_long_long_format'"'
3036 gint64_format='"'$glib_cv_long_long_format'i"'
3037 guint64_format='"'$glib_cv_long_long_format'u"'
3039 glib_extension='G_GNUC_EXTENSION '
3040 gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3041 guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3043 $ac_cv_sizeof___int64)
3045 if test -n "$glib_cv_long_long_format"; then
3046 gint64_modifier='"'$glib_cv_long_long_format'"'
3047 gint64_format='"'$glib_cv_long_long_format'i"'
3048 guint64_format='"'$glib_cv_long_long_format'u"'
3051 gint64_constant='(val##i64)'
3052 guint64_constant='(val##ui64)'
3055 glib_size_t=$ac_cv_sizeof_size_t
3056 glib_size_type_define=$glib_size_type
3057 glib_void_p=$ac_cv_sizeof_long
3058 glib_long=$ac_cv_sizeof_void_p
3060 case $glib_size_type in
3062 gsize_modifier='"h"'
3064 gssize_format='"hi"'
3065 glib_msize_type='SHRT'
3071 glib_msize_type='INT'
3074 gsize_modifier='"l"'
3076 gssize_format='"li"'
3077 glib_msize_type='LONG'
3081 gintbits=`expr $ac_cv_sizeof_int \* 8`
3082 glongbits=`expr $ac_cv_sizeof_long \* 8`
3085 case $ac_cv_sizeof_void_p in
3086 $ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
3087 $ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
3088 *) glib_unknown_void_p=yes ;;
3093 x$ac_cv_func_atexit)
3095 #ifdef NeXT /* @#%@! NeXTStep */
3096 # define g_ATEXIT(proc) (!atexit (proc))
3098 # define g_ATEXIT(proc) (atexit (proc))
3101 x$ac_cv_func_on_exit)
3103 #define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
3108 x$ac_cv_func_memmove)
3110 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3112 x$glib_cv_working_bcopy)
3114 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3115 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3119 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3120 * so we have to roll our own copy routine. */
3121 void g_memmove (void* dest, const void * src, unsigned long len);"
3126 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3127 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3128 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3132 x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
3133 x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
3137 if test x$glib_cv_va_val_copy = xno; then
3138 glib_vacopy="\$glib_vacopy
3139 #define G_VA_COPY_AS_ARRAY 1"
3142 if test x$glib_cv_hasinline = xyes; then
3143 glib_inline='#define G_HAVE_INLINE 1'
3145 if test x$glib_cv_has__inline = xyes; then
3146 glib_inline="\$glib_inline
3147 #define G_HAVE___INLINE 1"
3149 if test x$glib_cv_has__inline__ = xyes; then
3150 glib_inline="\$glib_inline
3151 #define G_HAVE___INLINE__ 1"
3154 g_have_gnuc_varargs=$g_have_gnuc_varargs
3155 g_have_iso_c_varargs=$g_have_iso_c_varargs
3156 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3158 g_can_inline=$g_can_inline
3159 g_have_gnuc_visibility=$g_have_gnuc_visibility
3160 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3162 if test x$ac_cv_c_bigendian = xyes; then
3163 g_byte_order=G_BIG_ENDIAN
3167 if test x$ac_cv_c_bigendian = xuniversal then
3168 g_byte_order=G_BIG_ENDIAN
3172 g_byte_order=G_LITTLE_ENDIAN
3178 g_pollin=$glib_cv_value_POLLIN
3179 g_pollout=$glib_cv_value_POLLOUT
3180 g_pollpri=$glib_cv_value_POLLPRI
3181 g_pollhup=$glib_cv_value_POLLHUP
3182 g_pollerr=$glib_cv_value_POLLERR
3183 g_pollnval=$glib_cv_value_POLLNVAL
3185 g_stack_grows=$glib_cv_stack_grows
3187 g_have_eilseq=$have_eilseq
3189 case x$have_threads in
3190 xno) g_enable_threads_def="#undef";;
3191 *) g_enable_threads_def="#define";;
3194 g_threads_impl_def=$g_threads_impl
3196 g_mutex_has_default="$mutex_has_default"
3197 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3198 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3199 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3201 g_memory_barrier_needed="$glib_memory_barrier_needed"
3203 g_module_suffix="$glib_gmodule_suffix"
3205 g_pid_type="$glib_pid_type"
3208 glib_os="#define G_OS_BEOS"
3211 glib_os="#define G_OS_UNIX
3212 #define G_PLATFORM_WIN32
3213 #define G_WITH_CYGWIN"
3216 glib_os="#define G_OS_WIN32
3217 #define G_PLATFORM_WIN32"
3220 glib_os="#define G_OS_UNIX"
3223 glib_static_compilation=""
3224 if test x$glib_win32_static_compilation = xyes; then
3225 glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3226 #define GOBJECT_STATIC_COMPILATION 1"
3232 glib-2.0-uninstalled.pc
3234 gmodule-export-2.0.pc
3235 gmodule-no-export-2.0.pc
3236 gmodule-2.0-uninstalled.pc
3237 gmodule-no-export-2.0-uninstalled.pc
3239 gthread-2.0-uninstalled.pc
3241 gobject-2.0-uninstalled.pc
3244 gio-2.0-uninstalled.pc
3245 gio-unix-2.0-uninstalled.pc
3250 build/win32/Makefile
3251 build/win32/dirent/Makefile
3252 build/win32/vs8/Makefile
3254 glib/libcharset/Makefile
3255 glib/gnulib/Makefile
3257 glib/update-pcre/Makefile
3260 gmodule/gmoduleconf.h
3262 gobject/glib-mkenums
3263 gobject/tests/Makefile
3266 gio/xdgmime/Makefile
3267 gio/inotify/Makefile
3274 docs/reference/Makefile
3275 docs/reference/glib/Makefile
3276 docs/reference/glib/version.xml
3277 docs/reference/gobject/Makefile
3278 docs/reference/gobject/version.xml
3279 docs/reference/gio/Makefile
3280 docs/reference/gio/version.xml
3282 tests/gobject/Makefile
3283 tests/refcount/Makefile
3287 AC_CONFIG_COMMANDS([chmod-scripts],
3288 [chmod 0755 glib-zip
3289 chmod 0755 glib-gettextize
3290 chmod 0755 gobject/glib-mkenums])
3292 # we want to invoke this macro solely so that the config.status script
3293 # and automake generated makefiles know about these generated files.
3294 # They are only needed to distcheck the package
3303 gmodule/makefile.msc
3305 gobject/makefile.msc
3307 gthread/makefile.msc