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], [6])
30 m4_define([glib_micro_version], [1])
31 m4_define([glib_interface_age], [1])
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=
157 AC_MSG_RESULT([$glib_native_win32])
158 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
159 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
160 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
161 AC_SUBST(G_LIB_WIN32_RESOURCE)
162 AC_SUBST(G_MODULE_WIN32_RESOURCE)
163 AC_SUBST(G_OBJECT_WIN32_RESOURCE)
164 AC_SUBST(G_THREAD_WIN32_RESOURCE)
166 AC_SUBST(GMODULE_DEF)
167 AC_SUBST(GOBJECT_DEF)
168 AC_SUBST(GTHREAD_DEF)
169 AC_SUBST(TESTGMODULE_EXP)
171 if test "$glib_native_win32" = "yes"; then
172 AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
174 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
176 if test "$glib_native_win32" != yes; then
177 # libtool option to control which symbols are exported
178 # right now, symbols starting with _ are not exported
179 LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^[[^_]].*"'
181 # We currently use .def files on Windows
182 LIBTOOL_EXPORT_OPTIONS=
184 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
186 dnl declare --enable-* args and collect ac_help strings
188 AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
189 [turn on debugging @<:@default=glib_debug_default@:>@]),,
190 enable_debug=glib_debug_default)
192 AC_ARG_ENABLE(gc_friendly,
193 [AC_HELP_STRING([--enable-gc-friendly],
194 [turn on garbage collector friendliness [default=no]])],,
195 [enable_gc_friendly=no])
196 AC_ARG_ENABLE(mem_pools,
197 [AC_HELP_STRING([--disable-mem-pools],
198 [disable all glib memory pools])],,
199 [disable_mem_pools=no])
201 [AC_HELP_STRING([--enable-ansi],
202 [turn on strict ansi [default=no]])],,
204 AC_ARG_ENABLE(threads,
205 [AC_HELP_STRING([--enable-threads],
206 [turn on basic thread support [default=yes]
207 ([=no] will override --with-threads)])],,
208 [enable_threads=yes])
209 AC_ARG_ENABLE(rebuilds,
210 [AC_HELP_STRING([--disable-rebuilds],
211 [disable all source autogeneration rules])],,
212 [enable_rebuilds=yes])
213 AC_ARG_ENABLE(visibility,
214 [AC_HELP_STRING([--disable-visibility],
215 [don't use ELF visibility attributes])],,
216 [enable_visibility=yes])
218 if test "x$enable_threads" != "xyes"; then
222 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, ["${enable_debug}"],
223 [Whether glib was compiled with debugging enabled])
225 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
226 if test "x$enable_gc_friendly" = "xyes"; then
227 AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
228 AC_SUBST(ENABLE_GC_FRIENDLY)
234 AC_MSG_CHECKING([whether to disable memory pools])
235 if test "x$disable_mem_pools" = "xno"; then
238 AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
239 AC_SUBST(DISABLE_MEM_POOLS)
243 if test "$glib_native_win32" = "yes"; then
244 if test x$enable_static = xyes -o x$enable_static = x; then
245 AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
248 if test x$enable_shared = xno; then
249 AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
254 dnl Checks for programs.
257 dnl Check for a working C++ compiler, but do not bail out, if none is found.
258 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
261 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
262 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
273 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
274 if test x$PKG_CONFIG = xno ; then
275 AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
278 if $PKG_CONFIG --atleast-pkgconfig-version 0.14 ; then
281 AC_MSG_ERROR([*** pkg-config too old; version 0.14 or better required.])
284 if test "x$enable_debug" = "xyes"; then
285 if test x$cflags_set != xset ; then
287 *[[\ \ ]]-g[[\ \ ]]*) ;;
288 *) CFLAGS="$CFLAGS -g" ;;
292 GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
294 GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
296 if test "x$enable_debug" = "xno"; then
297 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
301 if test "x$enable_visibility" = "xno"; then
302 GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
305 # Ensure MSVC-compatible struct packing convention is used when
306 # compiling for Win32 with gcc.
307 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
308 # gcc2 uses "-fnative-struct".
309 if test x"$glib_native_win32" = xyes; then
310 if test x"$GCC" = xyes; then
312 AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
313 if test -z "$ac_cv_prog_CC"; then
316 our_gcc="$ac_cv_prog_CC"
318 case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
320 if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
321 msnative_struct='-fnative-struct'
325 if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
326 msnative_struct='-mms-bitfields'
330 if test x"$msnative_struct" = x ; then
331 AC_MSG_RESULT([no way])
332 AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
334 CFLAGS="$CFLAGS $msnative_struct"
335 AC_MSG_RESULT([${msnative_struct}])
342 # define a MAINT-like variable REBUILD which is set if Perl
343 # and awk are found, so autogenerated sources can be rebuilt
345 AC_CHECK_PROGS(PERL, [perl5 perl])
346 # We would like indent, but don't require it.
347 AC_CHECK_PROG(INDENT, indent, indent)
349 if test "x$enable_rebuilds" = "xyes" && \
351 $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
352 test -n "$AWK" ; then
357 # Need full path to Perl for glib-mkenums
359 if test "x$PERL" != x ; then
360 AC_PATH_PROG(PERL_PATH, [$PERL])
362 PERL_PATH="/usr/bin/env perl"
366 dnl ***********************
367 dnl *** Tests for iconv ***
368 dnl ***********************
370 dnl We do this before the gettext checks, to avoid distortion
372 AC_ARG_WITH(libiconv,
373 [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
374 [use the libiconv library])],,
375 [with_libiconv=maybe])
378 case $with_libiconv in
380 # Check in the C library first
381 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
382 # Check if we have GNU libiconv
383 if test $found_iconv = "no"; then
384 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
386 # Check if we have a iconv in -liconv, possibly from vendor
387 if test $found_iconv = "no"; then
388 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
392 AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
395 AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
398 AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
402 if test "x$found_iconv" = "xno" ; then
403 AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
410 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 nb ne nl nn no or 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"
413 if test "$gt_cv_have_gettext" != "yes" ; then
415 *** You must have either have gettext support in your C library, or use the
416 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
420 LIBS="$INTLLIBS $LIBS"
422 GETTEXT_PACKAGE=glib20
423 AC_SUBST(GETTEXT_PACKAGE)
424 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
425 [Define the gettext package to be used])
427 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
430 dnl Now we are done with gettext checks, figure out ICONV_LIBS
433 if test x$with_libiconv != xno ; then
434 case " $INTLLIBS " in
435 *[[\ \ ]]-liconv[[\ \ ]]*) ;;
436 *) ICONV_LIBS="-liconv" ;;
441 case $with_libiconv in
443 AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
446 AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
450 dnl Initialize libtool
454 if test "x$GCC" = "xyes"; then
456 *[[\ \ ]]-Wall[[\ \ ]]*) ;;
457 *) CFLAGS="$CFLAGS -Wall" ;;
460 if test "x$enable_ansi" = "xyes"; then
462 *[[\ \ ]]-ansi[[\ \ ]]*) ;;
463 *) CFLAGS="$CFLAGS -ansi" ;;
467 *[[\ \ ]]-pedantic[[\ \ ]]*) ;;
468 *) CFLAGS="$CFLAGS -pedantic" ;;
474 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
476 if test $cross_compiling != yes ; then
477 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
480 AC_TRY_RUN([#include <math.h>
481 int main (void) { return (log(1) != log(1.)); }],
482 AC_MSG_RESULT(none needed),
483 glib_save_CFLAGS=$CFLAGS
484 CFLAGS="$CFLAGS -std1"
485 AC_TRY_RUN([#include <math.h>
486 int main (void) { return (log(1) != log(1.)); }],
487 AC_MSG_RESULT(-std1),
489 CFLAGS=$glib_save_CFLAGS
491 [No ANSI prototypes found in library. (-std1 didn't work.)])
497 dnl NeXTStep cc seems to need this
498 AC_MSG_CHECKING([for extra flags for POSIX compliance])
499 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
500 AC_MSG_RESULT(none needed),
501 glib_save_CFLAGS=$CFLAGS
502 CFLAGS="$CFLAGS -posix"
503 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
504 AC_MSG_RESULT(-posix),
506 CFLAGS=$glib_save_CFLAGS
507 AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
509 # Checks for header files.
512 # Checks for library functions.
517 AC_CHECK_FUNCS(atexit on_exit)
519 AC_CHECK_SIZEOF(char)
520 AC_CHECK_SIZEOF(short)
521 AC_CHECK_SIZEOF(long)
523 AC_CHECK_SIZEOF(void *)
524 AC_CHECK_SIZEOF(long long)
525 AC_CHECK_SIZEOF(__int64)
527 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
531 *** GLib requires a 64 bit type. You might want to consider
532 *** using the GNU C compiler.
536 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
537 # long long is a 64 bit integer.
538 AC_MSG_CHECKING(for format to printf and scanf a guint64)
539 AC_CACHE_VAL(glib_cv_long_long_format,[
540 for format in ll q I64; do
541 AC_TRY_RUN([#include <stdio.h>
544 long long b, a = -0x3AFAFAFAFAFAFAFALL;
546 sprintf (buffer, "%${format}u", a);
547 sscanf (buffer, "%${format}u", &b);
551 [glib_cv_long_long_format=${format}
555 if test -n "$glib_cv_long_long_format"; then
556 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
557 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
558 if test x"$glib_cv_long_long_format" = xI64; then
559 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
564 elif test x$ac_cv_sizeof___int64 = x8; then
565 # __int64 is a 64 bit integer.
566 AC_MSG_CHECKING(for format to printf and scanf a guint64)
567 # We know this is MSVCRT.DLL, and what the formats are
568 glib_cv_long_long_format=I64
569 AC_MSG_RESULT(%${glib_cv_long_long_format}u)
570 AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
571 AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
574 dnl long doubles were not used, and a portability problem
578 dnl ok, here we try to check whether the systems prototypes for
579 dnl malloc and friends actually match the prototypes provided
580 dnl by gmem.h (keep in sync). i currently only know how to check
581 dnl this reliably with gcc (-Werror), improvements for other
582 dnl compilers are apprechiated.
583 SANE_MALLOC_PROTOS=no
584 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
585 glib_save_CFLAGS=$CFLAGS
586 if test "x$GCC" = "xyes"; then
587 CFLAGS="$CFLAGS -Werror"
588 AC_TRY_COMPILE([#include <stdlib.h>], [
589 void* (*my_calloc_p) (size_t, size_t) = calloc;
590 void* (*my_malloc_p) (size_t) = malloc;
591 void (*my_free_p) (void*) = free;
592 void* (*my_realloc_p) (void*, size_t) = realloc;
598 AC_DEFINE(SANE_MALLOC_PROTOS, 1,
599 [Define if you have correct malloc prototypes])
600 SANE_MALLOC_PROTOS=yes)
602 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
603 CFLAGS=$glib_save_CFLAGS
606 dnl check in which direction the stack grows
608 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
610 volatile int *a = 0, *b = 0;
612 int main () { volatile int y = 7; a = &y; foo (); return b > a; }
613 void foo (void) { volatile int x = 5; b = &x; }
615 glib_cv_stack_grows=no
617 glib_cv_stack_grows=yes
621 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
622 dnl truely know which ones of `inline', `__inline' and `__inline__' are
623 dnl actually supported.
624 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
626 __inline int foo () { return 0; }
627 int main () { return foo (); }
629 glib_cv_has__inline=yes
631 glib_cv_has__inline=no
634 case x$glib_cv_has__inline in
635 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
637 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
639 __inline__ int foo () { return 0; }
640 int main () { return foo (); }
642 glib_cv_has__inline__=yes
644 glib_cv_has__inline__=no
647 case x$glib_cv_has__inline__ in
648 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
650 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
653 inline int foo () { return 0; }
654 int main () { return foo (); }
656 glib_cv_hasinline=yes
661 case x$glib_cv_hasinline in
662 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
665 # check for flavours of varargs macros
666 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
668 int a(int p1, int p2, int p3);
669 #define call_a(...) a(1,__VA_ARGS__)
671 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
672 AC_MSG_RESULT($g_have_iso_c_varargs)
674 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
675 if test "$CXX" = ""; then
677 g_have_iso_cxx_varargs=no
681 int a(int p1, int p2, int p3);
682 #define call_a(...) a(1,__VA_ARGS__)
684 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
687 AC_MSG_RESULT($g_have_iso_cxx_varargs)
689 AC_MSG_CHECKING(for GNUC varargs macros)
691 int a(int p1, int p2, int p3);
692 #define call_a(params...) a(1,params)
694 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
695 AC_MSG_RESULT($g_have_gnuc_varargs)
697 # check for GNUC visibility support
698 AC_MSG_CHECKING(for GNUC visibility attribute)
699 GLIB_CHECK_COMPILE_WARNINGS([
701 __attribute__ ((visibility ("hidden")))
706 __attribute__ ((visibility ("internal")))
711 __attribute__ ((visibility ("protected")))
716 __attribute__ ((visibility ("default")))
720 int main (int argc, char **argv)
728 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
729 AC_MSG_RESULT($g_have_gnuc_visibility)
731 # check for bytesex stuff
734 # check for header files
735 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h sys/types.h])
736 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
738 # Checks for libcharset
741 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
742 AC_CHECK_FUNCS(setlocale)
744 # check additional type sizes
745 AC_CHECK_SIZEOF(size_t)
747 dnl Try to figure out whether gsize, gssize should be long or int
748 AC_MSG_CHECKING([for the appropriate definition for size_t])
750 case $ac_cv_sizeof_size_t in
760 *) AC_MSG_ERROR([No type matching size_t in size])
764 dnl If int/long are the same size, we see which one produces
765 dnl warnings when used in the location as size_t. (This matters
768 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
769 test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
770 GLIB_CHECK_COMPILE_WARNINGS([
775 unsigned int *size_int = &s;
776 return (int)*size_int;
778 ],glib_size_type=int,
779 [GLIB_CHECK_COMPILE_WARNINGS([
784 unsigned long *size_long = &s;
785 return (int)*size_long;
787 ],glib_size_type=long)])
790 AC_MSG_RESULT(unsigned $glib_size_type)
792 # Check for some functions
793 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf setenv unsetenv getc_unlocked readlink symlink)
795 AC_FUNC_VSNPRINTF_C99
796 AC_FUNC_PRINTF_UNIX98
799 # Check whether to use an included printf
802 AC_ARG_ENABLE(included-printf,
803 [AC_HELP_STRING([--enable-included-printf],
804 [use included printf [default=auto]])],
805 enable_included_printf="$enableval")
807 need_included_printf=no
808 if test "x$enable_included_printf" = "xyes" ; then
809 need_included_printf=yes
811 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
812 need_included_printf=yes
814 if test "$ac_cv_func_printf_unix98" != "yes" ; then
815 need_included_printf=yes
817 if test "x$ac_cv_sizeof_long_long" = "x8" &&
818 test -z "$glib_cv_long_long_format" ; then
819 need_included_printf=yes
822 if test "x$enable_included_printf" = "xno" &&
823 test "x$need_included_printf" = "xyes" ; then
825 *** Your C library's printf doesn't appear to have the features that
826 *** GLib needs, but you specified --enable-included-printf=no.])
829 enable_included_printf=$need_included_printf
831 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
832 if test "$enable_included_printf" != "yes" ; then
833 AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
835 if test -z "$glib_cv_long_long_format" ; then
836 glib_cv_long_long_format="ll"
838 AC_DEFINE(HAVE_VASPRINTF,1)
841 # Checks needed for gnulib vasnprintf
848 AC_CHECK_TYPES(ptrdiff_t)
850 AC_CHECK_FUNCS(snprintf)
853 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
854 # The check is borrowed from the PERL Configure script.
855 if test "$ac_cv_func_memmove" != "yes"; then
856 AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
857 glib_cv_working_bcopy,[AC_TRY_RUN([
859 char buf[128], abc[128], *b;
861 bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
862 for (align = 7; align >= 0; align--) {
863 for (len = 36; len; len--) {
864 b = buf+align; bcopy(abc, b, len);
865 for (off = 1; off <= len; off++) {
866 bcopy(b, b+off, len); bcopy(b+off, b, len);
867 if (bcmp(b, abc, len)) return(1);
872 }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
874 GLIB_ASSERT_SET(glib_cv_working_bcopy)
875 if test "$glib_cv_working_bcopy" = "yes"; then
876 AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
880 # Check for sys_errlist
881 AC_MSG_CHECKING(for sys_errlist)
883 extern char *sys_errlist[];
885 sys_errlist[sys_nerr-1][0] = 0;
886 ], glib_ok=yes, glib_ok=no)
887 AC_MSG_RESULT($glib_ok)
888 if test "$glib_ok" = "no"; then
889 AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
892 # Check for sys_siglist
893 AC_MSG_CHECKING(for sys_siglist)
895 extern char *sys_siglist[];
896 exit (sys_siglist[0]);
897 ], glib_ok=yes, glib_ok=no)
898 AC_MSG_RESULT($glib_ok)
899 if test "$glib_ok" = "no"; then
900 AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
903 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
904 AC_MSG_CHECKING(for sys_siglist declaration)
905 AC_TRY_COMPILE([#include <signal.h>], [
906 strlen (sys_siglist[0]);
907 ], glib_ok=yes, glib_ok=no)
908 AC_MSG_RESULT($glib_ok)
909 if test "$glib_ok" = "no"; then
910 AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
913 # Check if <sys/select.h> needs to be included for fd_set
914 AC_MSG_CHECKING([for fd_set])
915 AC_TRY_COMPILE([#include <sys/types.h>],
916 [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
917 if test "$gtk_ok" = "yes"; then
918 AC_MSG_RESULT([yes, found in sys/types.h])
920 AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
921 if test "$gtk_ok" = "yes"; then
922 # *** FIXME: give it a different name
923 AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
924 AC_MSG_RESULT([yes, found in sys/select.h])
926 AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
931 dnl *** check for sane realloc() ***
932 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
933 AC_TRY_RUN([#include <stdlib.h>
935 return realloc (0, sizeof (int)) == 0;
937 [glib_cv_sane_realloc=yes],
938 [glib_cv_sane_realloc=no],
939 [glib_cv_sane_realloc=yes])
941 if test x$glib_cv_sane_realloc = xyes; then
942 AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
945 dnl Check for nl_langinfo and CODESET
947 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
948 AC_TRY_COMPILE([#include <langinfo.h>],
949 [char *codeset = nl_langinfo (CODESET);],
950 AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
953 AC_MSG_RESULT($have_codeset)
956 dnl ****************************************
957 dnl *** strlcpy/strlcat ***
958 dnl ****************************************
960 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
961 AC_TRY_RUN([#include <stdlib.h>
965 (void) strlcpy (p, "hi", 10);
966 if (strlcat (p, "bye", 0) != 3)
969 }], glib_cv_have_strlcpy=yes,
970 glib_cv_have_strlcpy=no,
971 glib_cv_have_strlcpy=no)])
972 if test "$glib_cv_have_strlcpy" = "yes"; then
973 AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
977 dnl **********************
978 dnl *** va_copy checks ***
979 dnl **********************
980 dnl we currently check for all three va_copy possibilities, so we get
981 dnl all results in config.log for bug reports.
982 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
983 AC_LINK_IFELSE([#include <stdarg.h>
984 void f (int i, ...) {
985 va_list args1, args2;
987 va_copy (args2, args1);
988 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
990 va_end (args1); va_end (args2);
996 [glib_cv_va_copy=yes],
997 [glib_cv_va_copy=no])
999 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1000 AC_LINK_IFELSE([#include <stdarg.h>
1001 void f (int i, ...) {
1002 va_list args1, args2;
1003 va_start (args1, i);
1004 __va_copy (args2, args1);
1005 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1007 va_end (args1); va_end (args2);
1013 [glib_cv___va_copy=yes],
1014 [glib_cv___va_copy=no])
1017 if test "x$glib_cv_va_copy" = "xyes"; then
1018 g_va_copy_func=va_copy
1019 else if test "x$glib_cv___va_copy" = "xyes"; then
1020 g_va_copy_func=__va_copy
1024 if test -n "$g_va_copy_func"; then
1025 AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1028 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1029 AC_TRY_RUN([#include <stdarg.h>
1030 void f (int i, ...) {
1031 va_list args1, args2;
1032 va_start (args1, i);
1034 if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1036 va_end (args1); va_end (args2);
1042 [glib_cv_va_val_copy=yes],
1043 [glib_cv_va_val_copy=no],
1044 [glib_cv_va_val_copy=yes])
1047 if test "x$glib_cv_va_val_copy" = "xno"; then
1048 AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1051 dnl ***********************
1052 dnl *** g_module checks ***
1053 dnl ***********************
1055 G_MODULE_LIBS_EXTRA=
1056 G_MODULE_PLUGIN_LIBS=
1057 if test x"$glib_native_win32" = xyes; then
1058 dnl No use for this on Win32
1061 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1063 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1064 G_MODULE_NEED_USCORE=0
1065 G_MODULE_BROKEN_RTLD_GLOBAL=0
1066 G_MODULE_HAVE_DLERROR=0
1067 dnl *** force native WIN32 shared lib loader
1068 if test -z "$G_MODULE_IMPL"; then
1070 *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1073 dnl *** force native AIX library loader
1074 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1075 if test -z "$G_MODULE_IMPL"; then
1077 *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1080 dnl *** dlopen() and dlsym() in system libraries
1081 if test -z "$G_MODULE_IMPL"; then
1082 AC_CHECK_FUNC(dlopen,
1083 [AC_CHECK_FUNC(dlsym,
1084 [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1087 dnl *** load_image (BeOS)
1088 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1089 AC_CHECK_LIB(root, load_image,
1090 [G_MODULE_LIBS="-lbe -lroot -lglib"
1091 G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1092 G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1093 G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1096 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1097 if test -z "$G_MODULE_IMPL"; then
1098 AC_CHECK_FUNC(NSLinkModule,
1099 [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1100 G_MODULE_NEED_USCORE=1],
1103 dnl *** dlopen() and dlsym() in libdl
1104 if test -z "$G_MODULE_IMPL"; then
1105 AC_CHECK_LIB(dl, dlopen,
1106 [AC_CHECK_LIB(dl, dlsym,
1108 G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1111 dnl *** shl_load() in libdld (HP-UX)
1112 if test -z "$G_MODULE_IMPL"; then
1113 AC_CHECK_LIB(dld, shl_load,
1114 [G_MODULE_LIBS=-ldld
1115 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1118 dnl *** additional checks for G_MODULE_IMPL_DL
1119 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1121 LDFLAGS_orig="$LDFLAGS"
1122 LIBS="$G_MODULE_LIBS $LIBS"
1123 LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1124 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1125 echo "void glib_plugin_test(void) { }" > plugin.c
1126 ${SHELL} ./libtool --mode=compile ${CC} -shared \
1127 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1128 AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1129 glib_cv_rtldglobal_broken,[
1133 # define RTLD_GLOBAL 0
1136 # define RTLD_LAZY 0
1138 int glib_plugin_test;
1140 void *handle, *global, *local;
1141 global = &glib_plugin_test;
1142 handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1143 if (!handle) return 0;
1144 local = dlsym (handle, "glib_plugin_test");
1145 return global == local;
1147 [glib_cv_rtldglobal_broken=no],
1148 [glib_cv_rtldglobal_broken=yes],
1149 [glib_cv_rtldglobal_broken=no])
1150 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1151 rmdir .libs 2>/dev/null
1153 if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1154 G_MODULE_BROKEN_RTLD_GLOBAL=1
1156 G_MODULE_BROKEN_RTLD_GLOBAL=0
1158 dnl *** check whether we need preceeding underscores
1159 AC_CACHE_CHECK([for preceeding underscore in symbols],
1161 AC_TRY_RUN([#include <dlfcn.h>
1162 int glib_underscore_test (void) { return 42; }
1164 void *f1 = (void*)0, *f2 = (void*)0, *handle;
1165 handle = dlopen ((void*)0, 0);
1167 f1 = dlsym (handle, "glib_underscore_test");
1168 f2 = dlsym (handle, "_glib_underscore_test");
1169 } return (!f2 || f1);
1171 [glib_cv_uscore=yes],
1172 [glib_cv_uscore=no],
1174 rm -f plugin.c plugin.$ac_objext plugin.lo
1176 GLIB_ASSERT_SET(glib_cv_uscore)
1177 if test "x$glib_cv_uscore" = "xyes"; then
1178 G_MODULE_NEED_USCORE=1
1180 G_MODULE_NEED_USCORE=0
1183 LDFLAGS="$LDFLAGS_orig"
1184 dnl *** check for having dlerror()
1185 AC_CHECK_FUNC(dlerror,
1186 [G_MODULE_HAVE_DLERROR=1],
1187 [G_MODULE_HAVE_DLERROR=0])
1190 dnl *** done, have we got an implementation?
1191 if test -z "$G_MODULE_IMPL"; then
1193 G_MODULE_SUPPORTED=false
1195 G_MODULE_SUPPORTED=true
1198 AC_MSG_CHECKING(for the suffix of shared libraries)
1200 hpux9* | hpux10* | hpux11*) # taken from ltconfig
1201 glib_gmodule_suffix='sl'
1204 glib_gmodule_suffix='dll'
1207 glib_gmodule_suffix='a'
1210 glib_gmodule_suffix='so'
1213 AC_MSG_RESULT(.$glib_gmodule_suffix)
1215 AC_SUBST(G_MODULE_SUPPORTED)
1216 AC_SUBST(G_MODULE_IMPL)
1217 AC_SUBST(G_MODULE_LIBS)
1218 AC_SUBST(G_MODULE_LIBS_EXTRA)
1219 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1220 AC_SUBST(G_MODULE_LDFLAGS)
1221 AC_SUBST(G_MODULE_HAVE_DLERROR)
1222 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1223 AC_SUBST(G_MODULE_NEED_USCORE)
1224 AC_SUBST(GLIB_DEBUG_FLAGS)
1226 dnl **********************
1227 dnl *** g_spawn checks ***
1228 dnl **********************
1230 AC_MSG_CHECKING(for gspawn implementation)
1233 GSPAWN=gspawn-win32.lo
1239 AC_MSG_RESULT($GSPAWN)
1242 dnl *************************
1243 dnl *** GIOChannel checks ***
1244 dnl *************************
1246 AC_MSG_CHECKING(for GIOChannel implementation)
1258 dnl ****************************************
1259 dnl *** platform dependent source checks ***
1260 dnl ****************************************
1262 AC_MSG_CHECKING(for platform-dependent source)
1264 *-*-cygwin*|*-*-mingw*)
1265 PLATFORMDEP=gwin32.lo
1271 AC_MSG_RESULT($PLATFORMDEP)
1272 AC_SUBST(PLATFORMDEP)
1274 AC_MSG_CHECKING([whether to compile timeloop])
1276 *-*-cygwin*|*-*-mingw*)
1283 AC_MSG_RESULT($enable_timeloop)
1284 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1286 AC_MSG_CHECKING([if building for some Win32 platform])
1288 *-*-mingw*|*-*-cygwin*)
1295 AC_MSG_RESULT($platform_win32)
1296 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1298 dnl ***********************
1299 dnl *** g_thread checks ***
1300 dnl ***********************
1302 AC_ARG_WITH(threads,
1303 [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
1304 [specify a thread implementation to use])],
1305 [if test "x$with_threads" = x; then
1308 want_threads=$with_threads
1311 if test "x$enable_threads" = "xno"; then
1315 dnl error and warning message
1316 dnl *************************
1318 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1319 computer. GLib will not have a default thread implementation."
1321 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1322 platform (normally it's "_REENTRANT"). I'll not use any flag on
1323 compilation now, but then your programs might not work.
1324 Please provide information on how it is done on your system."
1326 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1329 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1330 provide information on your thread implementation.
1331 You can also run 'configure --disable-threads'
1332 to compile without thread support."
1334 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1335 functions will not be MT-safe during their first call because
1336 there is no working 'getpwuid_r' on your system."
1338 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1339 because there is no 'localtime_r' on your system."
1341 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1342 crude surrogate will be used. If you happen to know a
1343 yield function for your system, please inform the GLib
1346 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1347 threads on your system. Thus threads can only have the default
1348 priority. If you happen to know these main/max
1349 priorities, please inform the GLib developers."
1351 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1352 linking threaded applications. As GLib cannot do that
1353 automatically, you will get an linkg error everytime you are
1354 not using the right compiler. In that case you have to relink
1355 with the right compiler. Ususally just '_r' is appended
1356 to the compiler name."
1358 dnl determination of thread implementation
1359 dnl ***************************************
1361 # have_threads=no means no thread support
1362 # have_threads=none means no default thread implementation
1365 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1368 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1372 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1373 || test "x$want_threads" = xdce; then
1374 # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1375 # -U_OSF_SOURCE is for Digital UNIX 4.0d
1376 GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1377 glib_save_CPPFLAGS="$CPPFLAGS"
1378 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1379 if test "x$have_threads" = xno; then
1380 AC_TRY_COMPILE([#include <pthread.h>],
1381 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1384 if test "x$have_threads" = xno; then
1385 AC_TRY_COMPILE([#include <pthread.h>],
1387 pthread_mutex_init (&m, pthread_mutexattr_default);],
1390 # Tru64Unix requires -pthread to find pthread.h. See #103020
1391 CPPFLAGS="$CPPFLAGS -pthread"
1392 if test "x$have_threads" = xno; then
1393 AC_TRY_COMPILE([#include <pthread.h>],
1394 [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1397 CPPFLAGS="$glib_save_CPPFLAGS"
1399 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1406 if test "x$want_threads" = xnone; then
1410 AC_MSG_CHECKING(for thread implementation)
1412 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1413 AC_MSG_RESULT(none available)
1414 AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1416 AC_MSG_RESULT($have_threads)
1420 dnl determination of G_THREAD_CFLAGS
1421 dnl ********************************
1424 G_THREAD_LIBS_EXTRA=
1428 dnl Test program for basic POSIX threads functionality
1430 m4_define([glib_thread_test],[
1431 #include <pthread.h>
1433 void* func(void* data) {check_me = 42; return &check_me;}
1437 pthread_create (&t, $1, func, 0);
1438 pthread_join (t, &ret);
1439 exit (check_me != 42 || ret != &check_me);
1443 dnl Test program for sched_get_priority_min()
1445 m4_define([glib_sched_priority_test],[
1450 return sched_get_priority_min(SCHED_OTHER)==-1
1454 if test x"$have_threads" != xno; then
1456 if test x"$have_threads" = xposix; then
1457 # First we test for posix, whether -pthread or -pthreads do the trick as
1458 # both CPPFLAG and LIBS.
1459 # One of them does for most gcc versions and some other platforms/compilers
1460 # too and could be considered as the canonical way to go.
1463 # skip cygwin -pthread or -pthreads test
1466 for flag in pthread pthreads; do
1467 glib_save_CFLAGS="$CFLAGS"
1468 CFLAGS="$CFLAGS -$flag"
1469 AC_TRY_RUN(glib_thread_test(0),
1470 glib_flag_works=yes,
1472 [AC_LINK_IFELSE(glib_thread_test(0),
1473 glib_flag_works=yes,
1474 glib_flag_works=no)])
1475 CFLAGS="$glib_save_CFLAGS"
1476 if test $glib_flag_works = yes ; then
1477 G_THREAD_CFLAGS=-$flag
1478 G_THREAD_LIBS=-$flag
1485 if test x"$G_THREAD_CFLAGS" = x; then
1487 # The canonical -pthread[s] does not work. Try something different.
1491 if test x"$GCC" = xyes; then
1492 # GCC 3.0 and above needs -pthread.
1493 # Should be coverd by the case above.
1494 # GCC 2.x and below needs -mthreads
1495 G_THREAD_CFLAGS="-mthreads"
1496 G_THREAD_LIBS=$G_THREAD_CFLAGS
1498 # We are probably using the aix compiler. Normaly a
1499 # program would have to be compiled with the _r variant
1500 # of the corresponding compiler, but we as GLib cannot
1501 # do that: but the good news is that for compiling the
1502 # only difference is the added -D_THREAD_SAFE compile
1503 # option. This is according to the "C for AIX User's
1505 G_THREAD_CFLAGS="-D_THREAD_SAFE"
1509 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1512 # So we are using dce threads. posix threads are already
1514 G_THREAD_CFLAGS="-threads"
1515 G_THREAD_LIBS=$G_THREAD_CFLAGS
1518 if test x"$GCC" = xyes; then
1519 # We are using solaris threads. posix threads are
1520 # already catched above.
1521 G_THREAD_CFLAGS="-threads"
1523 G_THREAD_CFLAGS="-mt"
1525 G_THREAD_LIBS=$G_THREAD_CFLAGS
1527 *-sysv5uw7*) # UnixWare 7
1528 # We are not using gcc with -pthread. Catched above.
1529 G_THREAD_CFLAGS="-Kthread"
1530 G_THREAD_LIBS=$G_THREAD_CFLAGS
1533 # No flag needed when using MSVCRT.DLL
1537 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1543 # if we are not finding the localtime_r function, then we probably are
1544 # not using the proper multithread flag
1546 glib_save_CPPFLAGS="$CPPFLAGS"
1547 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1549 # First we test, whether localtime_r is declared in time.h
1550 # directly. Then we test whether a macro localtime_r exists, in
1551 # which case localtime_r in the test program is replaced and thus
1552 # if we still find localtime_r in the output, it is not defined as
1555 AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1556 [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1558 AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1560 CPPFLAGS="$glib_save_CPPFLAGS"
1562 AC_MSG_CHECKING(thread related cflags)
1563 AC_MSG_RESULT($G_THREAD_CFLAGS)
1564 CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1567 dnl determination of G_THREAD_LIBS
1568 dnl ******************************
1570 mutex_has_default=no
1571 case $have_threads in
1573 glib_save_CPPFLAGS="$CPPFLAGS"
1574 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1575 if test x"$G_THREAD_LIBS" = x; then
1578 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1579 # probably using the aix compiler.
1580 AC_MSG_WARN($AIX_COMPILE_INFO)
1584 glib_save_LIBS="$LIBS"
1585 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1586 if test x"$thread_lib" = x; then
1590 add_thread_lib="-l$thread_lib"
1591 IN=" in -l$thread_lib"
1593 if test x"$have_threads" = xposix; then
1596 defattr=pthread_attr_default
1599 LIBS="$add_thread_lib $glib_save_LIBS"
1601 AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1602 AC_TRY_RUN(glib_thread_test($defattr),
1605 [AC_LINK_IFELSE(glib_thread_test($defattr),
1608 AC_MSG_RESULT($glib_result)
1610 if test "$glib_result" = "yes" ; then
1611 G_THREAD_LIBS="$add_thread_lib"
1615 if test "x$G_THREAD_LIBS" = xerror; then
1616 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1618 LIBS="$glib_save_LIBS"
1623 glib_save_LIBS="$LIBS"
1624 for thread_lib in "" rt rte; do
1625 if test x"$thread_lib" = x; then
1629 add_thread_lib="-l$thread_lib"
1630 IN=" in -l$thread_lib"
1632 LIBS="$add_thread_lib $glib_save_LIBS"
1634 AC_MSG_CHECKING(for sched_get_priority_min$IN)
1635 AC_TRY_RUN(glib_sched_priority_test,
1638 [AC_LINK_IFELSE(glib_sched_priority_test,
1641 AC_MSG_RESULT($glib_result)
1643 if test "$glib_result" = "yes" ; then
1644 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1645 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1646 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1650 LIBS="$glib_save_LIBS"
1651 mutex_has_default=yes
1652 mutex_default_type='pthread_mutex_t'
1653 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1654 mutex_header_file='pthread.h'
1655 if test "x$have_threads" = "xposix"; then
1656 g_threads_impl="POSIX"
1658 g_threads_impl="DCE"
1659 have_threads="posix"
1661 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1662 CPPFLAGS="$glib_save_CPPFLAGS"
1665 mutex_has_default=yes
1666 mutex_default_type='mutex_t'
1667 mutex_default_init="DEFAULTMUTEX"
1668 mutex_header_file='thread.h'
1669 g_threads_impl="SOLARIS"
1672 g_threads_impl="WIN32"
1675 g_threads_impl="NONE"
1678 g_threads_impl="NONE"
1683 if test "x$G_THREAD_LIBS" = xerror; then
1684 AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1689 G_THREAD_LIBS="-lbe -lroot -lglib "
1690 G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1696 AC_MSG_CHECKING(thread related libraries)
1697 AC_MSG_RESULT($G_THREAD_LIBS)
1699 dnl check for mt safe function variants and some posix functions
1700 dnl ************************************************************
1702 if test x"$have_threads" != xno; then
1703 glib_save_LIBS="$LIBS"
1704 # we are not doing the following for now, as this might require glib
1705 # to always be linked with the thread libs on some platforms.
1706 # LIBS="$LIBS $G_THREAD_LIBS"
1707 AC_CHECK_FUNCS(localtime_r)
1708 if test "$ac_cv_header_pwd_h" = "yes"; then
1709 AC_CACHE_CHECK([for posix getpwuid_r],
1710 ac_cv_func_posix_getpwuid_r,
1716 struct passwd pwd, *pwptr = &pwd;
1719 error = getpwuid_r (0, &pwd, buffer,
1720 sizeof (buffer), &pwptr);
1721 return (error < 0 && errno == ENOSYS)
1724 [ac_cv_func_posix_getpwuid_r=yes],
1725 [ac_cv_func_posix_getpwuid_r=no])])
1726 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1727 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1728 AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1729 [Have POSIX function getpwuid_r])
1731 AC_CACHE_CHECK([for nonposix getpwuid_r],
1732 ac_cv_func_nonposix_getpwuid_r,
1733 [AC_TRY_LINK([#include <pwd.h>],
1734 [char buffer[10000];
1736 getpwuid_r (0, &pwd, buffer,
1738 [ac_cv_func_nonposix_getpwuid_r=yes],
1739 [ac_cv_func_nonposix_getpwuid_r=no])])
1740 GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1741 if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1742 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1743 [Have non-POSIX function getpwuid_r])
1747 LIBS="$G_THREAD_LIBS $LIBS"
1748 if test x"$have_threads" = xposix; then
1749 glib_save_CPPFLAGS="$CPPFLAGS"
1750 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1751 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1752 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1753 # This is not AC_CHECK_FUNC to also work with function
1754 # name mangling in header files.
1755 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1756 AC_TRY_LINK([#include <pthread.h>],
1757 [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1759 AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1760 [Have function pthread_attr_setstacksize])],
1761 [AC_MSG_RESULT(no)])
1762 AC_MSG_CHECKING(for minimal/maximal thread priority)
1763 if test x"$posix_priority_min" = x; then
1764 AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1766 posix_priority_min=PX_PRIO_MIN
1767 posix_priority_max=PX_PRIO_MAX])
1769 if test x"$posix_priority_min" = x; then
1771 AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1772 PTHREAD_PRIO_MIN],,[
1773 posix_priority_min=PTHREAD_PRIO_MIN
1774 posix_priority_max=PTHREAD_PRIO_MAX])
1776 if test x"$posix_priority_min" = x; then
1777 AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1779 posix_priority_min=PRI_OTHER_MIN
1780 posix_priority_max=PRI_OTHER_MAX])
1782 if test x"$posix_priority_min" = x; then
1783 AC_MSG_RESULT(none found)
1784 AC_MSG_WARN($POSIX_NO_PRIORITIES)
1785 posix_priority_min=-1
1786 posix_priority_max=-1
1788 AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1789 AC_MSG_CHECKING(for pthread_setschedparam)
1790 AC_TRY_LINK([#include <pthread.h>],
1791 [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1793 AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1794 AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1796 AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1798 posix_yield_func=none
1799 AC_MSG_CHECKING(for posix yield function)
1800 for yield_func in sched_yield pthread_yield_np pthread_yield \
1802 AC_TRY_LINK([#include <pthread.h>],
1804 [posix_yield_func="$yield_func"
1807 if test x"$posix_yield_func" = xnone; then
1808 AC_MSG_RESULT(none found)
1809 AC_MSG_WARN($POSIX_NO_YIELD)
1810 posix_yield_func="g_usleep(1000)"
1812 AC_MSG_RESULT($posix_yield_func)
1813 posix_yield_func="$posix_yield_func()"
1815 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1816 CPPFLAGS="$glib_save_CPPFLAGS"
1818 elif test x"$have_threads" = xwin32; then
1819 # It's a pointer to a private struct
1820 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1821 elif test x"$have_threads" = xsolaris; then
1822 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1825 LIBS="$glib_save_LIBS"
1827 # now spit out all the warnings.
1828 if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1829 test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1830 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1832 if test "$ac_cv_func_localtime_r" != "yes"; then
1833 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1837 if test x"$glib_cv_sizeof_system_thread" = x; then
1838 # use a pointer as a fallback.
1839 GLIB_SIZEOF(,void *, system_thread)
1843 # Hack to deal with:
1845 # a) GCC < 3.3 for Linux doesn't include -lpthread when
1846 # building shared libraries with linux.
1850 G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1854 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1855 [Source file containing theread implementation])
1856 AC_SUBST(G_THREAD_CFLAGS)
1857 AC_SUBST(G_THREAD_LIBS)
1858 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1859 AC_SUBST(G_THREAD_LIBS_EXTRA)
1861 dnl **********************************************
1862 dnl *** GDefaultMutex setup and initialization ***
1863 dnl **********************************************
1865 dnl if mutex_has_default = yes, we also got
1866 dnl mutex_default_type, mutex_default_init and mutex_header_file
1867 if test $mutex_has_default = yes ; then
1868 glib_save_CPPFLAGS="$CPPFLAGS"
1869 glib_save_LIBS="$LIBS"
1870 LIBS="$G_THREAD_LIBS $LIBS"
1871 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1872 GLIB_SIZEOF([#include <$mutex_header_file>],
1873 $mutex_default_type,
1875 GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1876 $mutex_default_type,
1878 $glib_cv_sizeof_gmutex,
1879 $mutex_default_init)
1880 if test x"$glib_cv_byte_contents_gmutex" = xno; then
1881 mutex_has_default=no
1883 CPPFLAGS="$glib_save_CPPFLAGS"
1884 LIBS="$glib_save_LIBS"
1887 dnl ********************************
1888 dnl *** g_atomic_* tests for gcc ***
1889 dnl ********************************
1891 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1893 if test x"$GCC" = xyes; then
1896 AC_MSG_RESULT([none])
1897 glib_memory_barrier_needed=no
1900 AC_MSG_RESULT([i486])
1901 AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1902 [i486 atomic implementation])
1903 glib_memory_barrier_needed=no
1906 SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1907 when you are using a sparc with v9 instruction set (most
1908 sparcs nowadays). This will make the code for atomic
1909 operations much faster. The resulting code will not run
1910 on very old sparcs though."
1915 int tmp1, tmp2, tmp3;
1916 __asm__ __volatile__("casx [%2], %0, %1"
1917 : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1919 AC_MSG_RESULT([sparcv9])
1920 AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1921 [sparcv9 atomic implementation]),
1923 AC_MSG_WARN([[$SPARCV9_WARNING]]))
1924 glib_memory_barrier_needed=yes
1927 AC_MSG_RESULT([alpha])
1928 AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1929 [alpha atomic implementation])
1930 glib_memory_barrier_needed=yes
1933 AC_MSG_RESULT([x86_64])
1934 AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1935 [x86_64 atomic implementation])
1936 glib_memory_barrier_needed=no
1939 AC_MSG_RESULT([powerpc])
1940 AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1941 [powerpc atomic implementation])
1942 glib_memory_barrier_needed=yes
1945 AC_MSG_RESULT([ia64])
1946 AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1947 [ia64 atomic implementation])
1948 glib_memory_barrier_needed=yes
1951 AC_MSG_RESULT([none])
1952 glib_memory_barrier_needed=yes
1957 dnl ****************************************
1958 dnl *** GLib POLL* compatibility defines ***
1959 dnl ****************************************
1961 glib_poll_includes=["
1962 #include <sys/types.h>
1963 #include <sys/poll.h>
1966 if test $ac_cv_header_sys_types_h = yes &&
1967 test $ac_cv_header_sys_poll_h = yes ; then
1969 GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1970 GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1971 GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1972 GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1973 GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1974 GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1975 if $glib_failed ; then
1976 AC_MSG_ERROR([Could not determine values for POLL* constants])
1979 glib_cv_value_POLLIN=1
1980 glib_cv_value_POLLOUT=4
1981 glib_cv_value_POLLPRI=2
1982 glib_cv_value_POLLERR=8
1983 glib_cv_value_POLLHUP=16
1984 glib_cv_value_POLLNVAL=32
1987 dnl **********************
1988 dnl *** Win32 API libs ***
1989 dnl **********************
1993 G_LIBS_EXTRA="-luser32 -lkernel32"
1996 G_LIBS_EXTRA="-lwsock32 -lole32"
2002 AC_SUBST(G_LIBS_EXTRA)
2004 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2005 dnl since we need it for g_iconv()
2007 AC_MSG_CHECKING([for EILSEQ])
2013 ], have_eilseq=yes, have_eilseq=no);
2014 AC_MSG_RESULT($have_eilseq)
2016 dnl ******************************************************************
2017 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2018 dnl ******************************************************************
2020 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2022 if test $cross_compiling = yes; then
2023 AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2024 if test x$GLIB_GENMARSHAL = xno; then
2025 AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2029 dnl **************************
2030 dnl *** Checks for gtk-doc ***
2031 dnl **************************
2033 GTK_DOC_CHECK([1.0])
2036 [AC_HELP_STRING([--enable-man],
2037 [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2040 if test "${enable_man}" != no; then
2042 dnl Check for xsltproc
2044 AC_PATH_PROG([XSLTPROC], [xsltproc])
2045 if test -z "$XSLTPROC"; then
2049 dnl check for DocBook DTD and stylesheets in the local catalog.
2050 JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2051 [DocBook XML DTD V4.1.2],,enable_man=no)
2052 JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2053 [DocBook XSL Stylesheets],,enable_man=no)
2056 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2058 dnl ******************************
2059 dnl *** output the whole stuff ***
2060 dnl ******************************
2062 dnl this section will only be run if config.status is invoked with no
2063 dnl arguments, or with "glibconfig.h" as an argument.
2064 AC_CONFIG_COMMANDS([glibconfig.h],
2066 outfile=glibconfig.h-tmp
2067 cat > $outfile <<\_______EOF
2070 * This is a generated file. Please modify 'configure.in'
2073 #ifndef __G_LIBCONFIG_H__
2074 #define __G_LIBCONFIG_H__
2076 #include <glib/gmacros.h>
2080 if test x$glib_limits_h = xyes; then
2081 echo '#include <limits.h>' >> $outfile
2083 if test x$glib_float_h = xyes; then
2084 echo '#include <float.h>' >> $outfile
2086 if test x$glib_values_h = xyes; then
2087 echo '#include <values.h>' >> $outfile
2089 if test "$glib_header_alloca_h" = "yes"; then
2090 echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2092 if test x$glib_sys_poll_h = xyes; then
2093 echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2096 cat >> $outfile <<_______EOF
2100 #define G_MINFLOAT $glib_mf
2101 #define G_MAXFLOAT $glib_Mf
2102 #define G_MINDOUBLE $glib_md
2103 #define G_MAXDOUBLE $glib_Md
2104 #define G_MINSHORT $glib_ms
2105 #define G_MAXSHORT $glib_Ms
2106 #define G_MAXUSHORT $glib_Mus
2107 #define G_MININT $glib_mi
2108 #define G_MAXINT $glib_Mi
2109 #define G_MAXUINT $glib_Mui
2110 #define G_MINLONG $glib_ml
2111 #define G_MAXLONG $glib_Ml
2112 #define G_MAXULONG $glib_Mul
2117 ### this should always be true in a modern C/C++ compiler
2118 cat >>$outfile <<_______EOF
2119 typedef signed char gint8;
2120 typedef unsigned char guint8;
2124 if test -n "$gint16"; then
2125 cat >>$outfile <<_______EOF
2126 typedef signed $gint16 gint16;
2127 typedef unsigned $gint16 guint16;
2128 #define G_GINT16_MODIFIER $gint16_modifier
2129 #define G_GINT16_FORMAT $gint16_format
2130 #define G_GUINT16_FORMAT $guint16_format
2135 if test -n "$gint32"; then
2136 cat >>$outfile <<_______EOF
2137 typedef signed $gint32 gint32;
2138 typedef unsigned $gint32 guint32;
2139 #define G_GINT32_MODIFIER $gint32_modifier
2140 #define G_GINT32_FORMAT $gint32_format
2141 #define G_GUINT32_FORMAT $guint32_format
2145 cat >>$outfile <<_______EOF
2146 #define G_HAVE_GINT64 1 /* deprecated, always true */
2148 ${glib_extension}typedef signed $gint64 gint64;
2149 ${glib_extension}typedef unsigned $gint64 guint64;
2151 #define G_GINT64_CONSTANT(val) $gint64_constant
2154 if test x$gint64_format != x ; then
2155 cat >>$outfile <<_______EOF
2156 #define G_GINT64_MODIFIER $gint64_modifier
2157 #define G_GINT64_FORMAT $gint64_format
2158 #define G_GUINT64_FORMAT $guint64_format
2161 cat >>$outfile <<_______EOF
2162 #undef G_GINT64_MODIFIER
2163 #undef G_GINT64_FORMAT
2164 #undef G_GUINT64_FORMAT
2168 cat >>$outfile <<_______EOF
2170 #define GLIB_SIZEOF_VOID_P $glib_void_p
2171 #define GLIB_SIZEOF_LONG $glib_long
2172 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2176 cat >>$outfile <<_______EOF
2177 typedef signed $glib_size_type_define gssize;
2178 typedef unsigned $glib_size_type_define gsize;
2179 #define G_GSIZE_MODIFIER $gsize_modifier
2180 #define G_GSSIZE_FORMAT $gssize_format
2181 #define G_GSIZE_FORMAT $gsize_format
2183 #define G_MAXSIZE G_MAXU$glib_msize_type
2186 if test -z "$glib_unknown_void_p"; then
2187 cat >>$outfile <<_______EOF
2189 #define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
2190 #define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
2192 #define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
2193 #define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
2196 echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2201 cat >>$outfile <<_______EOF
2210 #define G_HAVE_INLINE 1
2211 #else /* !__cplusplus */
2213 #endif /* !__cplusplus */
2217 if test x$g_have_iso_c_varargs = xyes ; then
2218 cat >>$outfile <<_______EOF
2220 # define G_HAVE_ISO_VARARGS 1
2224 if test x$g_have_iso_cxx_varargs = xyes ; then
2225 cat >>$outfile <<_______EOF
2227 # define G_HAVE_ISO_VARARGS 1
2231 if test x$g_have_gnuc_varargs = xyes ; then
2232 cat >>$outfile <<_______EOF
2234 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2235 * is passed ISO vararg support is turned off, and there is no work
2236 * around to turn it on, so we unconditionally turn it off.
2238 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2239 # undef G_HAVE_ISO_VARARGS
2242 #define G_HAVE_GNUC_VARARGS 1
2246 case x$g_stack_grows in
2247 xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2248 *) echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2253 if test x$g_have_eilseq = xno; then
2254 cat >>$outfile <<_______EOF
2256 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2257 * The correspondence between this and the corresponding definition
2258 * in libiconv is essential.
2260 # define EILSEQ ENOENT
2266 if test x$g_have_gnuc_visibility = xyes ; then
2267 cat >>$outfile <<_______EOF
2268 #define G_HAVE_GNUC_VISIBILITY 1
2269 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2272 cat >>$outfile <<_______EOF
2273 #define G_GNUC_INTERNAL
2279 if test x$g_mutex_has_default = xyes; then
2280 cat >>$outfile <<_______EOF
2281 $g_enable_threads_def G_THREADS_ENABLED
2282 #define G_THREADS_IMPL_$g_threads_impl_def
2283 typedef struct _GStaticMutex GStaticMutex;
2284 struct _GStaticMutex
2286 struct _GMutex *runtime_mutex;
2288 char pad[[$g_mutex_sizeof]];
2289 double dummy_double;
2290 void *dummy_pointer;
2294 #define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
2295 #define g_static_mutex_get_mutex(mutex) \\
2296 (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2297 g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2300 cat >>$outfile <<_______EOF
2301 $g_enable_threads_def G_THREADS_ENABLED
2302 #define G_THREADS_IMPL_$g_threads_impl_def
2303 typedef struct _GMutex* GStaticMutex;
2304 #define G_STATIC_MUTEX_INIT NULL
2305 #define g_static_mutex_get_mutex(mutex) \\
2306 (g_static_mutex_get_mutex_impl_shortcut (mutex))
2310 cat >>$outfile <<_______EOF
2311 /* This represents a system thread as used by the implementation. An
2312 * alien implementaion, as loaded by g_thread_init can only count on
2313 * "sizeof (gpointer)" bytes to store their info. We however need more
2314 * for some of our native implementations. */
2315 typedef union _GSystemThread GSystemThread;
2316 union _GSystemThread
2318 char data[[$g_system_thread_sizeof]];
2319 double dummy_double;
2320 void *dummy_pointer;
2324 if test x"$g_memory_barrier_needed" != xno; then
2326 echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2330 g_bit_sizes="16 32 64"
2331 for bits in $g_bit_sizes; do
2332 cat >>$outfile <<_______EOF
2333 #define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
2334 #define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
2335 #define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2336 #define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
2340 cat >>$outfile <<_______EOF
2341 #define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
2342 #define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
2343 #define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
2344 #define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
2345 #define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
2346 #define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
2347 #define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
2348 #define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
2349 #define G_BYTE_ORDER $g_byte_order
2351 #define GLIB_SYSDEF_POLLIN =$g_pollin
2352 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2353 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2354 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2355 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2356 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2358 #define G_MODULE_SUFFIX "$g_module_suffix"
2360 typedef $g_pid_type GPid;
2364 #endif /* GLIBCONFIG_H */
2368 if cmp -s $outfile glibconfig.h; then
2369 AC_MSG_NOTICE([glibconfig.h is unchanged])
2372 mv $outfile glibconfig.h
2376 # Note that if two cases are the same, case goes with the first one.
2377 # Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
2378 # on variable expansion in case labels. Look at the generated config.status
2381 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2382 glib_header_alloca_h="$ac_cv_working_alloca_h"
2384 glib_header_alloca_h="$ac_cv_header_alloca_h"
2388 x$ac_cv_header_float_h)
2390 glib_mf=FLT_MIN glib_Mf=FLT_MAX
2391 glib_md=DBL_MIN glib_Md=DBL_MAX
2393 x$ac_cv_header_values_h)
2395 glib_mf=MINFLOAT glib_Mf=MAXFLOAT
2396 glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2401 x$ac_cv_header_limits_h)
2403 glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2404 glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
2405 glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2407 x$ac_cv_header_values_h)
2409 glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2410 glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
2411 glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2415 if test x$ac_cv_header_sys_poll_h = xyes ; then
2420 $ac_cv_sizeof_short)
2422 gint16_modifier='"h"'
2423 gint16_format='"hi"'
2424 guint16_format='"hu"'
2428 gint16_modifier='""'
2430 guint16_format='"u"'
2434 $ac_cv_sizeof_short)
2436 gint32_modifier='"h"'
2437 gint32_format='"hi"'
2438 guint32_format='"hu"'
2442 gint32_modifier='""'
2444 guint32_format='"u"'
2448 gint32_modifier='"l"'
2449 gint32_format='"li"'
2450 guint32_format='"lu"'
2456 gint64_modifier='""'
2458 guint64_format='"u"'
2460 gint64_constant='(val)'
2464 gint64_modifier='"l"'
2465 gint64_format='"li"'
2466 guint64_format='"lu"'
2468 gint64_constant='(val##L)'
2470 $ac_cv_sizeof_long_long)
2472 if test -n "$glib_cv_long_long_format"; then
2473 gint64_modifier='"'$glib_cv_long_long_format'"'
2474 gint64_format='"'$glib_cv_long_long_format'i"'
2475 guint64_format='"'$glib_cv_long_long_format'u"'
2477 glib_extension='G_GNUC_EXTENSION '
2478 gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2480 $ac_cv_sizeof___int64)
2482 if test -n "$glib_cv_long_long_format"; then
2483 gint64_modifier='"'$glib_cv_long_long_format'"'
2484 gint64_format='"'$glib_cv_long_long_format'i"'
2485 guint64_format='"'$glib_cv_long_long_format'u"'
2488 gint64_constant='(val##i64)'
2491 glib_size_t=$ac_cv_sizeof_size_t
2492 glib_size_type_define=$glib_size_type
2493 glib_void_p=$ac_cv_sizeof_long
2494 glib_long=$ac_cv_sizeof_void_p
2496 case $glib_size_type in
2498 gsize_modifier='"h"'
2500 gssize_format='"hi"'
2501 glib_msize_type='SHRT'
2507 glib_msize_type='INT'
2510 gsize_modifier='"l"'
2512 gssize_format='"li"'
2513 glib_msize_type='LONG'
2517 gintbits=`expr $ac_cv_sizeof_int \* 8`
2518 glongbits=`expr $ac_cv_sizeof_long \* 8`
2521 case $ac_cv_sizeof_void_p in
2522 $ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
2523 $ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2524 *) glib_unknown_void_p=yes ;;
2529 x$ac_cv_func_atexit)
2531 #ifdef NeXT /* @#%@! NeXTStep */
2532 # define g_ATEXIT(proc) (!atexit (proc))
2534 # define g_ATEXIT(proc) (atexit (proc))
2537 x$ac_cv_func_on_exit)
2539 #define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
2544 x$ac_cv_func_memmove)
2546 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2548 x$glib_cv_working_bcopy)
2550 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2551 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2555 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2556 * so we have to roll our own copy routine. */
2557 void g_memmove (void* dest, const void * src, unsigned long len);"
2562 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2563 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2564 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2568 x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
2569 x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
2573 if test x$glib_cv_va_val_copy = xno; then
2574 glib_vacopy="\$glib_vacopy
2575 #define G_VA_COPY_AS_ARRAY 1"
2578 if test x$glib_cv_hasinline = xyes; then
2579 glib_inline='#define G_HAVE_INLINE 1'
2581 if test x$glib_cv_has__inline = xyes; then
2582 glib_inline="\$glib_inline
2583 #define G_HAVE___INLINE 1"
2585 if test x$glib_cv_has__inline__ = xyes; then
2586 glib_inline="\$glib_inline
2587 #define G_HAVE___INLINE__ 1"
2590 g_have_gnuc_varargs=$g_have_gnuc_varargs
2591 g_have_iso_c_varargs=$g_have_iso_c_varargs
2592 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2594 g_have_gnuc_visibility=$g_have_gnuc_visibility
2597 x$ac_cv_c_bigendian)
2598 g_byte_order=G_BIG_ENDIAN
2603 g_byte_order=G_LITTLE_ENDIAN
2609 g_pollin=$glib_cv_value_POLLIN
2610 g_pollout=$glib_cv_value_POLLOUT
2611 g_pollpri=$glib_cv_value_POLLPRI
2612 g_pollhup=$glib_cv_value_POLLHUP
2613 g_pollerr=$glib_cv_value_POLLERR
2614 g_pollnval=$glib_cv_value_POLLNVAL
2616 g_stack_grows=$glib_cv_stack_grows
2618 g_have_eilseq=$have_eilseq
2620 case x$have_threads in
2621 xno) g_enable_threads_def="#undef";;
2622 *) g_enable_threads_def="#define";;
2625 g_threads_impl_def=$g_threads_impl
2627 g_mutex_has_default="$mutex_has_default"
2628 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2629 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2630 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2632 g_memory_barrier_needed="$glib_memory_barrier_needed"
2634 g_module_suffix="$glib_gmodule_suffix"
2636 g_pid_type="$glib_pid_type"
2639 glib_os="#define G_OS_BEOS"
2642 glib_os="#define G_OS_UNIX
2643 #define G_PLATFORM_WIN32
2644 #define G_WITH_CYGWIN"
2647 glib_os="#define G_OS_WIN32
2648 #define G_PLATFORM_WIN32"
2651 glib_os="#define G_OS_UNIX"
2658 glib-2.0-uninstalled.pc
2660 gmodule-no-export-2.0.pc
2661 gmodule-2.0-uninstalled.pc
2663 gthread-2.0-uninstalled.pc
2665 gobject-2.0-uninstalled.pc
2670 build/win32/Makefile
2671 build/win32/dirent/Makefile
2673 glib/libcharset/Makefile
2674 glib/gnulib/Makefile
2676 gmodule/gmoduleconf.h
2678 gobject/glib-mkenums
2682 docs/reference/Makefile
2683 docs/reference/glib/Makefile
2684 docs/reference/glib/version.xml
2685 docs/reference/gobject/Makefile
2686 docs/reference/gobject/version.xml
2688 tests/gobject/Makefile
2692 AC_CONFIG_COMMANDS([chmod-scripts],
2693 [chmod 0755 glib-zip
2694 chmod 0755 glib-gettextize
2695 chmod 0755 gobject/glib-mkenums])
2697 # we want to invoke this macro solely so that the config.status script
2698 # and automake generated makefiles know about these generated files.
2699 # They are only needed to distcheck the package
2708 gmodule/makefile.msc
2710 gobject/makefile.msc
2712 gthread/makefile.msc