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)
10 m4_include(acglib.m4)dnl
11 m4_include(glib/libcharset/codeset.m4)dnl
12 m4_include(glib/libcharset/glibc21.m4)dnl
13 m4_include(m4macros/glib-gettext.m4)dnl
16 # The following version number definitions apply to GLib, GModule, GObject
17 # and GThread as a whole, so if changes occoured in any of them, they are all
18 # treated with the same interface and binary age.
21 # glib_micro_version += 1;
22 # glib_interface_age += 1;
23 # glib_binary_age += 1;
24 # if any functions have been added, set glib_interface_age to 0.
25 # if backwards compatibility has been broken,
26 # set glib_binary_age _and_ glib_interface_age to 0.
28 m4_define([glib_major_version], [2])
29 m4_define([glib_minor_version], [5])
30 m4_define([glib_micro_version], [2])
31 m4_define([glib_interface_age], [0])
32 m4_define([glib_binary_age],
33 [m4_eval(100 * glib_minor_version + glib_micro_version)])
34 m4_define([glib_version],
35 [glib_major_version.glib_minor_version.glib_micro_version])
37 # libtool version related macros
38 m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
39 m4_define([glib_lt_current],
40 [m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
41 m4_define([glib_lt_revision], [glib_interface_age])
42 m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
43 m4_define([glib_lt_current_minus_age],
44 [m4_eval(glib_lt_current - glib_lt_age)])
46 # if the minor version number is odd, then we want debugging. Otherwise
47 # we only want minimal debugging support.
48 m4_define([glib_debug_default],
49 [m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
52 AC_INIT(glib, [glib_version],
53 [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
55 AC_CONFIG_SRCDIR([glib/glib.h])
57 # Save this value here, since automake will set cflags later
58 cflags_set=${CFLAGS+set}
60 AM_INIT_AUTOMAKE([no-define])
62 # Specify a configuration file
63 AM_CONFIG_HEADER([config.h])
66 GLIB_MAJOR_VERSION=glib_major_version
67 GLIB_MINOR_VERSION=glib_minor_version
68 GLIB_MICRO_VERSION=glib_micro_version
69 GLIB_INTERFACE_AGE=glib_interface_age
70 GLIB_BINARY_AGE=glib_binary_age
71 GLIB_VERSION=glib_version
73 AC_SUBST(GLIB_MAJOR_VERSION)
74 AC_SUBST(GLIB_MINOR_VERSION)
75 AC_SUBST(GLIB_MICRO_VERSION)
76 AC_SUBST(GLIB_VERSION)
77 AC_SUBST(GLIB_INTERFACE_AGE)
78 AC_SUBST(GLIB_BINARY_AGE)
80 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
81 [Define to the GLIB major version])
82 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
83 [Define to the GLIB minor version])
84 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
85 [Define to the GLIB micro version])
86 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
87 [Define to the GLIB interface age])
88 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
89 [Define to the GLIB binary age])
92 LT_RELEASE=glib_lt_release
93 LT_CURRENT=glib_lt_current
94 LT_REVISION=glib_lt_revision
96 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
101 AC_SUBST(LT_CURRENT_MINUS_AGE)
103 dnl Initialize maintainer mode
108 AC_MSG_CHECKING([for the BeOS])
111 glib_native_beos="yes"
114 glib_native_beos="no"
117 AC_MSG_RESULT([$glib_native_beos])
121 AC_MSG_CHECKING([for Win32])
124 glib_native_win32=yes
125 G_LIB_WIN32_RESOURCE=glib-win32res.lo
126 G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo
127 G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo
128 G_THREAD_WIN32_RESOURCE=gthread-win32res.lo
130 GMODULE_DEF=gmodule.def
131 GOBJECT_DEF=gobject.def
132 GTHREAD_DEF=gthread.def
133 TESTGMODULE_EXP=testgmodule.exp
134 glib_pid_type='void *'
138 G_LIB_WIN32_RESOURCE=
139 G_MODULE_WIN32_RESOURCE=
140 G_OBJECT_WIN32_RESOURCE=
141 G_THREAD_WIN32_RESOURCE=
150 AC_MSG_RESULT([$glib_native_win32])
151 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
152 AC_SUBST(G_LIB_WIN32_RESOURCE)
153 AC_SUBST(G_MODULE_WIN32_RESOURCE)
154 AC_SUBST(G_OBJECT_WIN32_RESOURCE)
155 AC_SUBST(G_THREAD_WIN32_RESOURCE)
157 AC_SUBST(GMODULE_DEF)
158 AC_SUBST(GOBJECT_DEF)
159 AC_SUBST(GTHREAD_DEF)
160 AC_SUBST(TESTGMODULE_EXP)
162 if test "$glib_native_win32" = "yes"; then
163 AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
165 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
167 dnl declare --enable-* args and collect ac_help strings
169 AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
170 [turn on debugging @<:@default=glib_debug_default@:>@]),,
171 enable_debug=glib_debug_default)
173 AC_ARG_ENABLE(gc_friendly,
174 [AC_HELP_STRING([--enable-gc-friendly],
175 [turn on garbage collector friendliness [default=no]])],,
176 [enable_gc_friendly=no])
177 AC_ARG_ENABLE(mem_pools,
178 [AC_HELP_STRING([--disable-mem-pools],
179 [disable all glib memory pools])],,
180 [disable_mem_pools=no])
182 [AC_HELP_STRING([--enable-ansi],
183 [turn on strict ansi [default=no]])],,
185 AC_ARG_ENABLE(threads,
186 [AC_HELP_STRING([--enable-threads],
187 [turn on basic thread support [default=yes]
188 ([=no] will override --with-threads)])],,
189 [enable_threads=yes])
190 AC_ARG_ENABLE(rebuilds,
191 [AC_HELP_STRING([--disable-rebuilds],
192 [disable all source autogeneration rules])],,
193 [enable_rebuilds=yes])
195 if test "x$enable_threads" != "xyes"; then
199 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, ["${enable_debug}"],
200 [Whether glib was compiled with debugging enabled])
202 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
203 if test "x$enable_gc_friendly" = "xyes"; then
204 AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
205 AC_SUBST(ENABLE_GC_FRIENDLY)
211 AC_MSG_CHECKING([whether to disable memory pools])
212 if test "x$disable_mem_pools" = "xno"; then
215 AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
216 AC_SUBST(DISABLE_MEM_POOLS)
220 if test "$glib_native_win32" = "yes"; then
221 if test x$enable_static = xyes -o x$enable_static = x; then
222 AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
225 if test x$enable_shared = xno; then
226 AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
231 dnl Checks for programs.
234 dnl Check for a working C++ compiler, but do not bail out, if none is found.
235 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
238 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
239 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
250 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
251 if test x$PKG_CONFIG = xno ; then
252 AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
255 if $PKG_CONFIG --atleast-pkgconfig-version 0.14 ; then
258 AC_MSG_ERROR([*** pkg-config too old; version 0.14 or better required.])
261 if test "x$enable_debug" = "xyes"; then
262 if test x$cflags_set != xset ; then
264 *[[\ \ ]]-g[[\ \ ]]*) ;;
265 *) CFLAGS="$CFLAGS -g" ;;
269 GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
271 GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
273 if test "x$enable_debug" = "xno"; then
274 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
278 # Ensure MSVC-compatible struct packing convention is used when
279 # compiling for Win32 with gcc.
280 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
281 # gcc2 uses "-fnative-struct".
282 if test x"$glib_native_win32" = xyes; then
283 if test x"$GCC" = xyes; then
285 AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
286 if test -z "$ac_cv_prog_CC"; then
289 our_gcc="$ac_cv_prog_CC"
291 case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
293 if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
294 msnative_struct='-fnative-struct'
298 if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
299 msnative_struct='-mms-bitfields'
303 if test x"$msnative_struct" = x ; then
304 AC_MSG_RESULT([no way])
305 AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
307 CFLAGS="$CFLAGS $msnative_struct"
308 AC_MSG_RESULT([${msnative_struct}])
315 # define a MAINT-like variable REBUILD which is set if Perl
316 # and awk are found, so autogenerated sources can be rebuilt
318 AC_CHECK_PROGS(PERL, [perl5 perl])
319 # We would like indent, but don't require it.
320 AC_CHECK_PROG(INDENT, indent, indent)
322 if test "x$enable_rebuilds" = "xyes" && \
324 $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
325 test -n "$AWK" ; then
330 # Need full path to Perl for glib-mkenums
332 if test "x$PERL" != x ; then
333 AC_PATH_PROG(PERL_PATH, [$PERL])
335 PERL_PATH="/usr/bin/env perl"
339 dnl ***********************
340 dnl *** Tests for iconv ***
341 dnl ***********************
343 dnl We do this before the gettext checks, to avoid distortion
345 AC_ARG_WITH(libiconv,
346 [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
347 [use the libiconv library])],,
348 [with_libiconv=maybe])
351 case $with_libiconv in
353 # Check in the C library first
354 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
355 # Check if we have GNU libiconv
356 if test $found_iconv = "no"; then
357 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
359 # Check if we have a iconv in -liconv, possibly from vendor
360 if test $found_iconv = "no"; then
361 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
365 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
368 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
371 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
375 if test "x$found_iconv" = "xno" ; then
376 AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
383 ALL_LINGUAS="am ar az be bg bn bs ca cs cy da de el en_CA en_GB eo es et eu fa fi fr ga gl gu he hi hr id is it ja ko lt lv mk mn ms ne nl nn no pa pl pt pt_BR ro ru sk sl sq sr sr@ije sr@Latn sv ta tr uk vi wa yi zh_CN zh_TW"
386 if test "$gt_cv_have_gettext" != "yes" ; then
388 *** You must have either have gettext support in your C library, or use the
389 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
393 LIBS="$INTLLIBS $LIBS"
395 GETTEXT_PACKAGE=glib20
396 AC_SUBST(GETTEXT_PACKAGE)
397 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
398 [Define the gettext package to be used])
400 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
403 dnl Now we are done with gettext checks, figure out ICONV_LIBS
406 if test x$with_libiconv != xno ; then
407 case " $INTLLIBS " in
408 *[[\ \ ]]-liconv[[\ \ ]]*) ;;
409 *) ICONV_LIBS="-liconv" ;;
414 case $with_libiconv in
416 AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
419 AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
423 dnl Initialize libtool
427 if test "x$GCC" = "xyes"; then
429 *[[\ \ ]]-Wall[[\ \ ]]*) ;;
430 *) CFLAGS="$CFLAGS -Wall" ;;
433 if test "x$enable_ansi" = "xyes"; then
435 *[[\ \ ]]-ansi[[\ \ ]]*) ;;
436 *) CFLAGS="$CFLAGS -ansi" ;;
440 *[[\ \ ]]-pedantic[[\ \ ]]*) ;;
441 *) CFLAGS="$CFLAGS -pedantic" ;;
447 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
449 if test $cross_compiling != yes ; then
450 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
453 AC_TRY_RUN([#include <math.h>
454 int main (void) { return (log(1) != log(1.)); }],
455 AC_MSG_RESULT(none needed),
456 glib_save_CFLAGS=$CFLAGS
457 CFLAGS="$CFLAGS -std1"
458 AC_TRY_RUN([#include <math.h>
459 int main (void) { return (log(1) != log(1.)); }],
460 AC_MSG_RESULT(-std1),
462 CFLAGS=$glib_save_CFLAGS
464 [No ANSI prototypes found in library. (-std1 didn't work.)])
470 dnl NeXTStep cc seems to need this
471 AC_MSG_CHECKING([for extra flags for POSIX compliance])
472 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
473 AC_MSG_RESULT(none needed),
474 glib_save_CFLAGS=$CFLAGS
475 CFLAGS="$CFLAGS -posix"
476 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
477 AC_MSG_RESULT(-posix),
479 CFLAGS=$glib_save_CFLAGS
480 AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
482 # Checks for header files.
485 # Checks for library functions.
490 AC_CHECK_FUNCS(atexit on_exit)
492 AC_CHECK_SIZEOF(char)
493 AC_CHECK_SIZEOF(short)
494 AC_CHECK_SIZEOF(long)
496 AC_CHECK_SIZEOF(void *)
497 AC_CHECK_SIZEOF(long long)
498 AC_CHECK_SIZEOF(__int64)
500 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
504 *** GLib requires a 64 bit type. You might want to consider
505 *** using the GNU C compiler.
509 if test x$ac_cv_sizeof_long_long = x8; then
510 # long long is a 64 bit integer.
511 AC_MSG_CHECKING(for format to printf and scanf a guint64)
512 AC_CACHE_VAL(glib_cv_long_long_format,[
513 for format in ll q I64; do
514 AC_TRY_RUN([#include <stdio.h>
517 long long b, a = -0x3AFAFAFAFAFAFAFALL;
519 sprintf (buffer, "%${format}u", a);
520 sscanf (buffer, "%${format}u", &b);
524 [glib_cv_long_long_format=${format}
528 if test -n "$glib_cv_long_long_format"; then
529 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
530 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
531 if test x"$glib_cv_long_long_format" = xI64; then
532 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
537 elif test x$ac_cv_sizeof___int64 = x8; then
538 # __int64 is a 64 bit integer.
539 AC_MSG_CHECKING(for format to printf and scanf a guint64)
540 # We know this is MSVC, and what the formats are
541 glib_cv_long_long_format=I64
542 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
543 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
544 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
547 dnl long doubles were not used, and a portability problem
551 dnl ok, here we try to check whether the systems prototypes for
552 dnl malloc and friends actually match the prototypes provided
553 dnl by gmem.h (keep in sync). i currently only know how to check
554 dnl this reliably with gcc (-Werror), improvements for other
555 dnl compilers are apprechiated.
556 SANE_MALLOC_PROTOS=no
557 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
558 glib_save_CFLAGS=$CFLAGS
559 if test "x$GCC" = "xyes"; then
560 CFLAGS="$CFLAGS -Werror"
561 AC_TRY_COMPILE([#include <stdlib.h>], [
562 void* (*my_calloc_p) (size_t, size_t) = calloc;
563 void* (*my_malloc_p) (size_t) = malloc;
564 void (*my_free_p) (void*) = free;
565 void* (*my_realloc_p) (void*, size_t) = realloc;
571 AC_DEFINE(SANE_MALLOC_PROTOS, 1,
572 [Define if you have correct malloc prototypes])
573 SANE_MALLOC_PROTOS=yes)
575 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
576 CFLAGS=$glib_save_CFLAGS
579 dnl check in which direction the stack grows
581 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
583 volatile int *a = 0, *b = 0;
585 int main () { volatile int y = 7; a = &y; foo (); return b > a; }
586 void foo (void) { volatile int x = 5; b = &x; }
588 glib_cv_stack_grows=no
590 glib_cv_stack_grows=yes
594 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
595 dnl truely know which ones of `inline', `__inline' and `__inline__' are
596 dnl actually supported.
597 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
599 __inline int foo () { return 0; }
600 int main () { return foo (); }
602 glib_cv_has__inline=yes
604 glib_cv_has__inline=no
607 case x$glib_cv_has__inline in
608 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
610 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
612 __inline__ int foo () { return 0; }
613 int main () { return foo (); }
615 glib_cv_has__inline__=yes
617 glib_cv_has__inline__=no
620 case x$glib_cv_has__inline__ in
621 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
623 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
626 inline int foo () { return 0; }
627 int main () { return foo (); }
629 glib_cv_hasinline=yes
634 case x$glib_cv_hasinline in
635 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
638 # check for flavours of varargs macros
639 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
641 int a(int p1, int p2, int p3);
642 #define call_a(...) a(1,__VA_ARGS__)
644 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
645 AC_MSG_RESULT($g_have_iso_c_varargs)
647 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
648 if test "$CXX" = ""; then
650 g_have_iso_cxx_varargs=no
654 int a(int p1, int p2, int p3);
655 #define call_a(...) a(1,__VA_ARGS__)
657 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
660 AC_MSG_RESULT($g_have_iso_cxx_varargs)
662 AC_MSG_CHECKING(for GNUC varargs macros)
664 int a(int p1, int p2, int p3);
665 #define call_a(params...) a(1,params)
667 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
668 AC_MSG_RESULT($g_have_gnuc_varargs)
670 # check for GNUC visibility support
671 AC_MSG_CHECKING(for GNUC visibility attribute)
672 GLIB_CHECK_COMPILE_WARNINGS([
674 __attribute__ ((visibility ("hidden")))
679 int main (int argc, char **argv)
684 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
685 AC_MSG_RESULT($g_have_gnuc_visibility)
687 # check for bytesex stuff
690 # check for header files
691 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h sys/types.h])
692 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
694 # Checks for libcharset
697 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
698 AC_CHECK_FUNCS(setlocale)
700 # check additional type sizes
701 AC_CHECK_SIZEOF(size_t)
703 dnl Try to figure out whether gsize, gssize should be long or int
704 AC_MSG_CHECKING([for the appropriate definition for size_t])
706 case $ac_cv_sizeof_size_t in
716 *) AC_MSG_ERROR([No type matching size_t in size])
720 dnl If int/long are the same size, we see which one produces
721 dnl warnings when used in the location as size_t. (This matters
724 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
725 test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
726 GLIB_CHECK_COMPILE_WARNINGS([
731 unsigned int *size_int = &s;
732 return (int)*size_int;
734 ],glib_size_type=int,
735 [GLIB_CHECK_COMPILE_WARNINGS([
740 unsigned long *size_long = &s;
741 return (int)*size_long;
743 ],glib_size_type=long)])
746 AC_MSG_RESULT(unsigned $glib_size_type)
748 # Check for some functions
749 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf setenv unsetenv getc_unlocked readlink symlink)
751 AC_FUNC_VSNPRINTF_C99
752 AC_FUNC_PRINTF_UNIX98
755 # Check whether to use an included printf
758 AC_ARG_ENABLE(included-printf,
759 [AC_HELP_STRING([--enable-included-printf],
760 [use included printf [default=auto]])],
761 enable_included_printf="$enableval")
763 need_included_printf=no
764 if test "x$enable_included_printf" = "xyes" ; then
765 need_included_printf=yes
767 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
768 need_included_printf=yes
770 if test "$ac_cv_func_printf_unix98" != "yes" ; then
771 need_included_printf=yes
773 if test "x$ac_cv_sizeof_long_long" = "x8" &&
774 test -z "$glib_cv_long_long_format" ; then
775 need_included_printf=yes
778 if test "x$enable_included_printf" = "xno" &&
779 test "x$need_included_printf" = "xyes" ; then
781 *** Your C library's printf doesn't appear to have the features that
782 *** GLib needs, but you specified --enable-included-printf=no.])
785 enable_included_printf=$need_included_printf
787 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
788 if test "$enable_included_printf" != "yes" ; then
789 AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
791 if test -z "$glib_cv_long_long_format" ; then
792 glib_cv_long_long_format="ll"
794 AC_DEFINE(HAVE_VASPRINTF,1)
797 # Checks needed for gnulib vasnprintf
804 AC_CHECK_TYPES(ptrdiff_t)
806 AC_CHECK_FUNCS(snprintf)
809 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
810 # The check is borrowed from the PERL Configure script.
811 if test "$ac_cv_func_memmove" != "yes"; then
812 AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
813 glib_cv_working_bcopy,[AC_TRY_RUN([
815 char buf[128], abc[128], *b;
817 bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
818 for (align = 7; align >= 0; align--) {
819 for (len = 36; len; len--) {
820 b = buf+align; bcopy(abc, b, len);
821 for (off = 1; off <= len; off++) {
822 bcopy(b, b+off, len); bcopy(b+off, b, len);
823 if (bcmp(b, abc, len)) return(1);
828 }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
830 GLIB_ASSERT_SET(glib_cv_working_bcopy)
831 if test "$glib_cv_working_bcopy" = "yes"; then
832 AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
836 # Check for sys_errlist
837 AC_MSG_CHECKING(for sys_errlist)
839 extern char *sys_errlist[];
841 sys_errlist[sys_nerr-1][0] = 0;
842 ], glib_ok=yes, glib_ok=no)
843 AC_MSG_RESULT($glib_ok)
844 if test "$glib_ok" = "no"; then
845 AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
848 # Check for sys_siglist
849 AC_MSG_CHECKING(for sys_siglist)
851 extern char *sys_siglist[];
852 exit (sys_siglist[0]);
853 ], glib_ok=yes, glib_ok=no)
854 AC_MSG_RESULT($glib_ok)
855 if test "$glib_ok" = "no"; then
856 AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
859 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
860 AC_MSG_CHECKING(for sys_siglist declaration)
861 AC_TRY_COMPILE([#include <signal.h>], [
862 strlen (sys_siglist[0]);
863 ], glib_ok=yes, glib_ok=no)
864 AC_MSG_RESULT($glib_ok)
865 if test "$glib_ok" = "no"; then
866 AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
869 # Check if <sys/select.h> needs to be included for fd_set
870 AC_MSG_CHECKING([for fd_set])
871 AC_TRY_COMPILE([#include <sys/types.h>],
872 [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
873 if test "$gtk_ok" = "yes"; then
874 AC_MSG_RESULT([yes, found in sys/types.h])
876 AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
877 if test "$gtk_ok" = "yes"; then
878 # *** FIXME: give it a different name
879 AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
880 AC_MSG_RESULT([yes, found in sys/select.h])
882 AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
887 dnl *** check for sane realloc() ***
888 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
889 AC_TRY_RUN([#include <stdlib.h>
891 return realloc (0, sizeof (int)) == 0;
893 [glib_cv_sane_realloc=yes],
894 [glib_cv_sane_realloc=no],
895 [glib_cv_sane_realloc=yes])
897 if test x$glib_cv_sane_realloc = xyes; then
898 AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
901 dnl Check for nl_langinfo and CODESET
903 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
904 AC_TRY_COMPILE([#include <langinfo.h>],
905 [char *codeset = nl_langinfo (CODESET);],
906 AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
909 AC_MSG_RESULT($have_codeset)
912 dnl ****************************************
913 dnl *** strlcpy/strlcat ***
914 dnl ****************************************
916 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
917 AC_TRY_RUN([#include <stdlib.h>
921 (void) strlcpy (p, "hi", 10);
922 if (strlcat (p, "bye", 0) != 3)
925 }], glib_cv_have_strlcpy=yes,
926 glib_cv_have_strlcpy=no,
927 glib_cv_have_strlcpy=no)])
928 if test "$glib_cv_have_strlcpy" = "yes"; then
929 AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
933 dnl **********************
934 dnl *** va_copy checks ***
935 dnl **********************
936 dnl we currently check for all three va_copy possibilities, so we get
937 dnl all results in config.log for bug reports.
938 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
939 AC_LINK_IFELSE([#include <stdarg.h>
940 void f (int i, ...) {
941 va_list args1, args2;
943 va_copy (args2, args1);
944 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
946 va_end (args1); va_end (args2);
952 [glib_cv_va_copy=yes],
953 [glib_cv_va_copy=no])
955 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
956 AC_LINK_IFELSE([#include <stdarg.h>
957 void f (int i, ...) {
958 va_list args1, args2;
960 __va_copy (args2, args1);
961 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
963 va_end (args1); va_end (args2);
969 [glib_cv___va_copy=yes],
970 [glib_cv___va_copy=no])
973 if test "x$glib_cv_va_copy" = "xyes"; then
974 g_va_copy_func=va_copy
975 else if test "x$glib_cv___va_copy" = "xyes"; then
976 g_va_copy_func=__va_copy
980 if test -n "$g_va_copy_func"; then
981 AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
984 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
985 AC_TRY_RUN([#include <stdarg.h>
986 void f (int i, ...) {
987 va_list args1, args2;
990 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
992 va_end (args1); va_end (args2);
998 [glib_cv_va_val_copy=yes],
999 [glib_cv_va_val_copy=no],
1000 [glib_cv_va_val_copy=yes])
1003 if test "x$glib_cv_va_val_copy" = "xno"; then
1004 AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1007 dnl ***********************
1008 dnl *** g_module checks ***
1009 dnl ***********************
1011 G_MODULE_LIBS_EXTRA=
1012 G_MODULE_PLUGIN_LIBS=
1013 if test x"$glib_native_win32" = xyes; then
1014 dnl No use for this on Win32
1017 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1019 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1020 G_MODULE_NEED_USCORE=0
1021 G_MODULE_BROKEN_RTLD_GLOBAL=0
1022 G_MODULE_HAVE_DLERROR=0
1023 dnl *** force native WIN32 shared lib loader
1024 if test -z "$G_MODULE_IMPL"; then
1026 *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1029 dnl *** force native AIX library loader
1030 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1031 if test -z "$G_MODULE_IMPL"; then
1033 *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1036 dnl *** dlopen() and dlsym() in system libraries
1037 if test -z "$G_MODULE_IMPL"; then
1038 AC_CHECK_FUNC(dlopen,
1039 [AC_CHECK_FUNC(dlsym,
1040 [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1043 dnl *** load_image (BeOS)
1044 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1045 AC_CHECK_LIB(root, load_image,
1046 [G_MODULE_LIBS="-lbe -lroot -lglib"
1047 G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1048 G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1049 G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1052 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1053 if test -z "$G_MODULE_IMPL"; then
1054 AC_CHECK_FUNC(NSLinkModule,
1055 [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1056 G_MODULE_NEED_USCORE=1],
1059 dnl *** dlopen() and dlsym() in libdl
1060 if test -z "$G_MODULE_IMPL"; then
1061 AC_CHECK_LIB(dl, dlopen,
1062 [AC_CHECK_LIB(dl, dlsym,
1064 G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1067 dnl *** shl_load() in libdld (HP-UX)
1068 if test -z "$G_MODULE_IMPL"; then
1069 AC_CHECK_LIB(dld, shl_load,
1070 [G_MODULE_LIBS=-ldld
1071 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1074 dnl *** additional checks for G_MODULE_IMPL_DL
1075 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1077 LDFLAGS_orig="$LDFLAGS"
1078 LIBS="$G_MODULE_LIBS $LIBS"
1079 LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1080 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1081 echo "void glib_plugin_test(void) { }" > plugin.c
1082 ${SHELL} ./libtool --mode=compile ${CC} -shared \
1083 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1084 AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1085 glib_cv_rtldglobal_broken,[
1089 # define RTLD_GLOBAL 0
1092 # define RTLD_LAZY 0
1094 int glib_plugin_test;
1096 void *handle, *global, *local;
1097 global = &glib_plugin_test;
1098 handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1099 if (!handle) return 0;
1100 local = dlsym (handle, "glib_plugin_test");
1101 return global == local;
1103 [glib_cv_rtldglobal_broken=no],
1104 [glib_cv_rtldglobal_broken=yes],
1105 [glib_cv_rtldglobal_broken=no])
1106 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1107 rmdir .libs 2>/dev/null
1109 if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1110 G_MODULE_BROKEN_RTLD_GLOBAL=1
1112 G_MODULE_BROKEN_RTLD_GLOBAL=0
1114 dnl *** check whether we need preceeding underscores
1115 AC_CACHE_CHECK([for preceeding underscore in symbols],
1117 AC_TRY_RUN([#include <dlfcn.h>
1118 int glib_underscore_test (void) { return 42; }
1120 void *f1 = (void*)0, *f2 = (void*)0, *handle;
1121 handle = dlopen ((void*)0, 0);
1123 f1 = dlsym (handle, "glib_underscore_test");
1124 f2 = dlsym (handle, "_glib_underscore_test");
1125 } return (!f2 || f1);
1127 [glib_cv_uscore=yes],
1128 [glib_cv_uscore=no],
1130 rm -f plugin.c plugin.$ac_objext plugin.lo
1132 GLIB_ASSERT_SET(glib_cv_uscore)
1133 if test "x$glib_cv_uscore" = "xyes"; then
1134 G_MODULE_NEED_USCORE=1
1136 G_MODULE_NEED_USCORE=0
1139 LDFLAGS="$LDFLAGS_orig"
1140 dnl *** check for having dlerror()
1141 AC_CHECK_FUNC(dlerror,
1142 [G_MODULE_HAVE_DLERROR=1],
1143 [G_MODULE_HAVE_DLERROR=0])
1146 dnl *** done, have we got an implementation?
1147 if test -z "$G_MODULE_IMPL"; then
1149 G_MODULE_SUPPORTED=false
1151 G_MODULE_SUPPORTED=true
1154 AC_MSG_CHECKING(for the suffix of shared libraries)
1156 hpux9* | hpux10* | hpux11*) # taken from ltconfig
1157 glib_gmodule_suffix='sl'
1160 glib_gmodule_suffix='dll'
1163 glib_gmodule_suffix='a'
1166 glib_gmodule_suffix='so'
1169 AC_MSG_RESULT(.$glib_gmodule_suffix)
1171 AC_SUBST(G_MODULE_SUPPORTED)
1172 AC_SUBST(G_MODULE_IMPL)
1173 AC_SUBST(G_MODULE_LIBS)
1174 AC_SUBST(G_MODULE_LIBS_EXTRA)
1175 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1176 AC_SUBST(G_MODULE_LDFLAGS)
1177 AC_SUBST(G_MODULE_HAVE_DLERROR)
1178 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1179 AC_SUBST(G_MODULE_NEED_USCORE)
1180 AC_SUBST(GLIB_DEBUG_FLAGS)
1182 dnl **********************
1183 dnl *** g_spawn checks ***
1184 dnl **********************
1186 AC_MSG_CHECKING(for gspawn implementation)
1189 GSPAWN=gspawn-win32.lo
1195 AC_MSG_RESULT($GSPAWN)
1198 dnl *************************
1199 dnl *** GIOChannel checks ***
1200 dnl *************************
1202 AC_MSG_CHECKING(for GIOChannel implementation)
1214 dnl ****************************************
1215 dnl *** platform dependent source checks ***
1216 dnl ****************************************
1218 AC_MSG_CHECKING(for platform-dependent source)
1220 *-*-cygwin*|*-*-mingw*)
1221 PLATFORMDEP=gwin32.lo
1227 AC_MSG_RESULT($PLATFORMDEP)
1228 AC_SUBST(PLATFORMDEP)
1230 AC_MSG_CHECKING([whether to compile timeloop])
1232 *-*-cygwin*|*-*-mingw*)
1239 AC_MSG_RESULT($enable_timeloop)
1240 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1242 AC_MSG_CHECKING([if building for some Win32 platform])
1244 *-*-mingw*|*-*-cygwin*)
1251 AC_MSG_RESULT($platform_win32)
1252 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1254 dnl ***********************
1255 dnl *** g_thread checks ***
1256 dnl ***********************
1258 AC_ARG_WITH(threads,
1259 [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
1260 [specify a thread implementation to use])],
1261 [if test "x$with_threads" = x; then
1264 want_threads=$with_threads
1267 if test "x$enable_threads" = "xno"; then
1271 dnl error and warning message
1272 dnl *************************
1274 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1275 computer. GLib will not have a default thread implementation."
1277 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1278 platform (normally it's "_REENTRANT"). I'll not use any flag on
1279 compilation now, but then your programs might not work.
1280 Please provide information on how it is done on your system."
1282 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1285 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1286 provide information on your thread implementation.
1287 You can also run 'configure --disable-threads'
1288 to compile without thread support."
1290 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1291 functions will not be MT-safe during their first call because
1292 there is no working 'getpwuid_r' on your system."
1294 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1295 because there is no 'localtime_r' on your system."
1297 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1298 crude surrogate will be used. If you happen to know a
1299 yield function for your system, please inform the GLib
1302 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1303 threads on your system. Thus threads can only have the default
1304 priority. If you happen to know these main/max
1305 priorities, please inform the GLib developers."
1307 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1308 linking threaded applications. As GLib cannot do that
1309 automatically, you will get an linkg error everytime you are
1310 not using the right compiler. In that case you have to relink
1311 with the right compiler. Ususally just '_r' is appended
1312 to the compiler name."
1314 dnl determination of thread implementation
1315 dnl ***************************************
1317 # have_threads=no means no thread support
1318 # have_threads=none means no default thread implementation
1321 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1324 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1328 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1329 || test "x$want_threads" = xdce; then
1330 # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1331 # -U_OSF_SOURCE is for Digital UNIX 4.0d
1332 GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1333 glib_save_CPPFLAGS="$CPPFLAGS"
1334 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1335 if test "x$have_threads" = xno; then
1336 AC_TRY_COMPILE([#include <pthread.h>],
1337 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1340 if test "x$have_threads" = xno; then
1341 AC_TRY_COMPILE([#include <pthread.h>],
1343 pthread_mutex_init (&m, pthread_mutexattr_default);],
1346 # Tru64Unix requires -pthread to find pthread.h. See #103020
1347 CPPFLAGS="$CPPFLAGS -pthread"
1348 if test "x$have_threads" = xno; then
1349 AC_TRY_COMPILE([#include <pthread.h>],
1350 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1353 CPPFLAGS="$glib_save_CPPFLAGS"
1355 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1362 if test "x$want_threads" = xnone; then
1366 AC_MSG_CHECKING(for thread implementation)
1368 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1369 AC_MSG_RESULT(none available)
1370 AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1372 AC_MSG_RESULT($have_threads)
1376 dnl determination of G_THREAD_CFLAGS
1377 dnl ********************************
1380 G_THREAD_LIBS_EXTRA=
1384 dnl Test program for basic POSIX threads functionality
1386 m4_define([glib_thread_test],[
1387 #include <pthread.h>
1389 void* func(void* data) {check_me = 42; return &check_me;}
1393 pthread_create (&t, $1, func, 0);
1394 pthread_join (t, &ret);
1395 exit (check_me != 42 || ret != &check_me);
1399 dnl Test program for sched_get_priority_min()
1401 m4_define([glib_sched_priority_test],[
1406 return sched_get_priority_min(SCHED_OTHER)==-1
1410 if test x"$have_threads" != xno; then
1412 if test x"$have_threads" = xposix; then
1413 # First we test for posix, whether -pthread or -pthreads do the trick as
1414 # both CPPFLAG and LIBS.
1415 # One of them does for most gcc versions and some other platforms/compilers
1416 # too and could be considered as the canonical way to go.
1419 # skip cygwin -pthread or -pthreads test
1422 for flag in pthread pthreads; do
1423 glib_save_CFLAGS="$CFLAGS"
1424 CFLAGS="$CFLAGS -$flag"
1425 AC_TRY_RUN(glib_thread_test(0),
1426 glib_flag_works=yes,
1428 [AC_LINK_IFELSE(glib_thread_test(0),
1429 glib_flag_works=yes,
1430 glib_flag_works=no)])
1431 CFLAGS="$glib_save_CFLAGS"
1432 if test $glib_flag_works = yes ; then
1433 G_THREAD_CFLAGS=-$flag
1434 G_THREAD_LIBS=-$flag
1441 if test x"$G_THREAD_CFLAGS" = x; then
1443 # The canonical -pthread[s] does not work. Try something different.
1447 if test x"$GCC" = xyes; then
1448 # GCC 3.0 and above needs -pthread.
1449 # Should be coverd by the case above.
1450 # GCC 2.x and below needs -mthreads
1451 G_THREAD_CFLAGS="-mthreads"
1452 G_THREAD_LIBS=$G_THREAD_CFLAGS
1454 # We are probably using the aix compiler. Normaly a
1455 # program would have to be compiled with the _r variant
1456 # of the corresponding compiler, but we as GLib cannot
1457 # do that: but the good news is that for compiling the
1458 # only difference is the added -D_THREAD_SAFE compile
1459 # option. This is according to the "C for AIX User's
1461 G_THREAD_CFLAGS="-D_THREAD_SAFE"
1465 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1468 # So we are using dce threads. posix threads are already
1470 G_THREAD_CFLAGS="-threads"
1471 G_THREAD_LIBS=$G_THREAD_CFLAGS
1474 if test x"$GCC" = xyes; then
1475 # We are using solaris threads. posix threads are
1476 # already catched above.
1477 G_THREAD_CFLAGS="-threads"
1479 G_THREAD_CFLAGS="-mt"
1481 G_THREAD_LIBS=$G_THREAD_CFLAGS
1483 *-sysv5uw7*) # UnixWare 7
1484 # We are not using gcc with -pthread. Catched above.
1485 G_THREAD_CFLAGS="-Kthread"
1486 G_THREAD_LIBS=$G_THREAD_CFLAGS
1489 # No flag needed when using MSVCRT.DLL
1493 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1499 # if we are not finding the localtime_r function, then we probably are
1500 # not using the proper multithread flag
1502 glib_save_CPPFLAGS="$CPPFLAGS"
1503 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1505 # First we test, whether localtime_r is declared in time.h
1506 # directly. Then we test whether a macro localtime_r exists, in
1507 # which case localtime_r in the test program is replaced and thus
1508 # if we still find localtime_r in the output, it is not defined as
1511 AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1512 [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1514 AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1516 CPPFLAGS="$glib_save_CPPFLAGS"
1518 AC_MSG_CHECKING(thread related cflags)
1519 AC_MSG_RESULT($G_THREAD_CFLAGS)
1520 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1523 dnl determination of G_THREAD_LIBS
1524 dnl ******************************
1526 mutex_has_default=no
1527 case $have_threads in
1529 glib_save_CPPFLAGS="$CPPFLAGS"
1530 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1531 if test x"$G_THREAD_LIBS" = x; then
1534 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1535 # probably using the aix compiler.
1536 AC_MSG_WARN($AIX_COMPILE_INFO)
1540 glib_save_LIBS="$LIBS"
1541 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1542 if test x"$thread_lib" = x; then
1546 add_thread_lib="-l$thread_lib"
1547 IN=" in -l$thread_lib"
1549 if test x"$have_threads" = xposix; then
1552 defattr=pthread_attr_default
1555 LIBS="$add_thread_lib $glib_save_LIBS"
1557 AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1558 AC_TRY_RUN(glib_thread_test($defattr),
1561 [AC_LINK_IFELSE(glib_thread_test($defattr),
1564 AC_MSG_RESULT($glib_result)
1566 if test "$glib_result" = "yes" ; then
1567 G_THREAD_LIBS="$add_thread_lib"
1571 if test "x$G_THREAD_LIBS" = xerror; then
1572 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1574 LIBS="$glib_save_LIBS"
1579 glib_save_LIBS="$LIBS"
1580 for thread_lib in "" rt rte; do
1581 if test x"$thread_lib" = x; then
1585 add_thread_lib="-l$thread_lib"
1586 IN=" in -l$thread_lib"
1588 LIBS="$add_thread_lib $glib_save_LIBS"
1590 AC_MSG_CHECKING(for sched_get_priority_min$IN)
1591 AC_TRY_RUN(glib_sched_priority_test,
1594 [AC_LINK_IFELSE(glib_sched_priority_test,
1597 AC_MSG_RESULT($glib_result)
1599 if test "$glib_result" = "yes" ; then
1600 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1601 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1602 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1606 LIBS="$glib_save_LIBS"
1607 mutex_has_default=yes
1608 mutex_default_type='pthread_mutex_t'
1609 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1610 mutex_header_file='pthread.h'
1611 if test "x$have_threads" = "xposix"; then
1612 g_threads_impl="POSIX"
1614 g_threads_impl="DCE"
1615 have_threads="posix"
1617 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1618 CPPFLAGS="$glib_save_CPPFLAGS"
1621 mutex_has_default=yes
1622 mutex_default_type='mutex_t'
1623 mutex_default_init="DEFAULTMUTEX"
1624 mutex_header_file='thread.h'
1625 g_threads_impl="SOLARIS"
1628 g_threads_impl="WIN32"
1631 g_threads_impl="NONE"
1634 g_threads_impl="NONE"
1639 if test "x$G_THREAD_LIBS" = xerror; then
1640 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1645 G_THREAD_LIBS="-lbe -lroot -lglib "
1646 G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1652 AC_MSG_CHECKING(thread related libraries)
1653 AC_MSG_RESULT($G_THREAD_LIBS)
1655 dnl check for mt safe function variants and some posix functions
1656 dnl ************************************************************
1658 if test x"$have_threads" != xno; then
1659 glib_save_LIBS="$LIBS"
1660 # we are not doing the following for now, as this might require glib
1661 # to always be linked with the thread libs on some platforms.
1662 # LIBS="$LIBS $G_THREAD_LIBS"
1663 AC_CHECK_FUNCS(localtime_r)
1664 if test "$ac_cv_header_pwd_h" = "yes"; then
1665 AC_CACHE_CHECK([for posix getpwuid_r],
1666 ac_cv_func_posix_getpwuid_r,
1672 struct passwd pwd, *pwptr = &pwd;
1675 error = getpwuid_r (0, &pwd, buffer,
1676 sizeof (buffer), &pwptr);
1677 return (error < 0 && errno == ENOSYS)
1680 [ac_cv_func_posix_getpwuid_r=yes],
1681 [ac_cv_func_posix_getpwuid_r=no])])
1682 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1683 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1684 AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1685 [Have POSIX function getpwuid_r])
1687 AC_CACHE_CHECK([for nonposix getpwuid_r],
1688 ac_cv_func_nonposix_getpwuid_r,
1689 [AC_TRY_LINK([#include <pwd.h>],
1690 [char buffer[10000];
1692 getpwuid_r (0, &pwd, buffer,
1694 [ac_cv_func_nonposix_getpwuid_r=yes],
1695 [ac_cv_func_nonposix_getpwuid_r=no])])
1696 GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1697 if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1698 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1699 [Have non-POSIX function getpwuid_r])
1703 LIBS="$G_THREAD_LIBS $LIBS"
1704 if test x"$have_threads" = xposix; then
1705 glib_save_CPPFLAGS="$CPPFLAGS"
1706 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1707 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1708 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1709 # This is not AC_CHECK_FUNC to also work with function
1710 # name mangling in header files.
1711 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1712 AC_TRY_LINK([#include <pthread.h>],
1713 [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1715 AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1716 [Have function pthread_attr_setstacksize])],
1717 [AC_MSG_RESULT(no)])
1718 AC_MSG_CHECKING(for minimal/maximal thread priority)
1719 if test x"$posix_priority_min" = x; then
1720 AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1722 posix_priority_min=PX_PRIO_MIN
1723 posix_priority_max=PX_PRIO_MAX])
1725 if test x"$posix_priority_min" = x; then
1727 AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1728 PTHREAD_PRIO_MIN],,[
1729 posix_priority_min=PTHREAD_PRIO_MIN
1730 posix_priority_max=PTHREAD_PRIO_MAX])
1732 if test x"$posix_priority_min" = x; then
1733 AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1735 posix_priority_min=PRI_OTHER_MIN
1736 posix_priority_max=PRI_OTHER_MAX])
1738 if test x"$posix_priority_min" = x; then
1739 AC_MSG_RESULT(none found)
1740 AC_MSG_WARN($POSIX_NO_PRIORITIES)
1741 posix_priority_min=-1
1742 posix_priority_max=-1
1744 AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1745 AC_MSG_CHECKING(for pthread_setschedparam)
1746 AC_TRY_LINK([#include <pthread.h>],
1747 [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1749 AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1750 AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1752 AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1754 posix_yield_func=none
1755 AC_MSG_CHECKING(for posix yield function)
1756 for yield_func in sched_yield pthread_yield_np pthread_yield \
1758 AC_TRY_LINK([#include <pthread.h>],
1760 [posix_yield_func="$yield_func"
1763 if test x"$posix_yield_func" = xnone; then
1764 AC_MSG_RESULT(none found)
1765 AC_MSG_WARN($POSIX_NO_YIELD)
1766 posix_yield_func="g_usleep(1000)"
1768 AC_MSG_RESULT($posix_yield_func)
1769 posix_yield_func="$posix_yield_func()"
1771 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1772 CPPFLAGS="$glib_save_CPPFLAGS"
1774 elif test x"$have_threads" = xwin32; then
1775 # It's a pointer to a private struct
1776 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1777 elif test x"$have_threads" = xsolaris; then
1778 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1781 LIBS="$glib_save_LIBS"
1783 # now spit out all the warnings.
1784 if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1785 test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1786 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1788 if test "$ac_cv_func_localtime_r" != "yes"; then
1789 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1793 if test x"$glib_cv_sizeof_system_thread" = x; then
1794 # use a pointer as a fallback.
1795 GLIB_SIZEOF(,void *, system_thread)
1799 # Hack to deal with:
1801 # a) GCC < 3.3 for Linux doesn't include -lpthread when
1802 # building shared libraries with linux.
1803 # b) libtool doesn't recognize -pthread as a library dependency.
1807 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1810 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
1814 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1815 [Source file containing theread implementation])
1816 AC_SUBST(G_THREAD_CFLAGS)
1817 AC_SUBST(G_THREAD_LIBS)
1818 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1819 AC_SUBST(G_THREAD_LIBS_EXTRA)
1821 dnl **********************************************
1822 dnl *** GDefaultMutex setup and initialization ***
1823 dnl **********************************************
1825 dnl if mutex_has_default = yes, we also got
1826 dnl mutex_default_type, mutex_default_init and mutex_header_file
1827 if test $mutex_has_default = yes ; then
1828 glib_save_CPPFLAGS="$CPPFLAGS"
1829 glib_save_LIBS="$LIBS"
1830 LIBS="$G_THREAD_LIBS $LIBS"
1831 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1832 GLIB_SIZEOF([#include <$mutex_header_file>],
1833 $mutex_default_type,
1835 GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1836 $mutex_default_type,
1838 $glib_cv_sizeof_gmutex,
1839 $mutex_default_init)
1840 if test x"$glib_cv_byte_contents_gmutex" = xno; then
1841 mutex_has_default=no
1843 CPPFLAGS="$glib_save_CPPFLAGS"
1844 LIBS="$glib_save_LIBS"
1847 dnl ********************************
1848 dnl *** g_atomic_* tests for gcc ***
1849 dnl ********************************
1851 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1853 if test x"$GCC" = xyes; then
1856 AC_MSG_RESULT([none])
1857 glib_memory_barrier_needed=no
1860 AC_MSG_RESULT([i486])
1861 AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1862 [i486 atomic implementation])
1863 glib_memory_barrier_needed=no
1866 SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1867 when you are using a sparc with v9 instruction set (most
1868 sparcs nowadays). This will make the code for atomic
1869 operations much faster. The resulting code will not run
1870 on very old sparcs though."
1875 int tmp1, tmp2, tmp3;
1876 __asm__ __volatile__("casx [%2], %0, %1"
1877 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1879 AC_MSG_RESULT([sparcv9])
1880 AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1881 [sparcv9 atomic implementation]),
1883 AC_MSG_WARN([[$SPARCV9_WARNING]]))
1884 glib_memory_barrier_needed=yes
1887 AC_MSG_RESULT([alpha])
1888 AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1889 [alpha atomic implementation])
1890 glib_memory_barrier_needed=yes
1893 AC_MSG_RESULT([x86_64])
1894 AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1895 [x86_64 atomic implementation])
1896 glib_memory_barrier_needed=no
1899 AC_MSG_RESULT([powerpc])
1900 AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1901 [powerpc atomic implementation])
1902 glib_memory_barrier_needed=yes
1905 AC_MSG_RESULT([ia64])
1906 AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1907 [ia64 atomic implementation])
1908 glib_memory_barrier_needed=yes
1911 AC_MSG_RESULT([none])
1912 glib_memory_barrier_needed=yes
1917 dnl ****************************************
1918 dnl *** GLib POLL* compatibility defines ***
1919 dnl ****************************************
1921 glib_poll_includes=["
1922 #include <sys/types.h>
1923 #include <sys/poll.h>
1926 if test $ac_cv_header_sys_types_h = yes &&
1927 test $ac_cv_header_sys_poll_h = yes ; then
1929 GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1930 GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1931 GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1932 GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1933 GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1934 GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1935 if $glib_failed ; then
1936 AC_MSG_ERROR([Could not determine values for POLL* constants])
1939 glib_cv_value_POLLIN=1
1940 glib_cv_value_POLLOUT=4
1941 glib_cv_value_POLLPRI=2
1942 glib_cv_value_POLLERR=8
1943 glib_cv_value_POLLHUP=16
1944 glib_cv_value_POLLNVAL=32
1947 dnl **********************
1948 dnl *** Win32 API libs ***
1949 dnl **********************
1953 G_LIBS_EXTRA="-luser32 -lkernel32"
1956 G_LIBS_EXTRA="-lwsock32"
1962 AC_SUBST(G_LIBS_EXTRA)
1964 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1965 dnl since we need it for g_iconv()
1967 AC_MSG_CHECKING([for EILSEQ])
1973 ], have_eilseq=yes, have_eilseq=no);
1974 AC_MSG_RESULT($have_eilseq)
1976 dnl ******************************************************************
1977 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1978 dnl ******************************************************************
1980 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1982 if test $cross_compiling = yes; then
1983 AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1984 if test x$GLIB_GENMARSHAL = xno; then
1985 AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1989 dnl **************************
1990 dnl *** Checks for gtk-doc ***
1991 dnl **************************
1993 GTK_DOC_CHECK([1.0])
1996 [AC_HELP_STRING([--enable-man],
1997 [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2000 if test "${enable_man}" != no; then
2002 dnl Check for xsltproc
2004 AC_PATH_PROG([XSLTPROC], [xsltproc])
2005 if test -z "$XSLTPROC"; then
2009 dnl check for DocBook DTD and stylesheets in the local catalog.
2010 JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2011 [DocBook XML DTD V4.1.2],,enable_man=no)
2012 JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2013 [DocBook XSL Stylesheets],,enable_man=no)
2016 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2018 dnl ******************************
2019 dnl *** output the whole stuff ***
2020 dnl ******************************
2022 dnl this section will only be run if config.status is invoked with no
2023 dnl arguments, or with "glibconfig.h" as an argument.
2024 AC_CONFIG_COMMANDS([glibconfig.h],
2026 outfile=glibconfig.h-tmp
2027 cat > $outfile <<\_______EOF
2030 * This is a generated file. Please modify 'configure.in'
2033 #ifndef __G_LIBCONFIG_H__
2034 #define __G_LIBCONFIG_H__
2036 #include <glib/gmacros.h>
2040 if test x$glib_limits_h = xyes; then
2041 echo '#include <limits.h>' >> $outfile
2043 if test x$glib_float_h = xyes; then
2044 echo '#include <float.h>' >> $outfile
2046 if test x$glib_values_h = xyes; then
2047 echo '#include <values.h>' >> $outfile
2049 if test "$glib_header_alloca_h" = "yes"; then
2050 echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2052 if test x$glib_sys_poll_h = xyes; then
2053 echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2056 cat >> $outfile <<_______EOF
2060 #define G_MINFLOAT $glib_mf
2061 #define G_MAXFLOAT $glib_Mf
2062 #define G_MINDOUBLE $glib_md
2063 #define G_MAXDOUBLE $glib_Md
2064 #define G_MINSHORT $glib_ms
2065 #define G_MAXSHORT $glib_Ms
2066 #define G_MAXUSHORT $glib_Mus
2067 #define G_MININT $glib_mi
2068 #define G_MAXINT $glib_Mi
2069 #define G_MAXUINT $glib_Mui
2070 #define G_MINLONG $glib_ml
2071 #define G_MAXLONG $glib_Ml
2072 #define G_MAXULONG $glib_Mul
2077 ### this should always be true in a modern C/C++ compiler
2078 cat >>$outfile <<_______EOF
2079 typedef signed char gint8;
2080 typedef unsigned char guint8;
2084 if test -n "$gint16"; then
2085 cat >>$outfile <<_______EOF
2086 typedef signed $gint16 gint16;
2087 typedef unsigned $gint16 guint16;
2088 #define G_GINT16_MODIFIER $gint16_modifier
2089 #define G_GINT16_FORMAT $gint16_format
2090 #define G_GUINT16_FORMAT $guint16_format
2095 if test -n "$gint32"; then
2096 cat >>$outfile <<_______EOF
2097 typedef signed $gint32 gint32;
2098 typedef unsigned $gint32 guint32;
2099 #define G_GINT32_MODIFIER $gint32_modifier
2100 #define G_GINT32_FORMAT $gint32_format
2101 #define G_GUINT32_FORMAT $guint32_format
2105 cat >>$outfile <<_______EOF
2106 #define G_HAVE_GINT64 1 /* deprecated, always true */
2108 ${glib_extension}typedef signed $gint64 gint64;
2109 ${glib_extension}typedef unsigned $gint64 guint64;
2111 #define G_GINT64_CONSTANT(val) $gint64_constant
2114 if test x$gint64_format != x ; then
2115 cat >>$outfile <<_______EOF
2116 #define G_GINT64_MODIFIER $gint64_modifier
2117 #define G_GINT64_FORMAT $gint64_format
2118 #define G_GUINT64_FORMAT $guint64_format
2121 cat >>$outfile <<_______EOF
2122 #undef G_GINT64_MODIFIER
2123 #undef G_GINT64_FORMAT
2124 #undef G_GUINT64_FORMAT
2128 cat >>$outfile <<_______EOF
2130 #define GLIB_SIZEOF_VOID_P $glib_void_p
2131 #define GLIB_SIZEOF_LONG $glib_long
2132 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2136 cat >>$outfile <<_______EOF
2137 typedef signed $glib_size_type_define gssize;
2138 typedef unsigned $glib_size_type_define gsize;
2139 #define G_GSIZE_MODIFIER $gsize_modifier
2140 #define G_GSSIZE_FORMAT $gssize_format
2141 #define G_GSIZE_FORMAT $gsize_format
2143 #define G_MAXSIZE G_MAXU$glib_msize_type
2146 if test -z "$glib_unknown_void_p"; then
2147 cat >>$outfile <<_______EOF
2149 #define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2150 #define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2152 #define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2153 #define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2156 echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2161 cat >>$outfile <<_______EOF
2170 #define G_HAVE_INLINE 1
2171 #else /* !__cplusplus */
2173 #endif /* !__cplusplus */
2177 if test x$g_have_iso_c_varargs = xyes ; then
2178 cat >>$outfile <<_______EOF
2180 # define G_HAVE_ISO_VARARGS 1
2184 if test x$g_have_iso_cxx_varargs = xyes ; then
2185 cat >>$outfile <<_______EOF
2187 # define G_HAVE_ISO_VARARGS 1
2191 if test x$g_have_gnuc_varargs = xyes ; then
2192 cat >>$outfile <<_______EOF
2194 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2195 * is passed ISO vararg support is turned off, and there is no work
2196 * around to turn it on, so we unconditionally turn it off.
2198 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2199 # undef G_HAVE_ISO_VARARGS
2202 #define G_HAVE_GNUC_VARARGS 1
2206 case x$g_stack_grows in
2207 xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2208 *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2213 if test x$g_have_eilseq = xno; then
2214 cat >>$outfile <<_______EOF
2216 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2217 * The correspondence between this and the corresponding definition
2218 * in libiconv is essential.
2220 # define EILSEQ ENOENT
2226 if test x$g_have_gnuc_visibility = xyes ; then
2227 cat >>$outfile <<_______EOF
2228 #define G_HAVE_GNUC_VISIBILITY 1
2229 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2232 cat >>$outfile <<_______EOF
2233 #define G_GNUC_INTERNAL
2239 if test x$g_mutex_has_default = xyes; then
2240 cat >>$outfile <<_______EOF
2241 $g_enable_threads_def G_THREADS_ENABLED
2242 #define G_THREADS_IMPL_$g_threads_impl_def
2243 typedef struct _GStaticMutex GStaticMutex;
2244 struct _GStaticMutex
2246 struct _GMutex *runtime_mutex;
2248 char pad[[$g_mutex_sizeof]];
2249 double dummy_double;
2250 void *dummy_pointer;
2254 #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2255 #define g_static_mutex_get_mutex(mutex) \\
2256 (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2257 g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2260 cat >>$outfile <<_______EOF
2261 $g_enable_threads_def G_THREADS_ENABLED
2262 #define G_THREADS_IMPL_$g_threads_impl_def
2263 typedef struct _GMutex* GStaticMutex;
2264 #define G_STATIC_MUTEX_INIT NULL
2265 #define g_static_mutex_get_mutex(mutex) \\
2266 (g_static_mutex_get_mutex_impl_shortcut (mutex))
2270 cat >>$outfile <<_______EOF
2271 /* This represents a system thread as used by the implementation. An
2272 * alien implementaion, as loaded by g_thread_init can only count on
2273 * "sizeof (gpointer)" bytes to store their info. We however need more
2274 * for some of our native implementations. */
2275 typedef union _GSystemThread GSystemThread;
2276 union _GSystemThread
2278 char data[[$g_system_thread_sizeof]];
2279 double dummy_double;
2280 void *dummy_pointer;
2284 if test x"$g_memory_barrier_needed" != xno; then
2286 echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2290 g_bit_sizes="16 32 64"
2291 for bits in $g_bit_sizes; do
2292 cat >>$outfile <<_______EOF
2293 #define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2294 #define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2295 #define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2296 #define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2300 cat >>$outfile <<_______EOF
2301 #define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2302 #define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2303 #define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2304 #define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2305 #define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2306 #define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2307 #define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2308 #define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2309 #define G_BYTE_ORDER $g_byte_order
2311 #define GLIB_SYSDEF_POLLIN =$g_pollin
2312 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2313 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2314 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2315 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2316 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2318 #define G_MODULE_SUFFIX "$g_module_suffix"
2320 typedef $g_pid_type GPid;
2324 #endif /* GLIBCONFIG_H */
2328 if cmp -s $outfile glibconfig.h; then
2329 AC_MSG_NOTICE([glibconfig.h is unchanged])
2332 mv $outfile glibconfig.h
2336 # Note that if two cases are the same, case goes with the first one.
2337 # Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2338 # on variable expansion in case labels. Look at the generated config.status
2341 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2342 glib_header_alloca_h="$ac_cv_working_alloca_h"
2344 glib_header_alloca_h="$ac_cv_header_alloca_h"
2348 x$ac_cv_header_float_h)
2350 glib_mf=FLT_MIN glib_Mf=FLT_MAX
2351 glib_md=DBL_MIN glib_Md=DBL_MAX
2353 x$ac_cv_header_values_h)
2355 glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2356 glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2361 x$ac_cv_header_limits_h)
2363 glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2364 glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2365 glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2367 x$ac_cv_header_values_h)
2369 glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2370 glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2371 glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2375 if test x$ac_cv_header_sys_poll_h = xyes ; then
2380 $ac_cv_sizeof_short)
2382 gint16_modifier='"h"'
2383 gint16_format='"hi"'
2384 guint16_format='"hu"'
2388 gint16_modifier='""'
2390 guint16_format='"u"'
2394 $ac_cv_sizeof_short)
2396 gint32_modifier='"h"'
2397 gint32_format='"hi"'
2398 guint32_format='"hu"'
2402 gint32_modifier='""'
2404 guint32_format='"u"'
2408 gint32_modifier='"l"'
2409 gint32_format='"li"'
2410 guint32_format='"lu"'
2416 gint64_modifier='""'
2418 guint64_format='"u"'
2420 gint64_constant='(val)'
2424 gint64_modifier='"l"'
2425 gint64_format='"li"'
2426 guint64_format='"lu"'
2428 gint64_constant='(val##L)'
2430 $ac_cv_sizeof_long_long)
2432 if test -n "$glib_cv_long_long_format"; then
2433 gint64_modifier='"'$glib_cv_long_long_format'"'
2434 gint64_format='"'$glib_cv_long_long_format'i"'
2435 guint64_format='"'$glib_cv_long_long_format'u"'
2437 glib_extension='G_GNUC_EXTENSION '
2438 gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2440 $ac_cv_sizeof___int64)
2442 if test -n "$glib_cv_long_long_format"; then
2443 gint64_modifier='"'$glib_cv_long_long_format'"'
2444 gint64_format='"'$glib_cv_long_long_format'i"'
2445 guint64_format='"'$glib_cv_long_long_format'u"'
2448 gint64_constant='(val##i64)'
2451 glib_size_t=$ac_cv_sizeof_size_t
2452 glib_size_type_define=$glib_size_type
2453 glib_void_p=$ac_cv_sizeof_long
2454 glib_long=$ac_cv_sizeof_void_p
2456 case $glib_size_type in
2458 gsize_modifier='"h"'
2460 gssize_format='"hi"'
2461 glib_msize_type='SHRT'
2467 glib_msize_type='INT'
2470 gsize_modifier='"l"'
2472 gssize_format='"li"'
2473 glib_msize_type='LONG'
2477 gintbits=`expr $ac_cv_sizeof_int \* 8`
2478 glongbits=`expr $ac_cv_sizeof_long \* 8`
2481 case $ac_cv_sizeof_void_p in
2482 $ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
2483 $ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2484 *) glib_unknown_void_p=yes ;;
2489 x$ac_cv_func_atexit)
2491 #ifdef NeXT /* @#%@! NeXTStep */
2492 # define g_ATEXIT(proc) (!atexit (proc))
2494 # define g_ATEXIT(proc) (atexit (proc))
2497 x$ac_cv_func_on_exit)
2499 #define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
2504 x$ac_cv_func_memmove)
2506 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2508 x$glib_cv_working_bcopy)
2510 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2511 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2515 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2516 * so we have to roll our own copy routine. */
2517 void g_memmove (void* dest, const void * src, unsigned long len);"
2522 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2523 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2524 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2528 x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
2529 x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
2533 if test x$glib_cv_va_val_copy = xno; then
2534 glib_vacopy="\$glib_vacopy
2535 #define G_VA_COPY_AS_ARRAY 1"
2538 if test x$glib_cv_hasinline = xyes; then
2539 glib_inline='#define G_HAVE_INLINE 1'
2541 if test x$glib_cv_has__inline = xyes; then
2542 glib_inline="\$glib_inline
2543 #define G_HAVE___INLINE 1"
2545 if test x$glib_cv_has__inline__ = xyes; then
2546 glib_inline="\$glib_inline
2547 #define G_HAVE___INLINE__ 1"
2550 g_have_gnuc_varargs=$g_have_gnuc_varargs
2551 g_have_iso_c_varargs=$g_have_iso_c_varargs
2552 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2554 g_have_gnuc_visibility=$g_have_gnuc_visibility
2557 x$ac_cv_c_bigendian)
2558 g_byte_order=G_BIG_ENDIAN
2563 g_byte_order=G_LITTLE_ENDIAN
2569 g_pollin=$glib_cv_value_POLLIN
2570 g_pollout=$glib_cv_value_POLLOUT
2571 g_pollpri=$glib_cv_value_POLLPRI
2572 g_pollhup=$glib_cv_value_POLLHUP
2573 g_pollerr=$glib_cv_value_POLLERR
2574 g_pollnval=$glib_cv_value_POLLNVAL
2576 g_stack_grows=$glib_cv_stack_grows
2578 g_have_eilseq=$have_eilseq
2580 case x$have_threads in
2581 xno) g_enable_threads_def="#undef";;
2582 *) g_enable_threads_def="#define";;
2585 g_threads_impl_def=$g_threads_impl
2587 g_mutex_has_default="$mutex_has_default"
2588 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2589 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2590 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2592 g_memory_barrier_needed="$glib_memory_barrier_needed"
2594 g_module_suffix="$glib_gmodule_suffix"
2596 g_pid_type="$glib_pid_type"
2599 glib_os="#define G_OS_BEOS"
2602 glib_os="#define G_OS_UNIX
2603 #define G_PLATFORM_WIN32
2604 #define G_WITH_CYGWIN"
2607 glib_os="#define G_OS_WIN32
2608 #define G_PLATFORM_WIN32"
2611 glib_os="#define G_OS_UNIX"
2618 glib-2.0-uninstalled.pc
2620 gmodule-2.0-uninstalled.pc
2622 gthread-2.0-uninstalled.pc
2624 gobject-2.0-uninstalled.pc
2629 build/win32/Makefile
2630 build/win32/dirent/Makefile
2632 glib/libcharset/Makefile
2633 glib/gnulib/Makefile
2635 gmodule/gmoduleconf.h
2637 gobject/glib-mkenums
2641 docs/reference/Makefile
2642 docs/reference/glib/Makefile
2643 docs/reference/glib/version.xml
2644 docs/reference/gobject/Makefile
2645 docs/reference/gobject/version.xml
2647 tests/gobject/Makefile
2651 AC_CONFIG_COMMANDS([chmod-scripts],
2652 [chmod 0755 glib-zip
2653 chmod 0755 glib-gettextize
2654 chmod 0755 gobject/glib-mkenums])
2656 # we want to invoke this macro solely so that the config.status script
2657 # and automake generated makefiles know about these generated files.
2658 # They are only needed to distcheck the package
2667 gmodule/makefile.msc
2669 gobject/makefile.msc
2671 gthread/makefile.msc