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