configure.in

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