configure.ac

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