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], [14])
26 m4_define([glib_micro_version], [4])
27 m4_define([glib_interface_age], [4])
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
122 GMODULE_DEF=gmodule.def
123 GOBJECT_DEF=gobject.def
124 GTHREAD_DEF=gthread.def
125 TESTGMODULE_EXP=testgmodule.exp
126 glib_pid_type='void *'
144 AC_MSG_RESULT([$glib_native_win32])
147 AC_MSG_CHECKING([for Mac OS X Carbon support])
149 #include <Carbon/Carbon.h>
150 #include <CoreServices/CoreServices.h>
151 ], glib_have_carbon=yes)
153 AC_MSG_RESULT([$glib_have_carbon])
155 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
156 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
157 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
158 AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
160 AC_SUBST(GMODULE_DEF)
161 AC_SUBST(GOBJECT_DEF)
162 AC_SUBST(GTHREAD_DEF)
163 AC_SUBST(TESTGMODULE_EXP)
165 if test "$glib_native_win32" = "yes"; then
166 AC_CHECK_TOOL(WINDRES, windres, no)
167 if test "$WINDRES" = no; then
168 AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
170 AC_CHECK_TOOL(NM, nm, no)
171 if test "$NM" = no; then
172 AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
174 AC_CHECK_TOOL(RANLIB, ranlib, :)
175 AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
177 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
179 if test "$glib_native_win32" != yes; then
180 # libtool option to control which symbols are exported
181 # right now, symbols starting with _ are not exported
182 LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
184 # We currently use .def files on Windows
185 LIBTOOL_EXPORT_OPTIONS=
187 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
189 if test "x$glib_have_carbon" = "xyes"; then
190 AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
191 LDFLAGS="$LDFLAGS -framework Carbon"
195 dnl declare --enable-* args and collect ac_help strings
197 AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
198 [turn on debugging @<:@default=glib_debug_default@:>@]),,
199 enable_debug=glib_debug_default)
201 AC_ARG_ENABLE(gc_friendly,
202 [AC_HELP_STRING([--enable-gc-friendly],
203 [turn on garbage collector friendliness [default=no]])],,
204 [enable_gc_friendly=no])
205 AC_ARG_ENABLE(mem_pools,
206 [AC_HELP_STRING([--disable-mem-pools],
207 [disable all glib memory pools])],,
208 [disable_mem_pools=no])
209 AC_ARG_ENABLE(threads,
210 [AC_HELP_STRING([--enable-threads],
211 [turn on basic thread support [default=yes]
212 ([=no] will override --with-threads)])],,
213 [enable_threads=yes])
214 AC_ARG_ENABLE(rebuilds,
215 [AC_HELP_STRING([--disable-rebuilds],
216 [disable all source autogeneration rules])],,
217 [enable_rebuilds=yes])
218 AC_ARG_ENABLE(visibility,
219 [AC_HELP_STRING([--disable-visibility],
220 [don't use ELF visibility attributes])],,
221 [enable_visibility=yes])
223 if test "x$enable_threads" != "xyes"; then
227 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
228 if test "x$enable_gc_friendly" = "xyes"; then
229 AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
235 AC_MSG_CHECKING([whether to disable memory pools])
236 if test "x$disable_mem_pools" = "xno"; then
239 AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
240 AC_SUBST(DISABLE_MEM_POOLS)
244 if test "$glib_native_win32" = "yes"; then
245 if test x$enable_static = xyes -o x$enable_static = x; then
246 AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
249 if test x$enable_shared = xno; then
250 AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
255 dnl Checks for programs.
258 dnl Check for a working C++ compiler, but do not bail out, if none is found.
259 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
262 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
263 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
274 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
275 if test x$PKG_CONFIG = xno ; then
276 AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
279 if $PKG_CONFIG --atleast-pkgconfig-version 0.16 ; then
282 AC_MSG_ERROR([*** pkg-config too old; version 0.16 or better required.])
285 if test "x$enable_debug" = "xyes"; then
286 if test x$cflags_set != xset ; then
288 *[[\ \ ]]-g[[\ \ ]]*) ;;
289 *) CFLAGS="$CFLAGS -g" ;;
293 GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
295 GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
297 if test "x$enable_debug" = "xno"; then
298 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
302 if test "x$enable_visibility" = "xno"; then
303 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
306 # Ensure MSVC-compatible struct packing convention is used when
307 # compiling for Win32 with gcc.
308 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
309 # gcc2 uses "-fnative-struct".
310 if test x"$glib_native_win32" = xyes; then
311 if test x"$GCC" = xyes; then
313 AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
314 if test -z "$ac_cv_prog_CC"; then
317 our_gcc="$ac_cv_prog_CC"
319 case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
321 if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
322 msnative_struct='-fnative-struct'
326 if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
327 msnative_struct='-mms-bitfields'
331 if test x"$msnative_struct" = x ; then
332 AC_MSG_RESULT([no way])
333 AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
335 CFLAGS="$CFLAGS $msnative_struct"
336 AC_MSG_RESULT([${msnative_struct}])
343 # define a MAINT-like variable REBUILD which is set if Perl
344 # and awk are found, so autogenerated sources can be rebuilt
346 AC_CHECK_PROGS(PERL, [perl5 perl])
347 # We would like indent, but don't require it.
348 AC_CHECK_PROG(INDENT, indent, indent)
350 if test "x$enable_rebuilds" = "xyes" && \
352 $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
353 test -n "$AWK" ; then
358 # Need full path to Perl for glib-mkenums
360 if test "x$PERL" != x ; then
361 AC_PATH_PROG(PERL_PATH, [$PERL])
363 if test "x$PERL_PATH" = x ; then
364 PERL_PATH="/usr/bin/env perl"
368 dnl ***********************
369 dnl *** Tests for iconv ***
370 dnl ***********************
372 dnl We do this before the gettext checks, to avoid distortion
374 AC_ARG_WITH(libiconv,
375 [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
376 [use the libiconv library])],,
377 [with_libiconv=maybe])
380 case $with_libiconv in
382 # Check in the C library first
383 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
384 # Check if we have GNU libiconv
385 if test $found_iconv = "no"; then
386 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
388 # Check if we have a iconv in -liconv, possibly from vendor
389 if test $found_iconv = "no"; then
390 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
394 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
397 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
400 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
404 if test "x$found_iconv" = "xno" ; then
405 AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
409 AC_ARG_ENABLE(iconv-cache,
410 [AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
411 [cache iconv descriptors [default=auto]])],,
412 [enable_iconv_cache=auto])
414 AC_MSG_CHECKING([Whether to cache iconv descriptors])
415 case $enable_iconv_cache in
417 if test $ac_cv_gnu_library_2_1 = yes; then
418 enable_iconv_cache=no
420 enable_iconv_cache=yes
425 *) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
429 if test $enable_iconv_cache = yes; then
430 AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
433 AC_MSG_RESULT($enable_iconv_cache)
440 ALL_LINGUAS="am ar as az be be@latin bg bn bn_IN bs ca cs cy da de dz el en_CA en_GB eo es et eu fa fi fr ga gl gu he hi hr hu hy id is it ja ka kn ko ku lt lv mg mk ml mn ms nb ne nl nn oc or pa pl pt pt_BR ro ru rw sk sl sq sr sr@Latn sr@ije sv ta te th tl tr tt uk vi wa xh yi zh_CN zh_HK zh_TW"
443 if test "$gt_cv_have_gettext" != "yes" ; then
445 *** You must have either have gettext support in your C library, or use the
446 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
450 LIBS="$INTLLIBS $LIBS"
452 GETTEXT_PACKAGE=glib20
453 AC_SUBST(GETTEXT_PACKAGE)
454 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
455 [Define the gettext package to be used])
457 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
460 dnl Now we are done with gettext checks, figure out ICONV_LIBS
463 if test x$with_libiconv != xno ; then
464 case " $INTLLIBS " in
465 *[[\ \ ]]-liconv[[\ \ ]]*) ;;
466 *) ICONV_LIBS="-liconv" ;;
471 case $with_libiconv in
473 AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
476 AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
480 dnl Initialize libtool
485 if test "x$GCC" = "xyes"; then
487 *[[\ \ ]]-Wall[[\ \ ]]*) ;;
488 *) CFLAGS="$CFLAGS -Wall" ;;
493 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
495 if test $cross_compiling != yes ; then
496 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
499 AC_TRY_RUN([#include <math.h>
500 int main (void) { return (log(1) != log(1.)); }],
501 AC_MSG_RESULT(none needed),
502 glib_save_CFLAGS=$CFLAGS
503 CFLAGS="$CFLAGS -std1"
504 AC_TRY_RUN([#include <math.h>
505 int main (void) { return (log(1) != log(1.)); }],
506 AC_MSG_RESULT(-std1),
508 CFLAGS=$glib_save_CFLAGS
510 [No ANSI prototypes found in library. (-std1 didn't work.)])
516 dnl NeXTStep cc seems to need this
517 AC_MSG_CHECKING([for extra flags for POSIX compliance])
518 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
519 AC_MSG_RESULT(none needed),
520 glib_save_CFLAGS=$CFLAGS
521 CFLAGS="$CFLAGS -posix"
522 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
523 AC_MSG_RESULT(-posix),
525 CFLAGS=$glib_save_CFLAGS
526 AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
528 # Checks for header files.
531 # Checks for library functions.
535 AC_CHECK_FUNCS(posix_memalign)
536 AC_CHECK_FUNCS(memalign)
537 AC_CHECK_FUNCS(valloc)
539 AC_CHECK_FUNCS(atexit on_exit)
541 AC_CHECK_FUNCS(timegm)
543 AC_CHECK_SIZEOF(char)
544 AC_CHECK_SIZEOF(short)
545 AC_CHECK_SIZEOF(long)
547 AC_CHECK_SIZEOF(void *)
548 AC_CHECK_SIZEOF(long long)
549 AC_CHECK_SIZEOF(__int64)
551 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
555 *** GLib requires a 64 bit type. You might want to consider
556 *** using the GNU C compiler.
560 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
561 # long long is a 64 bit integer.
562 AC_MSG_CHECKING(for format to printf and scanf a guint64)
563 AC_CACHE_VAL(glib_cv_long_long_format,[
564 for format in ll q I64; do
565 AC_TRY_RUN([#include <stdio.h>
568 long long b, a = -0x3AFAFAFAFAFAFAFALL;
570 sprintf (buffer, "%${format}u", a);
571 sscanf (buffer, "%${format}u", &b);
575 [glib_cv_long_long_format=${format}
579 if test -n "$glib_cv_long_long_format"; then
580 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
581 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
582 if test x"$glib_cv_long_long_format" = xI64; then
583 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
588 elif test x$ac_cv_sizeof___int64 = x8; then
589 # __int64 is a 64 bit integer.
590 AC_MSG_CHECKING(for format to printf and scanf a guint64)
591 # We know this is MSVCRT.DLL, and what the formats are
592 glib_cv_long_long_format=I64
593 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
594 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
595 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
598 dnl long doubles were not used, and a portability problem
602 dnl ok, here we try to check whether the systems prototypes for
603 dnl malloc and friends actually match the prototypes provided
604 dnl by gmem.h (keep in sync). i currently only know how to check
605 dnl this reliably with gcc (-Werror), improvements for other
606 dnl compilers are apprechiated.
607 SANE_MALLOC_PROTOS=no
608 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
609 glib_save_CFLAGS=$CFLAGS
610 if test "x$GCC" = "xyes"; then
611 CFLAGS="$CFLAGS -Werror"
612 AC_TRY_COMPILE([#include <stdlib.h>], [
613 void* (*my_calloc_p) (size_t, size_t) = calloc;
614 void* (*my_malloc_p) (size_t) = malloc;
615 void (*my_free_p) (void*) = free;
616 void* (*my_realloc_p) (void*, size_t) = realloc;
622 AC_DEFINE(SANE_MALLOC_PROTOS, 1,
623 [Define if you have correct malloc prototypes])
624 SANE_MALLOC_PROTOS=yes)
626 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
627 CFLAGS=$glib_save_CFLAGS
630 dnl check in which direction the stack grows
632 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
634 volatile int *a = 0, *b = 0;
636 int main () { volatile int y = 7; a = &y; foo (); return b > a; }
637 void foo (void) { volatile int x = 5; b = &x; }
639 glib_cv_stack_grows=no
641 glib_cv_stack_grows=yes
645 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
646 dnl truely know which ones of `inline', `__inline' and `__inline__' are
647 dnl actually supported.
648 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
650 __inline int foo () { return 0; }
651 int main () { return foo (); }
653 glib_cv_has__inline=yes
655 glib_cv_has__inline=no
658 case x$glib_cv_has__inline in
659 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
661 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
663 __inline__ int foo () { return 0; }
664 int main () { return foo (); }
666 glib_cv_has__inline__=yes
668 glib_cv_has__inline__=no
671 case x$glib_cv_has__inline__ in
672 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
674 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
677 inline int foo () { return 0; }
678 int main () { return foo (); }
680 glib_cv_hasinline=yes
685 case x$glib_cv_hasinline in
686 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
689 # if we can use inline functions in headers
690 AC_MSG_CHECKING(if inline functions in headers work)
692 #if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
694 # define inline __inline__
695 #elif !defined (G_HAVE_INLINE)
697 # if defined (G_HAVE___INLINE__)
698 # define inline __inline__
699 # elif defined (G_HAVE___INLINE)
700 # define inline __inline
704 int glib_test_func2 (int);
707 glib_test_func1 (void) {
708 return glib_test_func2 (1);
714 }],[g_can_inline=yes],[g_can_inline=no])
715 AC_MSG_RESULT($g_can_inline)
717 dnl *** check for working do while(0) macros ***
718 AC_CACHE_CHECK([for working do while(0) macros], g_support_dowhile_macros, [
720 #define STMT_START do
721 #define STMT_END while(0)
722 #define STMT_TEST STMT_START { i = 0; } STMT_END
723 int main(void) { int i = 1; STMT_TEST; return i; }],
724 [g_support_dowhile_macros=yes],
725 [g_support_dowhile_macros=no],
726 [g_support_dowhile_macros=yes])
728 if test x$g_support_dowhile_macros = xyes; then
729 AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
732 # check for flavours of varargs macros
733 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
735 int a(int p1, int p2, int p3);
736 #define call_a(...) a(1,__VA_ARGS__)
738 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
739 AC_MSG_RESULT($g_have_iso_c_varargs)
741 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
742 if test "$CXX" = ""; then
744 g_have_iso_cxx_varargs=no
748 int a(int p1, int p2, int p3);
749 #define call_a(...) a(1,__VA_ARGS__)
751 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
754 AC_MSG_RESULT($g_have_iso_cxx_varargs)
756 AC_MSG_CHECKING(for GNUC varargs macros)
758 int a(int p1, int p2, int p3);
759 #define call_a(params...) a(1,params)
761 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
762 AC_MSG_RESULT($g_have_gnuc_varargs)
764 # check for GNUC visibility support
765 AC_MSG_CHECKING(for GNUC visibility attribute)
766 GLIB_CHECK_COMPILE_WARNINGS([
768 __attribute__ ((visibility ("hidden")))
773 __attribute__ ((visibility ("internal")))
778 __attribute__ ((visibility ("protected")))
783 __attribute__ ((visibility ("default")))
787 int main (int argc, char **argv)
795 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
796 AC_MSG_RESULT($g_have_gnuc_visibility)
797 AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
799 AC_MSG_CHECKING([whether using Sun Studio C compiler])
800 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
802 # include "error: this is not Sun Studio."
804 ]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
805 AC_MSG_RESULT($g_have_sunstudio_visibility)
806 AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
808 # check for bytesex stuff
811 # check for header files
812 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/resource.h])
813 AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
814 AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h sched.h malloc.h])
816 # Checks for libcharset
819 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
820 AC_CHECK_FUNCS(setlocale)
822 # check additional type sizes
823 AC_CHECK_SIZEOF(size_t)
825 dnl Try to figure out whether gsize, gssize should be long or int
826 AC_MSG_CHECKING([for the appropriate definition for size_t])
828 case $ac_cv_sizeof_size_t in
838 *) AC_MSG_ERROR([No type matching size_t in size])
842 dnl If int/long are the same size, we see which one produces
843 dnl warnings when used in the location as size_t. (This matters
846 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
847 test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
848 GLIB_CHECK_COMPILE_WARNINGS([
849 #if defined(_AIX) && !defined(__GNUC__)
850 #pragma options langlvl=stdc89
856 unsigned int *size_int = &s;
857 return (int)*size_int;
859 ],glib_size_type=int,
860 [GLIB_CHECK_COMPILE_WARNINGS([
861 #if defined(_AIX) && !defined(__GNUC__)
862 #pragma options langlvl=stdc89
868 unsigned long *size_long = &s;
869 return (int)*size_long;
871 ],glib_size_type=long)])
874 AC_MSG_RESULT(unsigned $glib_size_type)
876 # Check for some functions
877 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk)
878 # Check for high-resolution sleep functions
879 AC_CHECK_FUNCS(nanosleep nsleep)
881 AC_CHECK_HEADERS(crt_externs.h)
882 AC_CHECK_FUNCS(_NSGetEnviron)
884 AC_FUNC_VSNPRINTF_C99
885 AC_FUNC_PRINTF_UNIX98
888 # Check whether to use an included printf
891 AC_ARG_ENABLE(included-printf,
892 [AC_HELP_STRING([--enable-included-printf],
893 [use included printf [default=auto]])],
894 enable_included_printf="$enableval")
896 need_included_printf=no
897 if test "x$enable_included_printf" = "xyes" ; then
898 need_included_printf=yes
900 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
901 need_included_printf=yes
903 if test "$ac_cv_func_printf_unix98" != "yes" ; then
904 need_included_printf=yes
906 if test "x$ac_cv_sizeof_long_long" = "x8" &&
907 test -z "$glib_cv_long_long_format" ; then
908 need_included_printf=yes
911 if test "x$enable_included_printf" = "xno" &&
912 test "x$need_included_printf" = "xyes" ; then
914 *** Your C library's printf doesn't appear to have the features that
915 *** GLib needs, but you specified --enable-included-printf=no.])
918 enable_included_printf=$need_included_printf
920 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
921 if test "$enable_included_printf" != "yes" ; then
922 AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
924 if test -z "$glib_cv_long_long_format" ; then
925 glib_cv_long_long_format="ll"
927 AC_DEFINE(HAVE_VASPRINTF,1)
930 # Checks needed for gnulib vasnprintf
937 AC_CHECK_TYPES(ptrdiff_t)
939 AC_CHECK_FUNCS([snprintf wcslen])
942 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
943 # The check is borrowed from the PERL Configure script.
944 if test "$ac_cv_func_memmove" != "yes"; then
945 AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
946 glib_cv_working_bcopy,[AC_TRY_RUN([
948 char buf[128], abc[128], *b;
950 bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
951 for (align = 7; align >= 0; align--) {
952 for (len = 36; len; len--) {
953 b = buf+align; bcopy(abc, b, len);
954 for (off = 1; off <= len; off++) {
955 bcopy(b, b+off, len); bcopy(b+off, b, len);
956 if (bcmp(b, abc, len)) return(1);
961 }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
963 GLIB_ASSERT_SET(glib_cv_working_bcopy)
964 if test "$glib_cv_working_bcopy" = "yes"; then
965 AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
969 # Check for sys_errlist
970 AC_MSG_CHECKING(for sys_errlist)
972 extern char *sys_errlist[];
974 sys_errlist[sys_nerr-1][0] = 0;
975 ], glib_ok=yes, glib_ok=no)
976 AC_MSG_RESULT($glib_ok)
977 if test "$glib_ok" = "no"; then
978 AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
981 # Check for sys_siglist
982 AC_MSG_CHECKING(for sys_siglist)
984 extern char *sys_siglist[];
985 exit (sys_siglist[0]);
986 ], glib_ok=yes, glib_ok=no)
987 AC_MSG_RESULT($glib_ok)
988 if test "$glib_ok" = "no"; then
989 AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
992 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
993 AC_MSG_CHECKING(for sys_siglist declaration)
994 AC_TRY_COMPILE([#include <signal.h>], [
995 strlen (sys_siglist[0]);
996 ], glib_ok=yes, glib_ok=no)
997 AC_MSG_RESULT($glib_ok)
998 if test "$glib_ok" = "no"; then
999 AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1002 # Check if <sys/select.h> needs to be included for fd_set
1003 AC_MSG_CHECKING([for fd_set])
1004 AC_TRY_COMPILE([#include <sys/types.h>],
1005 [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1006 if test "$gtk_ok" = "yes"; then
1007 AC_MSG_RESULT([yes, found in sys/types.h])
1009 AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1010 if test "$gtk_ok" = "yes"; then
1011 # *** FIXME: give it a different name
1012 AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1013 AC_MSG_RESULT([yes, found in sys/select.h])
1015 AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1020 dnl *** check for sane realloc() ***
1021 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1022 AC_TRY_RUN([#include <stdlib.h>
1024 return realloc (0, sizeof (int)) == 0;
1026 [glib_cv_sane_realloc=yes],
1027 [glib_cv_sane_realloc=no],
1028 [glib_cv_sane_realloc=yes])
1030 if test x$glib_cv_sane_realloc = xyes; then
1031 AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1034 dnl Check for nl_langinfo and CODESET
1035 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1036 AC_TRY_COMPILE([#include <langinfo.h>],
1037 [char *codeset = nl_langinfo (CODESET);],
1038 [glib_cv_langinfo_codeset=yes],
1039 [glib_cv_langinfo_codeset=no])])
1040 if test x$glib_cv_langinfo_codeset = xyes; then
1041 AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1044 dnl ****************************************
1045 dnl *** posix_memalign ***
1046 dnl ****************************************
1047 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1048 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1049 glib_cv_compliant_posix_memalign=0
1050 if test "$ac_cv_func_posix_memalign" = "yes" ; then
1052 #define _XOPEN_SOURCE 600
1053 #include <stdlib.h> /* posix_memalign() should be defined here */
1054 /* some systems break if #include <malloc.h> used */
1055 static void test_memalign (size_t boundary, size_t size) {
1057 if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1063 test_memalign ( 128, 128 - 2 * sizeof (void*));
1064 test_memalign ( 256, 256 - 2 * sizeof (void*));
1065 test_memalign ( 512, 512 - 2 * sizeof (void*));
1066 test_memalign ( 1024, 1024 - 2 * sizeof (void*));
1067 test_memalign ( 2048, 2048 - 2 * sizeof (void*));
1068 test_memalign ( 4096, 4096 - 2 * sizeof (void*));
1069 test_memalign ( 8192, 8192 - 2 * sizeof (void*));
1070 test_memalign (16384, 16384 - 2 * sizeof (void*));
1071 test_memalign (32768, 32768 - 2 * sizeof (void*));
1072 exit (0); /* success */
1075 [glib_cv_compliant_posix_memalign=1], [], [:])
1079 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1081 AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1087 dnl ****************************************
1088 dnl *** strlcpy/strlcat ***
1089 dnl ****************************************
1091 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1092 AC_TRY_RUN([#include <stdlib.h>
1096 (void) strlcpy (p, "hi", 10);
1097 if (strlcat (p, "bye", 0) != 3)
1100 }], glib_cv_have_strlcpy=yes,
1101 glib_cv_have_strlcpy=no,
1102 glib_cv_have_strlcpy=no)])
1103 if test "$glib_cv_have_strlcpy" = "yes"; then
1104 AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1108 dnl **********************
1109 dnl *** va_copy checks ***
1110 dnl **********************
1111 dnl we currently check for all three va_copy possibilities, so we get
1112 dnl all results in config.log for bug reports.
1113 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1114 AC_LINK_IFELSE([#include <stdarg.h>
1116 void f (int i, ...) {
1117 va_list args1, args2;
1118 va_start (args1, i);
1119 va_copy (args2, args1);
1120 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1122 va_end (args1); va_end (args2);
1128 [glib_cv_va_copy=yes],
1129 [glib_cv_va_copy=no])
1131 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1132 AC_LINK_IFELSE([#include <stdarg.h>
1134 void f (int i, ...) {
1135 va_list args1, args2;
1136 va_start (args1, i);
1137 __va_copy (args2, args1);
1138 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1140 va_end (args1); va_end (args2);
1146 [glib_cv___va_copy=yes],
1147 [glib_cv___va_copy=no])
1150 if test "x$glib_cv_va_copy" = "xyes"; then
1151 g_va_copy_func=va_copy
1152 else if test "x$glib_cv___va_copy" = "xyes"; then
1153 g_va_copy_func=__va_copy
1157 if test -n "$g_va_copy_func"; then
1158 AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1161 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1162 AC_TRY_RUN([#include <stdarg.h>
1164 void f (int i, ...) {
1165 va_list args1, args2;
1166 va_start (args1, i);
1168 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1170 va_end (args1); va_end (args2);
1176 [glib_cv_va_val_copy=yes],
1177 [glib_cv_va_val_copy=no],
1178 [glib_cv_va_val_copy=yes])
1181 if test "x$glib_cv_va_val_copy" = "xno"; then
1182 AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1185 dnl ***********************
1186 dnl *** g_module checks ***
1187 dnl ***********************
1189 G_MODULE_LIBS_EXTRA=
1190 G_MODULE_PLUGIN_LIBS=
1191 if test x"$glib_native_win32" = xyes; then
1192 dnl No use for this on Win32
1196 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1198 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1199 G_MODULE_NEED_USCORE=0
1200 G_MODULE_BROKEN_RTLD_GLOBAL=0
1201 G_MODULE_HAVE_DLERROR=0
1202 dnl *** force native WIN32 shared lib loader
1203 if test -z "$G_MODULE_IMPL"; then
1205 *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1208 dnl *** force native AIX library loader
1209 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1210 if test -z "$G_MODULE_IMPL"; then
1212 *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1215 dnl *** dlopen() and dlsym() in system libraries
1216 if test -z "$G_MODULE_IMPL"; then
1217 AC_CHECK_FUNC(dlopen,
1218 [AC_CHECK_FUNC(dlsym,
1219 [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1222 dnl *** load_image (BeOS)
1223 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1224 AC_CHECK_LIB(root, load_image,
1225 [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1226 G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1227 G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1228 G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1231 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1232 if test -z "$G_MODULE_IMPL"; then
1233 AC_CHECK_FUNC(NSLinkModule,
1234 [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1235 G_MODULE_NEED_USCORE=1],
1238 dnl *** dlopen() and dlsym() in libdl
1239 if test -z "$G_MODULE_IMPL"; then
1240 AC_CHECK_LIB(dl, dlopen,
1241 [AC_CHECK_LIB(dl, dlsym,
1243 G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1246 dnl *** shl_load() in libdld (HP-UX)
1247 if test -z "$G_MODULE_IMPL"; then
1248 AC_CHECK_LIB(dld, shl_load,
1249 [G_MODULE_LIBS=-ldld
1250 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1253 dnl *** additional checks for G_MODULE_IMPL_DL
1254 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1256 LDFLAGS_orig="$LDFLAGS"
1257 LIBS="$G_MODULE_LIBS $LIBS"
1258 LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1259 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1260 echo "void glib_plugin_test(void) { }" > plugin.c
1261 ${SHELL} ./libtool --mode=compile ${CC} -shared \
1262 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1263 AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1264 glib_cv_rtldglobal_broken,[
1268 # define RTLD_GLOBAL 0
1271 # define RTLD_LAZY 0
1273 int glib_plugin_test;
1275 void *handle, *global, *local;
1276 global = &glib_plugin_test;
1277 handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1278 if (!handle) return 0;
1279 local = dlsym (handle, "glib_plugin_test");
1280 return global == local;
1282 [glib_cv_rtldglobal_broken=no],
1283 [glib_cv_rtldglobal_broken=yes],
1284 [glib_cv_rtldglobal_broken=no])
1285 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1286 rmdir .libs 2>/dev/null
1288 if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1289 G_MODULE_BROKEN_RTLD_GLOBAL=1
1291 G_MODULE_BROKEN_RTLD_GLOBAL=0
1293 dnl *** check whether we need preceeding underscores
1294 AC_CACHE_CHECK([for preceeding underscore in symbols],
1296 AC_TRY_RUN([#include <dlfcn.h>
1297 int glib_underscore_test (void) { return 42; }
1299 void *f1 = (void*)0, *f2 = (void*)0, *handle;
1300 handle = dlopen ((void*)0, 0);
1302 f1 = dlsym (handle, "glib_underscore_test");
1303 f2 = dlsym (handle, "_glib_underscore_test");
1304 } return (!f2 || f1);
1306 [glib_cv_uscore=yes],
1307 [glib_cv_uscore=no],
1309 rm -f plugin.c plugin.$ac_objext plugin.lo
1311 GLIB_ASSERT_SET(glib_cv_uscore)
1312 if test "x$glib_cv_uscore" = "xyes"; then
1313 G_MODULE_NEED_USCORE=1
1315 G_MODULE_NEED_USCORE=0
1318 LDFLAGS="$LDFLAGS_orig"
1319 dnl *** check for having dlerror()
1320 AC_CHECK_FUNC(dlerror,
1321 [G_MODULE_HAVE_DLERROR=1],
1322 [G_MODULE_HAVE_DLERROR=0])
1325 dnl *** done, have we got an implementation?
1326 if test -z "$G_MODULE_IMPL"; then
1328 G_MODULE_SUPPORTED=false
1330 G_MODULE_SUPPORTED=true
1333 AC_MSG_CHECKING(for the suffix of shared libraries)
1335 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1337 module=yes eval std_shrext=$shrext_cmds
1338 # chop the initial dot
1339 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1340 AC_MSG_RESULT(.$glib_gmodule_suffix)
1341 # any reason it may fail?
1342 if test "x$glib_gmodule_suffix" = x; then
1343 AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1346 AC_SUBST(G_MODULE_SUPPORTED)
1347 AC_SUBST(G_MODULE_IMPL)
1348 AC_SUBST(G_MODULE_LIBS)
1349 AC_SUBST(G_MODULE_LIBS_EXTRA)
1350 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1351 AC_SUBST(G_MODULE_LDFLAGS)
1352 AC_SUBST(G_MODULE_HAVE_DLERROR)
1353 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1354 AC_SUBST(G_MODULE_NEED_USCORE)
1355 AC_SUBST(GLIB_DEBUG_FLAGS)
1357 dnl **********************
1358 dnl *** g_spawn checks ***
1359 dnl **********************
1361 AC_MSG_CHECKING(for gspawn implementation)
1364 GSPAWN=gspawn-win32.lo
1370 AC_MSG_RESULT($GSPAWN)
1373 dnl *************************
1374 dnl *** GIOChannel checks ***
1375 dnl *************************
1377 AC_MSG_CHECKING(for GIOChannel implementation)
1389 dnl ****************************************
1390 dnl *** platform dependent source checks ***
1391 dnl ****************************************
1393 AC_MSG_CHECKING(for platform-dependent source)
1395 *-*-cygwin*|*-*-mingw*)
1396 PLATFORMDEP=gwin32.lo
1402 AC_MSG_RESULT($PLATFORMDEP)
1403 AC_SUBST(PLATFORMDEP)
1405 AC_MSG_CHECKING([whether to compile timeloop])
1407 *-*-cygwin*|*-*-mingw*|*-*-minix)
1414 AC_MSG_RESULT($enable_timeloop)
1415 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1417 AC_MSG_CHECKING([if building for some Win32 platform])
1419 *-*-mingw*|*-*-cygwin*)
1426 AC_MSG_RESULT($platform_win32)
1427 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1429 dnl ***********************
1430 dnl *** g_thread checks ***
1431 dnl ***********************
1433 AC_ARG_WITH(threads,
1434 [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1435 [specify a thread implementation to use])],
1436 [if test "x$with_threads" = x; then
1439 want_threads=$with_threads
1442 if test "x$enable_threads" = "xno"; then
1446 dnl error and warning message
1447 dnl *************************
1449 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1450 computer. GLib will not have a default thread implementation."
1452 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1453 platform (normally it's "_REENTRANT"). I'll not use any flag on
1454 compilation now, but then your programs might not work.
1455 Please provide information on how it is done on your system."
1457 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1460 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1461 provide information on your thread implementation.
1462 You can also run 'configure --disable-threads'
1463 to compile without thread support."
1465 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1466 functions will not be MT-safe during their first call because
1467 there is no working 'getpwuid_r' on your system."
1469 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1470 because there is no 'localtime_r' on your system."
1472 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1473 crude surrogate will be used. If you happen to know a
1474 yield function for your system, please inform the GLib
1477 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1478 threads on your system. Thus threads can only have the default
1479 priority. If you happen to know these main/max
1480 priorities, please inform the GLib developers."
1482 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1483 linking threaded applications. As GLib cannot do that
1484 automatically, you will get an linkg error everytime you are
1485 not using the right compiler. In that case you have to relink
1486 with the right compiler. Ususally just '_r' is appended
1487 to the compiler name."
1489 dnl determination of thread implementation
1490 dnl ***************************************
1492 # have_threads=no means no thread support
1493 # have_threads=none means no default thread implementation
1496 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1497 || test "x$want_threads" = xdce; then
1498 # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1499 # -U_OSF_SOURCE is for Digital UNIX 4.0d
1500 GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1501 glib_save_CPPFLAGS="$CPPFLAGS"
1502 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1503 if test "x$have_threads" = xno; then
1504 AC_TRY_COMPILE([#include <pthread.h>],
1505 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1508 if test "x$have_threads" = xno; then
1509 AC_TRY_COMPILE([#include <pthread.h>],
1511 pthread_mutex_init (&m, pthread_mutexattr_default);],
1514 # Tru64Unix requires -pthread to find pthread.h. See #103020
1515 CPPFLAGS="$CPPFLAGS -pthread"
1516 if test "x$have_threads" = xno; then
1517 AC_TRY_COMPILE([#include <pthread.h>],
1518 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1521 CPPFLAGS="$glib_save_CPPFLAGS"
1523 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1530 if test "x$want_threads" = xnone; then
1534 AC_MSG_CHECKING(for thread implementation)
1536 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1537 AC_MSG_RESULT(none available)
1538 AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1540 AC_MSG_RESULT($have_threads)
1544 dnl determination of G_THREAD_CFLAGS
1545 dnl ********************************
1548 G_THREAD_LIBS_EXTRA=
1552 dnl Test program for basic POSIX threads functionality
1554 m4_define([glib_thread_test],[
1555 #include <pthread.h>
1557 void* func(void* data) {check_me = 42; return &check_me;}
1561 pthread_create (&t, $1, func, 0);
1562 pthread_join (t, &ret);
1563 return (check_me != 42 || ret != &check_me);
1567 dnl Test program for sched_get_priority_min()
1569 m4_define([glib_sched_priority_test],[
1574 return sched_get_priority_min(SCHED_OTHER)==-1
1578 if test x"$have_threads" != xno; then
1580 if test x"$have_threads" = xposix; then
1581 # First we test for posix, whether -pthread or -pthreads do the trick as
1582 # both CPPFLAG and LIBS.
1583 # One of them does for most gcc versions and some other platforms/compilers
1584 # too and could be considered as the canonical way to go.
1586 *-*-cygwin*|*-*-darwin*)
1587 # skip cygwin and darwin -pthread or -pthreads test
1590 # These compiler/linker flags work with both Sun Studio and gcc
1591 # Sun Studio expands -mt to -D_REENTRANT and -lthread
1592 # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1593 G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1594 G_THREAD_LIBS="-lpthread -lthread"
1597 for flag in pthread pthreads mt; do
1598 glib_save_CFLAGS="$CFLAGS"
1599 CFLAGS="$CFLAGS -$flag"
1600 AC_TRY_RUN(glib_thread_test(0),
1601 glib_flag_works=yes,
1603 [AC_LINK_IFELSE(glib_thread_test(0),
1604 glib_flag_works=yes,
1605 glib_flag_works=no)])
1606 CFLAGS="$glib_save_CFLAGS"
1607 if test $glib_flag_works = yes ; then
1608 G_THREAD_CFLAGS=-$flag
1609 G_THREAD_LIBS=-$flag
1617 if test x"$G_THREAD_CFLAGS" = x; then
1619 # The canonical -pthread[s] does not work. Try something different.
1623 if test x"$GCC" = xyes; then
1624 # GCC 3.0 and above needs -pthread.
1625 # Should be coverd by the case above.
1626 # GCC 2.x and below needs -mthreads
1627 G_THREAD_CFLAGS="-mthreads"
1628 G_THREAD_LIBS=$G_THREAD_CFLAGS
1630 # We are probably using the aix compiler. Normaly a
1631 # program would have to be compiled with the _r variant
1632 # of the corresponding compiler, but we as GLib cannot
1633 # do that: but the good news is that for compiling the
1634 # only difference is the added -D_THREAD_SAFE compile
1635 # option. This is according to the "C for AIX User's
1637 G_THREAD_CFLAGS="-D_THREAD_SAFE"
1641 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1644 # So we are using dce threads. posix threads are already
1646 G_THREAD_CFLAGS="-threads"
1647 G_THREAD_LIBS=$G_THREAD_CFLAGS
1649 *-sysv5uw7*) # UnixWare 7
1650 # We are not using gcc with -pthread. Catched above.
1651 G_THREAD_CFLAGS="-Kthread"
1652 G_THREAD_LIBS=$G_THREAD_CFLAGS
1655 # No flag needed when using MSVCRT.DLL
1659 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1665 # if we are not finding the localtime_r function, then we probably are
1666 # not using the proper multithread flag
1668 glib_save_CPPFLAGS="$CPPFLAGS"
1669 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1671 # First we test, whether localtime_r is declared in time.h
1672 # directly. Then we test whether a macro localtime_r exists, in
1673 # which case localtime_r in the test program is replaced and thus
1674 # if we still find localtime_r in the output, it is not defined as
1677 AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1678 [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1680 AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1682 CPPFLAGS="$glib_save_CPPFLAGS"
1684 AC_MSG_CHECKING(thread related cflags)
1685 AC_MSG_RESULT($G_THREAD_CFLAGS)
1686 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1689 dnl determination of G_THREAD_LIBS
1690 dnl ******************************
1692 mutex_has_default=no
1693 case $have_threads in
1695 glib_save_CPPFLAGS="$CPPFLAGS"
1696 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1697 if test x"$G_THREAD_LIBS" = x; then
1700 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1701 # probably using the aix compiler.
1702 AC_MSG_WARN($AIX_COMPILE_INFO)
1706 glib_save_LIBS="$LIBS"
1707 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1708 if test x"$thread_lib" = x; then
1712 add_thread_lib="-l$thread_lib"
1713 IN=" in -l$thread_lib"
1715 if test x"$have_threads" = xposix; then
1718 defattr=pthread_attr_default
1721 LIBS="$add_thread_lib $glib_save_LIBS"
1723 AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1724 AC_TRY_RUN(glib_thread_test($defattr),
1727 [AC_LINK_IFELSE(glib_thread_test($defattr),
1730 AC_MSG_RESULT($glib_result)
1732 if test "$glib_result" = "yes" ; then
1733 G_THREAD_LIBS="$add_thread_lib"
1737 if test "x$G_THREAD_LIBS" = xerror; then
1738 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1740 LIBS="$glib_save_LIBS"
1745 glib_save_LIBS="$LIBS"
1746 for thread_lib in "" rt rte; do
1747 if test x"$thread_lib" = x; then
1751 add_thread_lib="-l$thread_lib"
1752 IN=" in -l$thread_lib"
1754 LIBS="$add_thread_lib $glib_save_LIBS"
1756 AC_MSG_CHECKING(for sched_get_priority_min$IN)
1757 AC_TRY_RUN(glib_sched_priority_test,
1760 [AC_LINK_IFELSE(glib_sched_priority_test,
1763 AC_MSG_RESULT($glib_result)
1765 if test "$glib_result" = "yes" ; then
1766 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1767 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1768 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1772 LIBS="$glib_save_LIBS"
1773 mutex_has_default=yes
1774 mutex_default_type='pthread_mutex_t'
1775 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1776 mutex_header_file='pthread.h'
1777 if test "x$have_threads" = "xposix"; then
1778 g_threads_impl="POSIX"
1780 g_threads_impl="DCE"
1781 have_threads="posix"
1783 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1784 CPPFLAGS="$glib_save_CPPFLAGS"
1787 g_threads_impl="WIN32"
1790 g_threads_impl="NONE"
1793 g_threads_impl="NONE"
1798 if test "x$G_THREAD_LIBS" = xerror; then
1799 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1804 G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
1805 G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1811 AC_MSG_CHECKING(thread related libraries)
1812 AC_MSG_RESULT($G_THREAD_LIBS)
1814 dnl check for mt safe function variants and some posix functions
1815 dnl ************************************************************
1817 if test x"$have_threads" != xno; then
1818 glib_save_LIBS="$LIBS"
1819 # we are not doing the following for now, as this might require glib
1820 # to always be linked with the thread libs on some platforms.
1821 # LIBS="$LIBS $G_THREAD_LIBS"
1822 AC_CHECK_FUNCS(localtime_r)
1823 if test "$ac_cv_header_pwd_h" = "yes"; then
1824 AC_CACHE_CHECK([for posix getpwuid_r],
1825 ac_cv_func_posix_getpwuid_r,
1831 struct passwd pwd, *pwptr = &pwd;
1834 error = getpwuid_r (0, &pwd, buffer,
1835 sizeof (buffer), &pwptr);
1836 return (error < 0 && errno == ENOSYS)
1839 [ac_cv_func_posix_getpwuid_r=yes],
1840 [ac_cv_func_posix_getpwuid_r=no])])
1841 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1842 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1843 AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1844 [Have POSIX function getpwuid_r])
1846 AC_CACHE_CHECK([for nonposix getpwuid_r],
1847 ac_cv_func_nonposix_getpwuid_r,
1848 [AC_TRY_LINK([#include <pwd.h>],
1849 [char buffer[10000];
1851 getpwuid_r (0, &pwd, buffer,
1853 [ac_cv_func_nonposix_getpwuid_r=yes],
1854 [ac_cv_func_nonposix_getpwuid_r=no])])
1855 GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1856 if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1857 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1858 [Have non-POSIX function getpwuid_r])
1862 LIBS="$G_THREAD_LIBS $LIBS"
1863 if test x"$have_threads" = xposix; then
1864 glib_save_CPPFLAGS="$CPPFLAGS"
1865 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1866 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1867 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1868 # This is not AC_CHECK_FUNC to also work with function
1869 # name mangling in header files.
1870 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1871 AC_TRY_LINK([#include <pthread.h>],
1872 [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1874 AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1875 [Have function pthread_attr_setstacksize])],
1876 [AC_MSG_RESULT(no)])
1877 AC_MSG_CHECKING(for minimal/maximal thread priority)
1878 if test x"$posix_priority_min" = x; then
1879 AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1881 posix_priority_min=PX_PRIO_MIN
1882 posix_priority_max=PX_PRIO_MAX])
1884 if test x"$posix_priority_min" = x; then
1886 AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1887 PTHREAD_PRIO_MIN],,[
1888 posix_priority_min=PTHREAD_PRIO_MIN
1889 posix_priority_max=PTHREAD_PRIO_MAX])
1891 if test x"$posix_priority_min" = x; then
1892 AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1894 posix_priority_min=PRI_OTHER_MIN
1895 posix_priority_max=PRI_OTHER_MAX])
1897 if test x"$posix_priority_min" = x; then
1898 AC_MSG_RESULT(none found)
1899 AC_MSG_WARN($POSIX_NO_PRIORITIES)
1900 posix_priority_min=-1
1901 posix_priority_max=-1
1903 AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1904 AC_MSG_CHECKING(for pthread_setschedparam)
1905 AC_TRY_LINK([#include <pthread.h>],
1906 [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1908 AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1909 AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1911 AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1913 posix_yield_func=none
1914 AC_MSG_CHECKING(for posix yield function)
1915 for yield_func in sched_yield pthread_yield_np pthread_yield \
1917 AC_TRY_LINK([#include <pthread.h>],
1919 [posix_yield_func="$yield_func"
1922 if test x"$posix_yield_func" = xnone; then
1923 AC_MSG_RESULT(none found)
1924 AC_MSG_WARN($POSIX_NO_YIELD)
1925 posix_yield_func="g_usleep(1000)"
1927 AC_MSG_RESULT($posix_yield_func)
1928 posix_yield_func="$posix_yield_func()"
1930 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1931 CPPFLAGS="$glib_save_CPPFLAGS"
1933 elif test x"$have_threads" = xwin32; then
1934 # It's a pointer to a private struct
1935 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1938 LIBS="$glib_save_LIBS"
1940 # now spit out all the warnings.
1941 if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1942 test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1943 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1945 if test "$ac_cv_func_localtime_r" != "yes"; then
1946 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1950 if test x"$glib_cv_sizeof_system_thread" = x; then
1951 # use a pointer as a fallback.
1952 GLIB_SIZEOF(,void *, system_thread)
1956 # Hack to deal with:
1958 # a) GCC < 3.3 for Linux doesn't include -lpthread when
1959 # building shared libraries with linux.
1960 # b) FreeBSD doesn't do this either.
1963 *-*-freebsd*|*-*-linux*)
1964 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1967 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
1971 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1972 [Source file containing theread implementation])
1973 AC_SUBST(G_THREAD_CFLAGS)
1974 AC_SUBST(G_THREAD_LIBS)
1975 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1976 AC_SUBST(G_THREAD_LIBS_EXTRA)
1978 dnl **********************************************
1979 dnl *** GDefaultMutex setup and initialization ***
1980 dnl **********************************************
1982 dnl if mutex_has_default = yes, we also got
1983 dnl mutex_default_type, mutex_default_init and mutex_header_file
1984 if test $mutex_has_default = yes ; then
1985 glib_save_CPPFLAGS="$CPPFLAGS"
1986 glib_save_LIBS="$LIBS"
1987 LIBS="$G_THREAD_LIBS $LIBS"
1988 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1989 GLIB_SIZEOF([#include <$mutex_header_file>],
1990 $mutex_default_type,
1992 GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1993 $mutex_default_type,
1995 $glib_cv_sizeof_gmutex,
1996 $mutex_default_init)
1997 if test x"$glib_cv_byte_contents_gmutex" = xno; then
1998 mutex_has_default=no
2000 CPPFLAGS="$glib_save_CPPFLAGS"
2001 LIBS="$glib_save_LIBS"
2004 AC_CHECK_FUNCS(clock_gettime, [], [
2005 AC_CHECK_LIB(rt, clock_gettime, [
2006 AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2007 G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2008 G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2012 AC_CACHE_CHECK(for monotonic clocks,
2013 glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2017 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2018 #error No monotonic clock
2022 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2023 if test "$glib_cv_monotonic_clock" = "yes"; then
2024 AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2028 dnl ********************************
2029 dnl *** g_atomic_* tests for gcc ***
2030 dnl ********************************
2032 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2034 if test x"$GCC" = xyes; then
2037 AC_MSG_RESULT([none])
2038 glib_memory_barrier_needed=no
2041 AC_MSG_RESULT([i486])
2042 AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2043 [i486 atomic implementation])
2044 glib_memory_barrier_needed=no
2047 SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2048 when you are using a sparc with v9 instruction set (most
2049 sparcs nowadays). This will make the code for atomic
2050 operations much faster. The resulting code will not run
2051 on very old sparcs though."
2056 int tmp1, tmp2, tmp3;
2057 __asm__ __volatile__("casx [%2], %0, %1"
2058 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2060 AC_MSG_RESULT([sparcv9])
2061 AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2062 [sparcv9 atomic implementation]),
2064 AC_MSG_WARN([[$SPARCV9_WARNING]]))
2065 glib_memory_barrier_needed=yes
2068 AC_MSG_RESULT([alpha])
2069 AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2070 [alpha atomic implementation])
2071 glib_memory_barrier_needed=yes
2074 AC_MSG_RESULT([x86_64])
2075 AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2076 [x86_64 atomic implementation])
2077 glib_memory_barrier_needed=no
2080 AC_MSG_RESULT([powerpc])
2081 AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2082 [powerpc atomic implementation])
2083 glib_memory_barrier_needed=yes
2086 AC_MSG_RESULT([ia64])
2087 AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2088 [ia64 atomic implementation])
2089 glib_memory_barrier_needed=yes
2092 AC_MSG_RESULT([s390])
2093 AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2094 [s390 atomic implementation])
2095 glib_memory_barrier_needed=no
2098 AC_MSG_RESULT([arm])
2099 AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2100 [arm atomic implementation])
2101 glib_memory_barrier_needed=no
2104 AC_MSG_RESULT([none])
2105 glib_memory_barrier_needed=yes
2110 dnl ****************************************
2111 dnl *** GLib POLL* compatibility defines ***
2112 dnl ****************************************
2114 glib_poll_includes=["
2115 #include <sys/types.h>
2116 #include <sys/poll.h>
2119 if test $ac_cv_header_sys_types_h = yes &&
2120 test $ac_cv_header_sys_poll_h = yes ; then
2122 GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2123 GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2124 GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2125 GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2126 GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2127 GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2128 if $glib_failed ; then
2129 AC_MSG_ERROR([Could not determine values for POLL* constants])
2132 glib_cv_value_POLLIN=1
2133 glib_cv_value_POLLOUT=4
2134 glib_cv_value_POLLPRI=2
2135 glib_cv_value_POLLERR=8
2136 glib_cv_value_POLLHUP=16
2137 glib_cv_value_POLLNVAL=32
2140 AC_MSG_CHECKING([for broken poll])
2141 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2145 #ifdef HAVE_SYS_POLL_H
2146 #include <sys/poll.h>
2149 struct pollfd fds[1];
2151 fd = open("/dev/null", 1);
2153 fds[0].events = POLLIN;
2155 if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2156 exit(1); /* Does not work for devices -- fail */
2162 AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2163 [broken_poll="no (cross compiling)"])
2164 AC_MSG_RESULT($broken_poll)
2166 dnl *********************
2167 dnl *** GRegex checks ***
2168 dnl *********************
2169 PCRE_REQUIRED_VERSION=7.2
2171 # Check if we should compile GRegex
2172 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2173 [disable the compilation of GRegex]),
2174 [case "${enableval}" in
2175 yes) enable_regex=true ;;
2176 no) enable_regex=false ;;
2177 *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2179 [enable_regex=true])
2181 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2183 if test x$enable_regex = xtrue; then
2184 # Check if we should use the internal or the system-supplied pcre
2186 [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2187 [specify whether to use the internal or the
2188 system-supplied PCRE library])])
2190 AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2192 if test "x$with_pcre" = xsystem; then
2193 PKG_CHECK_MODULES(PCRE,
2194 libpcre >= $PCRE_REQUIRED_VERSION)
2195 AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2196 glib_save_CFLAGS="$CFLAGS"
2197 glib_save_LDFLAGS="$LDFLAGS"
2198 CFLAGS="$CFLAGS $PCRE_CFLAGS" LDFLAGS="$LDFLAGS $PCRE_LIBS"
2199 AC_TRY_RUN([#include <pcre.h>
2202 pcre_config (PCRE_CONFIG_UTF8, &support);
2205 pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2210 glib_cv_pcre_has_unicode=yes,
2211 glib_cv_pcre_has_unicode=no,
2212 glib_cv_pcre_has_unicode=yes)
2213 CFLAGS="$glib_save_CFLAGS"
2214 LDFLAGS="$glib_save_LDFLAGS"
2216 if test "$glib_cv_pcre_has_unicode" = "no"; then
2217 AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2219 AC_SUBST(PCRE_CFLAGS)
2221 AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2222 PCRE_REQUIRES=libpcre
2223 AC_SUBST(PCRE_REQUIRES)
2225 # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2226 if test x"$GCC" = xyes; then
2227 AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2228 save_CFLAGS="$CFLAGS"
2229 CFLAGS="$CFLAGS -Wno-pointer-sign"
2230 AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2231 AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2232 CFLAGS="$save_CFLAGS"
2235 AC_SUBST(PCRE_WARN_CFLAGS)
2237 AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2240 dnl **********************
2241 dnl *** Win32 API libs ***
2242 dnl **********************
2246 G_LIBS_EXTRA="-luser32 -lkernel32"
2249 G_LIBS_EXTRA="-lws2_32 -lole32"
2255 AC_SUBST(G_LIBS_EXTRA)
2257 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2258 dnl since we need it for g_iconv()
2260 AC_MSG_CHECKING([for EILSEQ])
2266 ], have_eilseq=yes, have_eilseq=no);
2267 AC_MSG_RESULT($have_eilseq)
2269 dnl ******************************************************************
2270 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2271 dnl ******************************************************************
2273 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2275 if test $cross_compiling = yes; then
2276 AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2277 if test x$GLIB_GENMARSHAL = xno; then
2278 AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2282 dnl **************************
2283 dnl *** Checks for gtk-doc ***
2284 dnl **************************
2286 GTK_DOC_CHECK([1.4])
2289 [AC_HELP_STRING([--enable-man],
2290 [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2293 if test "${enable_man}" != no; then
2295 dnl Check for xsltproc
2297 AC_PATH_PROG([XSLTPROC], [xsltproc])
2298 if test -z "$XSLTPROC"; then
2302 dnl check for DocBook DTD and stylesheets in the local catalog.
2303 JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2304 [DocBook XML DTD V4.1.2],,enable_man=no)
2305 JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2306 [DocBook XSL Stylesheets],,enable_man=no)
2309 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2311 dnl ******************************
2312 dnl *** output the whole stuff ***
2313 dnl ******************************
2315 dnl this section will only be run if config.status is invoked with no
2316 dnl arguments, or with "glibconfig.h" as an argument.
2317 AC_CONFIG_COMMANDS([glibconfig.h],
2319 outfile=glibconfig.h-tmp
2320 cat > $outfile <<\_______EOF
2323 * This is a generated file. Please modify 'configure.in'
2326 #ifndef __G_LIBCONFIG_H__
2327 #define __G_LIBCONFIG_H__
2329 #include <glib/gmacros.h>
2333 if test x$glib_limits_h = xyes; then
2334 echo '#include <limits.h>' >> $outfile
2336 if test x$glib_float_h = xyes; then
2337 echo '#include <float.h>' >> $outfile
2339 if test x$glib_values_h = xyes; then
2340 echo '#include <values.h>' >> $outfile
2342 if test "$glib_header_alloca_h" = "yes"; then
2343 echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2345 if test x$glib_sys_poll_h = xyes; then
2346 echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2349 cat >> $outfile <<_______EOF
2353 #define G_MINFLOAT $glib_mf
2354 #define G_MAXFLOAT $glib_Mf
2355 #define G_MINDOUBLE $glib_md
2356 #define G_MAXDOUBLE $glib_Md
2357 #define G_MINSHORT $glib_ms
2358 #define G_MAXSHORT $glib_Ms
2359 #define G_MAXUSHORT $glib_Mus
2360 #define G_MININT $glib_mi
2361 #define G_MAXINT $glib_Mi
2362 #define G_MAXUINT $glib_Mui
2363 #define G_MINLONG $glib_ml
2364 #define G_MAXLONG $glib_Ml
2365 #define G_MAXULONG $glib_Mul
2370 ### this should always be true in a modern C/C++ compiler
2371 cat >>$outfile <<_______EOF
2372 typedef signed char gint8;
2373 typedef unsigned char guint8;
2377 if test -n "$gint16"; then
2378 cat >>$outfile <<_______EOF
2379 typedef signed $gint16 gint16;
2380 typedef unsigned $gint16 guint16;
2381 #define G_GINT16_MODIFIER $gint16_modifier
2382 #define G_GINT16_FORMAT $gint16_format
2383 #define G_GUINT16_FORMAT $guint16_format
2388 if test -n "$gint32"; then
2389 cat >>$outfile <<_______EOF
2390 typedef signed $gint32 gint32;
2391 typedef unsigned $gint32 guint32;
2392 #define G_GINT32_MODIFIER $gint32_modifier
2393 #define G_GINT32_FORMAT $gint32_format
2394 #define G_GUINT32_FORMAT $guint32_format
2398 cat >>$outfile <<_______EOF
2399 #define G_HAVE_GINT64 1 /* deprecated, always true */
2401 ${glib_extension}typedef signed $gint64 gint64;
2402 ${glib_extension}typedef unsigned $gint64 guint64;
2404 #define G_GINT64_CONSTANT(val) $gint64_constant
2405 #define G_GUINT64_CONSTANT(val) $guint64_constant
2408 if test x$gint64_format != x ; then
2409 cat >>$outfile <<_______EOF
2410 #define G_GINT64_MODIFIER $gint64_modifier
2411 #define G_GINT64_FORMAT $gint64_format
2412 #define G_GUINT64_FORMAT $guint64_format
2415 cat >>$outfile <<_______EOF
2416 #undef G_GINT64_MODIFIER
2417 #undef G_GINT64_FORMAT
2418 #undef G_GUINT64_FORMAT
2422 cat >>$outfile <<_______EOF
2424 #define GLIB_SIZEOF_VOID_P $glib_void_p
2425 #define GLIB_SIZEOF_LONG $glib_long
2426 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2430 cat >>$outfile <<_______EOF
2431 typedef signed $glib_size_type_define gssize;
2432 typedef unsigned $glib_size_type_define gsize;
2433 #define G_GSIZE_MODIFIER $gsize_modifier
2434 #define G_GSSIZE_FORMAT $gssize_format
2435 #define G_GSIZE_FORMAT $gsize_format
2437 #define G_MAXSIZE G_MAXU$glib_msize_type
2438 #define G_MINSSIZE G_MIN$glib_msize_type
2439 #define G_MAXSSIZE G_MAX$glib_msize_type
2441 typedef gint64 goffset;
2442 #define G_MINOFFSET G_MININT64
2443 #define G_MAXOFFSET G_MAXINT64
2447 if test -z "$glib_unknown_void_p"; then
2448 cat >>$outfile <<_______EOF
2450 #define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2451 #define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2453 #define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2454 #define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2457 echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2462 cat >>$outfile <<_______EOF
2471 #define G_HAVE_INLINE 1
2472 #else /* !__cplusplus */
2474 #endif /* !__cplusplus */
2477 #define G_CAN_INLINE 1
2480 if test x$g_can_inline = xyes ; then
2481 cat >>$outfile <<_______EOF
2482 #else /* !__cplusplus */
2483 #define G_CAN_INLINE 1
2487 cat >>$outfile <<_______EOF
2492 if test x$g_have_iso_c_varargs = xyes ; then
2493 cat >>$outfile <<_______EOF
2495 # define G_HAVE_ISO_VARARGS 1
2499 if test x$g_have_iso_cxx_varargs = xyes ; then
2500 cat >>$outfile <<_______EOF
2502 # define G_HAVE_ISO_VARARGS 1
2506 if test x$g_have_gnuc_varargs = xyes ; then
2507 cat >>$outfile <<_______EOF
2509 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2510 * is passed ISO vararg support is turned off, and there is no work
2511 * around to turn it on, so we unconditionally turn it off.
2513 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2514 # undef G_HAVE_ISO_VARARGS
2517 #define G_HAVE_GNUC_VARARGS 1
2521 case x$g_stack_grows in
2522 xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2523 *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2528 if test x$g_have_eilseq = xno; then
2529 cat >>$outfile <<_______EOF
2531 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2532 * The correspondence between this and the corresponding definition
2533 * in libiconv is essential.
2535 # define EILSEQ ENOENT
2541 if test x$g_have_gnuc_visibility = xyes; then
2542 cat >>$outfile <<_______EOF
2543 #define G_HAVE_GNUC_VISIBILITY 1
2546 cat >>$outfile <<_______EOF
2547 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2548 #define G_GNUC_INTERNAL __hidden
2549 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2550 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2552 #define G_GNUC_INTERNAL
2558 if test x$g_mutex_has_default = xyes; then
2559 cat >>$outfile <<_______EOF
2560 $g_enable_threads_def G_THREADS_ENABLED
2561 #define G_THREADS_IMPL_$g_threads_impl_def
2562 typedef struct _GStaticMutex GStaticMutex;
2563 struct _GStaticMutex
2565 struct _GMutex *runtime_mutex;
2567 char pad[[$g_mutex_sizeof]];
2568 double dummy_double;
2569 void *dummy_pointer;
2573 #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2574 #define g_static_mutex_get_mutex(mutex) \\
2575 (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2576 g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2579 cat >>$outfile <<_______EOF
2580 $g_enable_threads_def G_THREADS_ENABLED
2581 #define G_THREADS_IMPL_$g_threads_impl_def
2582 typedef struct _GMutex* GStaticMutex;
2583 #define G_STATIC_MUTEX_INIT NULL
2584 #define g_static_mutex_get_mutex(mutex) \\
2585 (g_static_mutex_get_mutex_impl_shortcut (mutex))
2589 cat >>$outfile <<_______EOF
2590 /* This represents a system thread as used by the implementation. An
2591 * alien implementaion, as loaded by g_thread_init can only count on
2592 * "sizeof (gpointer)" bytes to store their info. We however need more
2593 * for some of our native implementations. */
2594 typedef union _GSystemThread GSystemThread;
2595 union _GSystemThread
2597 char data[[$g_system_thread_sizeof]];
2598 double dummy_double;
2599 void *dummy_pointer;
2603 if test x"$g_memory_barrier_needed" != xno; then
2605 echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2609 g_bit_sizes="16 32 64"
2610 for bits in $g_bit_sizes; do
2611 cat >>$outfile <<_______EOF
2612 #define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2613 #define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2614 #define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2615 #define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2619 cat >>$outfile <<_______EOF
2620 #define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2621 #define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2622 #define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2623 #define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2624 #define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2625 #define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2626 #define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2627 #define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2628 #define G_BYTE_ORDER $g_byte_order
2630 #define GLIB_SYSDEF_POLLIN =$g_pollin
2631 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2632 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2633 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2634 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2635 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2637 #define G_MODULE_SUFFIX "$g_module_suffix"
2639 typedef $g_pid_type GPid;
2643 #endif /* GLIBCONFIG_H */
2647 if cmp -s $outfile glibconfig.h; then
2648 AC_MSG_NOTICE([glibconfig.h is unchanged])
2651 mv $outfile glibconfig.h
2655 # Note that if two cases are the same, case goes with the first one.
2656 # Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2657 # on variable expansion in case labels. Look at the generated config.status
2660 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2661 glib_header_alloca_h="$ac_cv_working_alloca_h"
2663 glib_header_alloca_h="$ac_cv_header_alloca_h"
2667 x$ac_cv_header_float_h)
2669 glib_mf=FLT_MIN glib_Mf=FLT_MAX
2670 glib_md=DBL_MIN glib_Md=DBL_MAX
2672 x$ac_cv_header_values_h)
2674 glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2675 glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2680 x$ac_cv_header_limits_h)
2682 glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2683 glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2684 glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2686 x$ac_cv_header_values_h)
2688 glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2689 glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2690 glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2694 if test x$ac_cv_header_sys_poll_h = xyes ; then
2699 $ac_cv_sizeof_short)
2701 gint16_modifier='"h"'
2702 gint16_format='"hi"'
2703 guint16_format='"hu"'
2707 gint16_modifier='""'
2709 guint16_format='"u"'
2713 $ac_cv_sizeof_short)
2715 gint32_modifier='"h"'
2716 gint32_format='"hi"'
2717 guint32_format='"hu"'
2721 gint32_modifier='""'
2723 guint32_format='"u"'
2727 gint32_modifier='"l"'
2728 gint32_format='"li"'
2729 guint32_format='"lu"'
2735 gint64_modifier='""'
2737 guint64_format='"u"'
2739 gint64_constant='(val)'
2740 guint64_constant='(val)'
2744 gint64_modifier='"l"'
2745 gint64_format='"li"'
2746 guint64_format='"lu"'
2748 gint64_constant='(val##L)'
2749 guint64_constant='(val##UL)'
2751 $ac_cv_sizeof_long_long)
2753 if test -n "$glib_cv_long_long_format"; then
2754 gint64_modifier='"'$glib_cv_long_long_format'"'
2755 gint64_format='"'$glib_cv_long_long_format'i"'
2756 guint64_format='"'$glib_cv_long_long_format'u"'
2758 glib_extension='G_GNUC_EXTENSION '
2759 gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2760 guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
2762 $ac_cv_sizeof___int64)
2764 if test -n "$glib_cv_long_long_format"; then
2765 gint64_modifier='"'$glib_cv_long_long_format'"'
2766 gint64_format='"'$glib_cv_long_long_format'i"'
2767 guint64_format='"'$glib_cv_long_long_format'u"'
2770 gint64_constant='(val##i64)'
2771 guint64_constant='(val##ui64)'
2774 glib_size_t=$ac_cv_sizeof_size_t
2775 glib_size_type_define=$glib_size_type
2776 glib_void_p=$ac_cv_sizeof_long
2777 glib_long=$ac_cv_sizeof_void_p
2779 case $glib_size_type in
2781 gsize_modifier='"h"'
2783 gssize_format='"hi"'
2784 glib_msize_type='SHRT'
2790 glib_msize_type='INT'
2793 gsize_modifier='"l"'
2795 gssize_format='"li"'
2796 glib_msize_type='LONG'
2800 gintbits=`expr $ac_cv_sizeof_int \* 8`
2801 glongbits=`expr $ac_cv_sizeof_long \* 8`
2804 case $ac_cv_sizeof_void_p in
2805 $ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
2806 $ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2807 *) glib_unknown_void_p=yes ;;
2812 x$ac_cv_func_atexit)
2814 #ifdef NeXT /* @#%@! NeXTStep */
2815 # define g_ATEXIT(proc) (!atexit (proc))
2817 # define g_ATEXIT(proc) (atexit (proc))
2820 x$ac_cv_func_on_exit)
2822 #define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
2827 x$ac_cv_func_memmove)
2829 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
2831 x$glib_cv_working_bcopy)
2833 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2834 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2838 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2839 * so we have to roll our own copy routine. */
2840 void g_memmove (void* dest, const void * src, unsigned long len);"
2845 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2846 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2847 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2851 x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
2852 x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
2856 if test x$glib_cv_va_val_copy = xno; then
2857 glib_vacopy="\$glib_vacopy
2858 #define G_VA_COPY_AS_ARRAY 1"
2861 if test x$glib_cv_hasinline = xyes; then
2862 glib_inline='#define G_HAVE_INLINE 1'
2864 if test x$glib_cv_has__inline = xyes; then
2865 glib_inline="\$glib_inline
2866 #define G_HAVE___INLINE 1"
2868 if test x$glib_cv_has__inline__ = xyes; then
2869 glib_inline="\$glib_inline
2870 #define G_HAVE___INLINE__ 1"
2873 g_have_gnuc_varargs=$g_have_gnuc_varargs
2874 g_have_iso_c_varargs=$g_have_iso_c_varargs
2875 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2877 g_can_inline=$g_can_inline
2878 g_have_gnuc_visibility=$g_have_gnuc_visibility
2879 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
2882 x$ac_cv_c_bigendian)
2883 g_byte_order=G_BIG_ENDIAN
2888 g_byte_order=G_LITTLE_ENDIAN
2894 g_pollin=$glib_cv_value_POLLIN
2895 g_pollout=$glib_cv_value_POLLOUT
2896 g_pollpri=$glib_cv_value_POLLPRI
2897 g_pollhup=$glib_cv_value_POLLHUP
2898 g_pollerr=$glib_cv_value_POLLERR
2899 g_pollnval=$glib_cv_value_POLLNVAL
2901 g_stack_grows=$glib_cv_stack_grows
2903 g_have_eilseq=$have_eilseq
2905 case x$have_threads in
2906 xno) g_enable_threads_def="#undef";;
2907 *) g_enable_threads_def="#define";;
2910 g_threads_impl_def=$g_threads_impl
2912 g_mutex_has_default="$mutex_has_default"
2913 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2914 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2915 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2917 g_memory_barrier_needed="$glib_memory_barrier_needed"
2919 g_module_suffix="$glib_gmodule_suffix"
2921 g_pid_type="$glib_pid_type"
2924 glib_os="#define G_OS_BEOS"
2927 glib_os="#define G_OS_UNIX
2928 #define G_PLATFORM_WIN32
2929 #define G_WITH_CYGWIN"
2932 glib_os="#define G_OS_WIN32
2933 #define G_PLATFORM_WIN32"
2936 glib_os="#define G_OS_UNIX"
2943 glib-2.0-uninstalled.pc
2945 gmodule-export-2.0.pc
2946 gmodule-no-export-2.0.pc
2947 gmodule-2.0-uninstalled.pc
2948 gmodule-no-export-2.0-uninstalled.pc
2950 gthread-2.0-uninstalled.pc
2952 gobject-2.0-uninstalled.pc
2957 build/win32/Makefile
2958 build/win32/dirent/Makefile
2959 build/win32/vs8/Makefile
2961 glib/libcharset/Makefile
2962 glib/gnulib/Makefile
2964 glib/update-pcre/Makefile
2966 gmodule/gmoduleconf.h
2968 gobject/glib-mkenums
2972 docs/reference/Makefile
2973 docs/reference/glib/Makefile
2974 docs/reference/glib/version.xml
2975 docs/reference/gobject/Makefile
2976 docs/reference/gobject/version.xml
2978 tests/gobject/Makefile
2979 tests/refcount/Makefile
2983 AC_CONFIG_COMMANDS([chmod-scripts],
2984 [chmod 0755 glib-zip
2985 chmod 0755 glib-gettextize
2986 chmod 0755 gobject/glib-mkenums])
2988 # we want to invoke this macro solely so that the config.status script
2989 # and automake generated makefiles know about these generated files.
2990 # They are only needed to distcheck the package
2999 gmodule/makefile.msc
3001 gobject/makefile.msc
3003 gthread/makefile.msc