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   *-*-openbsd*)
2280     LDFLAGS="$LDFLAGS -pthread"
2281     ;;
2282   *)
2283     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2284     ;;
2285 esac
2286
2287 AC_SUBST(G_THREAD_CFLAGS)
2288 AC_SUBST(G_THREAD_LIBS)
2289 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2290 AC_SUBST(G_THREAD_LIBS_EXTRA)
2291
2292 AC_CHECK_FUNCS(clock_gettime, [], [
2293   AC_CHECK_LIB(rt, clock_gettime, [
2294     G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2295     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2296   ])
2297 ])
2298
2299
2300 dnl ************************
2301 dnl *** g_atomic_* tests ***
2302 dnl ************************
2303
2304 dnl We need to decide at configure time if GLib will use real atomic
2305 dnl operations ("lock free") or emulated ones with a mutex.  This is
2306 dnl because we must put this information in glibconfig.h so we know if
2307 dnl it is safe or not to inline using compiler intrinsics directly from
2308 dnl the header.
2309 dnl
2310 dnl We also publish the information via G_ATOMIC_LOCK_FREE in case the
2311 dnl user is interested in knowing if they can use the atomic ops across
2312 dnl processes.
2313 dnl
2314 dnl We can currently support the atomic ops natively when building GLib
2315 dnl with recent versions of GCC or MSVC.  MSVC doesn't run ./configure,
2316 dnl so we skip that case here and define G_ATOMIC_LOCK_FREE exactly when
2317 dnl we are using GCC (and not mingw*).
2318 dnl
2319 dnl Note that the atomic ops are only available with GCC on x86 when
2320 dnl using -march=i486 or higher.  If we detect that the atomic ops are
2321 dnl not available but would be available given the right flags, we want
2322 dnl to abort and advise the user to fix their CFLAGS.  It's better to do
2323 dnl that then to silently fall back on emulated atomic ops just because
2324 dnl the user had the wrong build environment.
2325
2326 dnl We may add other compilers here in the future...
2327
2328 AC_CACHE_CHECK([for lock-free atomic intrinsics], glib_cv_g_atomic_lock_free, [
2329   case $host in
2330     *-*-mingw*)
2331       glib_cv_g_atomic_lock_free=yes
2332       ;;
2333     *)
2334       AC_TRY_LINK([],
2335                      [volatile int atomic = 2;\
2336                       __sync_bool_compare_and_swap (&atomic, 2, 3);],
2337                      [glib_cv_g_atomic_lock_free=yes],
2338                      [glib_cv_g_atomic_lock_free=no])
2339       if test "$glib_cv_g_atomic_lock_free" = "no"; then
2340         SAVE_CFLAGS="${CFLAGS}"
2341         CFLAGS="-march=i486"
2342         AC_TRY_LINK([],
2343                        [volatile int atomic = 2;\
2344                         __sync_bool_compare_and_swap (&atomic, 2, 3);],
2345                        [AC_MSG_ERROR([GLib must be build with -march=i486 or later.])],
2346                        [])
2347         CFLAGS="${SAVE_CFLAGS}"
2348       fi
2349       ;;
2350   esac])
2351
2352
2353 case $host in
2354   *-*-mingw*)
2355     ;;
2356   *)
2357     # Some compilers support atomic operations but do not define
2358     # __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4, like clang
2359     if test x"$glib_cv_g_atomic_lock_free" = xyes; then
2360       AC_TRY_LINK([],
2361                      [__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4;],
2362                      [],
2363                      [AC_DEFINE(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4, 1, [ compiler supports atomic operations])])
2364     fi
2365     ;;
2366  esac
2367
2368 dnl We need a more robust approach here...
2369 case $host_cpu in
2370   i?86|x86_64|s390|s390x|arm*|crisv32*|etrax*)
2371     glib_memory_barrier_needed=no
2372     ;;
2373   sparc*|alpha*|powerpc*|ia64)
2374     glib_memory_barrier_needed=yes
2375     ;;
2376   *)
2377     glib_memory_barrier_needed=yes
2378     ;;
2379 esac
2380
2381 dnl ************************
2382 dnl ** Check for futex(2) **
2383 dnl ************************
2384 AC_CACHE_CHECK(for futex(2) system call,
2385     glib_cv_futex,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
2386 #include <linux/futex.h>
2387 #include <sys/syscall.h>
2388 #include <unistd.h>
2389 ],[
2390 int
2391 main (void)
2392 {
2393   /* it is not like this actually runs or anything... */
2394   syscall (__NR_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
2395   return 0;
2396 }
2397 ])],glib_cv_futex=yes,glib_cv_futex=no))
2398 if test x"$glib_cv_futex" = xyes; then
2399   AC_DEFINE(HAVE_FUTEX, 1, [we have the futex(2) system call])
2400 fi
2401
2402 AC_CACHE_CHECK(for eventfd(2) system call,
2403     glib_cv_eventfd,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
2404 #include <sys/eventfd.h>
2405 #include <unistd.h>
2406 ],[
2407 int
2408 main (void)
2409 {
2410   eventfd (0, EFD_CLOEXEC);
2411   return 0;
2412 }
2413 ])],glib_cv_eventfd=yes,glib_cv_eventfd=no))
2414 if test x"$glib_cv_eventfd" = x"yes"; then
2415   AC_DEFINE(HAVE_EVENTFD, 1, [we have the eventfd(2) system call])
2416 fi
2417 AM_CONDITIONAL(HAVE_EVENTFD, [test "$glib_cv_eventfd" = "yes"])
2418
2419 dnl ****************************************
2420 dnl *** GLib POLL* compatibility defines ***
2421 dnl ****************************************
2422
2423 glib_poll_includes=["
2424 #include <sys/types.h>
2425 #include <poll.h>
2426 "]
2427
2428 AS_IF([ test $ac_cv_header_sys_types_h = yes &&
2429    test $ac_cv_func_poll = yes ], [
2430   glib_failed=false
2431   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2432   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2433   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2434   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2435   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2436   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2437   if $glib_failed ; then
2438     AC_MSG_ERROR([Could not determine values for POLL* constants])
2439   fi
2440 ], [
2441   glib_cv_value_POLLIN=1
2442   glib_cv_value_POLLOUT=4
2443   glib_cv_value_POLLPRI=2
2444   glib_cv_value_POLLERR=8
2445   glib_cv_value_POLLHUP=16
2446   glib_cv_value_POLLNVAL=32
2447 ])
2448
2449 AC_MSG_CHECKING([for broken poll])
2450 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2451         #include <stdlib.h>
2452         #include <fcntl.h>
2453         #include <poll.h>
2454         int main(void) {
2455           struct pollfd fds[1];
2456           int fd;
2457           fd = open("/dev/null", 1);
2458           fds[0].fd = fd;
2459           fds[0].events = POLLIN;
2460           fds[0].revents = 0;
2461           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2462                 exit(1);  /* Does not work for devices -- fail */
2463           }
2464           exit(0);
2465         }]])],
2466   [broken_poll=no],
2467   [broken_poll=yes
2468    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2469   [broken_poll="no (cross compiling)"])
2470 AC_MSG_RESULT($broken_poll)
2471
2472 dnl *********************
2473 dnl *** GRegex checks ***
2474 dnl *********************
2475
2476 PCRE_REQUIRED_VERSION=8.13
2477
2478 # Check if we should use the internal or the system-supplied pcre
2479 AC_ARG_WITH(pcre,
2480             [AS_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2481                             [whether to use system PCRE [default=internal]])])
2482
2483 AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2484
2485 AS_IF([ test "x$with_pcre" = xsystem], [
2486   PKG_CHECK_MODULES(PCRE,
2487                     libpcre >= $PCRE_REQUIRED_VERSION)
2488   AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2489                   glib_save_CFLAGS="$CFLAGS"
2490                   glib_save_LIBS="$LIBS"
2491                   CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2492                   AC_TRY_RUN([#include <pcre.h>
2493                               int main () {
2494                                 int support;
2495                                 pcre_config (PCRE_CONFIG_UTF8, &support);
2496                                 if (!support)
2497                                   return 1;
2498                                 pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2499                                 if (!support)
2500                                   return 1;
2501                                 return 0;
2502                               }],
2503                   glib_cv_pcre_has_unicode=yes,
2504                   glib_cv_pcre_has_unicode=no,
2505                   glib_cv_pcre_has_unicode=yes)
2506                   CFLAGS="$glib_save_CFLAGS"
2507                   LIBS="$glib_save_LIBS"
2508       ])
2509   if test "$glib_cv_pcre_has_unicode" = "no"; then
2510     AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2511   fi
2512   AC_SUBST(PCRE_CFLAGS)
2513   AC_SUBST(PCRE_LIBS)
2514   AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2515   PCRE_REQUIRES=libpcre
2516   AC_SUBST(PCRE_REQUIRES)
2517 ], [
2518   # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2519   AS_IF([ test x"$GCC" = xyes], [
2520     AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2521     save_CFLAGS="$CFLAGS"
2522     CFLAGS="$CFLAGS -Wno-pointer-sign"
2523     AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2524                           AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2525     CFLAGS="$save_CFLAGS"
2526   ])
2527 ])
2528 AC_SUBST(PCRE_WARN_CFLAGS)
2529
2530 dnl **********************
2531 dnl *** Win32 API libs ***
2532 dnl **********************
2533
2534 case $host in
2535   *-*-cygwin*)
2536         G_LIBS_EXTRA="-luser32 -lkernel32"
2537     ;;
2538   *-*-mingw*)
2539         G_LIBS_EXTRA="-lws2_32 -lole32 -lwinmm -lshlwapi"
2540     ;;
2541   *)
2542         G_LIBS_EXTRA=""
2543     ;;
2544 esac
2545 AC_SUBST(G_LIBS_EXTRA)
2546
2547 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2548 dnl since we need it for g_iconv()
2549
2550 AC_MSG_CHECKING([for EILSEQ])
2551 AC_TRY_COMPILE([
2552 #include <errno.h>
2553 ],
2554 [
2555 int error = EILSEQ;
2556 ], have_eilseq=yes, have_eilseq=no);
2557 AC_MSG_RESULT($have_eilseq)
2558
2559 dnl ******************************************************************
2560 dnl *** If we are cross-compiling, look for glib-genmarshal and    ***
2561 dnl *** glib-compile-schemas in PATH                               ***
2562 dnl ******************************************************************
2563
2564 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2565
2566 AS_IF([ test $cross_compiling = yes ], [
2567   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2568   if test x$GLIB_GENMARSHAL = xno; then
2569     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2570   fi
2571
2572   AC_PATH_PROG(GLIB_COMPILE_SCHEMAS, glib-compile-schemas, no)
2573   if test x$GLIB_COMPILE_SCHEMAS = xno; then
2574     AC_MSG_ERROR(Could not find a glib-compile-schemas in your PATH)
2575   fi
2576
2577   AC_PATH_PROG(GLIB_COMPILE_RESOURCES, glib-compile-resources, no)
2578   if test x$GLIB_COMPILE_RESOURCES = xno; then
2579     AC_MSG_ERROR(Could not find a glib-compile-resources in your PATH)
2580   fi
2581 ])
2582
2583 dnl **************************
2584 dnl *** Checks for gtk-doc ***
2585 dnl **************************
2586 # gtkdocize greps for ^GTK_DOC_CHECK and parses it, so you need to have
2587 # it on it's own line.
2588 m4_ifdef([GTK_DOC_CHECK], [
2589 GTK_DOC_CHECK([1.20], [--flavour no-tmpl])
2590 ],[
2591 AM_CONDITIONAL([ENABLE_GTK_DOC],[false])
2592 ])
2593
2594 AC_ARG_ENABLE(man,
2595               [AS_HELP_STRING([--enable-man],
2596                               [generate man pages [default=auto]])],,
2597               enable_man=maybe)
2598
2599 AS_IF([test "$enable_man" != no], [
2600   AC_PATH_PROG([XSLTPROC], [xsltproc])
2601   AS_IF([test -z "$XSLTPROC"], [
2602     AS_IF([test "$enable_man" = yes], [
2603       AC_MSG_ERROR([xsltproc is required for --enable-man])
2604     ])
2605     enable_man=no
2606   ])
2607 ])
2608
2609 AS_IF([ test "$enable_man" != no ], [
2610   dnl check for DocBook DTD in the local catalog
2611   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2612      [DocBook XML DTD V4.1.2], [have_docbook_dtd=yes], [have_docbook_dtd=no])
2613   AS_IF([test "$have_docbook_dtd" != yes], [
2614     AS_IF([test "$enable_man" = yes ], [
2615       AC_MSG_ERROR([DocBook DTD is required for --enable-man])
2616     ])
2617     enable_man=no
2618   ])
2619 ])
2620
2621 AS_IF([test "$enable_man" != no], [
2622   dnl check for DocBook XSL stylesheets in the local catalog
2623   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2624      [DocBook XSL Stylesheets], [have_docbook_style=yes],[have_docbook_style=no])
2625   AS_IF([ test "$have_docbook_dtd" != yes ], [
2626     AS_IF([ test "$enable_man" = yes ], [
2627       AC_MSG_ERROR([DocBook XSL Stylesheets are required for --enable-man])
2628     ])
2629     enable_man=no
2630   ])
2631 ])
2632
2633 AM_CONDITIONAL(ENABLE_MAN, test "$enable_man" != no)
2634
2635 AC_MSG_CHECKING([whether to generate man pages])
2636 AS_IF([ test "$enable_man" != no ], [
2637   AC_MSG_RESULT([yes])
2638 ], [
2639   AC_MSG_RESULT([no])
2640 ])
2641
2642 dnl
2643 dnl Tracing
2644 dnl
2645
2646 AC_ARG_ENABLE([dtrace],
2647              [AS_HELP_STRING([--enable-dtrace],
2648                               [include tracing support for dtrace])])
2649 have_dtrace=no
2650 AC_MSG_CHECKING([whether to include dtrace tracing support])
2651 AS_IF([ test "x$enable_dtrace" != xno], [
2652   if test x$glib_have_carbon = xyes; then
2653     AC_MSG_RESULT([no (not yet compatible with MacOS dtrace)])
2654   else
2655     AC_MSG_RESULT([yes])
2656     AC_CHECK_PROGS(DTRACE, dtrace)
2657     if test -z "$DTRACE"; then
2658       if test "x$enable_dtrace" = xyes; then
2659         AC_MSG_ERROR([dtrace not found])
2660       fi
2661     else
2662       AC_CHECK_HEADER([sys/sdt.h],have_dtrace=yes,
2663                       [if test "x$enable_dtrace" = xyes; then
2664                         AC_MSG_ERROR([dtrace support needs sys/sdt.h header])
2665                        fi])
2666     fi
2667   fi
2668 ], [
2669   AC_MSG_RESULT([no])
2670 ])
2671 if test "x$have_dtrace" = xyes; then
2672   AC_DEFINE([HAVE_DTRACE], [1], [Define to 1 if using dtrace probes.])
2673 fi
2674 AM_CONDITIONAL([ENABLE_DTRACE], [test x$have_dtrace = xyes ])
2675
2676 AC_MSG_CHECKING([whether to include systemtap tracing support])
2677 AC_ARG_ENABLE([systemtap],
2678              [AS_HELP_STRING([--enable-systemtap],
2679                               [include tracing support for systemtap])])
2680 have_systemtap=no
2681 if test "x$enable_systemtap" != xno -a "x$have_dtrace" = xyes; then
2682   have_systemtap=yes
2683 fi
2684 AC_MSG_RESULT(${have_systemtap})
2685
2686 AM_CONDITIONAL([ENABLE_SYSTEMTAP], [test x$have_systemtap = xyes])
2687
2688 AC_ARG_WITH([tapset-install-dir],
2689             AS_HELP_STRING([--with-tapset-install-dir=DIR],
2690                             [path where systemtap tapsets are installed [DATADIR/systemtap/tapset]]),
2691             [if test "x${withval}" = x; then
2692                ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"
2693              else
2694                ABS_TAPSET_DIR="${withval}"
2695               fi],
2696             [ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"])
2697 AC_SUBST(ABS_TAPSET_DIR)
2698
2699 dnl ************************************
2700 dnl *** Enable lcov coverage reports ***
2701 dnl ************************************
2702
2703 AC_ARG_ENABLE(coverage,
2704   AS_HELP_STRING([--enable-coverage],
2705                  [enable coverage testing with gcov]),
2706   [use_gcov=$enableval], [use_gcov=no])
2707
2708 AS_IF([ test "x$use_gcov" = "xyes"], [
2709   dnl we need gcc:
2710   if test "$GCC" != "yes"; then
2711     AC_MSG_ERROR([GCC is required for --enable-coverage])
2712   fi
2713
2714   dnl Check if ccache is being used
2715   AC_CHECK_PROG(SHTOOL, shtool, shtool)
2716   case `$SHTOOL path $CC` in
2717     *ccache*[)] gcc_ccache=yes;;
2718     *[)] gcc_ccache=no;;
2719   esac
2720
2721   if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
2722     AC_MSG_ERROR([ccache must be disabled when --enable-coverage option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
2723   fi
2724
2725   ltp_version_list="1.6 1.7 1.8 1.9 1.10"
2726   AC_CHECK_PROG(LTP, lcov, lcov)
2727   AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
2728
2729   AS_IF([ test "$LTP" ], [
2730     AC_CACHE_CHECK([for ltp version], glib_cv_ltp_version, [
2731       glib_cv_ltp_version=invalid
2732       ltp_version=`$LTP -v 2>/dev/null | $SED -e 's/^.* //'`
2733       for ltp_check_version in $ltp_version_list; do
2734         if test "$ltp_version" = "$ltp_check_version"; then
2735           glib_cv_ltp_version="$ltp_check_version (ok)"
2736         fi
2737       done
2738     ])
2739   ], [
2740     ltp_msg="To enable code coverage reporting you must have one of the following LTP versions installed: $ltp_version_list"
2741     AC_MSG_ERROR([$ltp_msg])
2742   ])
2743
2744   case $glib_cv_ltp_version in
2745     ""|invalid[)]
2746       ltp_msg="You must have one of the following versions of LTP: $ltp_version_list (found: $ltp_version)."
2747       AC_MSG_ERROR([$ltp_msg])
2748       LTP="exit 0;"
2749       ;;
2750   esac
2751
2752   if test -z "$LTP_GENHTML"; then
2753     AC_MSG_ERROR([Could not find genhtml from the LTP package])
2754   fi
2755
2756   dnl Remove all optimization flags from CFLAGS
2757   changequote({,})
2758   CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
2759   changequote([,])
2760
2761   dnl Add the special gcc flags
2762   CFLAGS="$CFLAGS -O0 -fprofile-arcs -ftest-coverage"
2763   LDFLAGS="$LDFLAGS -lgcov"
2764 ])
2765
2766 dnl ******************************
2767 dnl *** output the whole stuff ***
2768 dnl ******************************
2769
2770 dnl this section will only be run if config.status is invoked with no
2771 dnl arguments, or with "glib/glibconfig.h" as an argument.
2772 AC_CONFIG_COMMANDS([glib/glibconfig.h],
2773 [
2774         outfile=glib/glibconfig.h-tmp
2775         cat > $outfile <<\_______EOF
2776 /* glibconfig.h
2777  *
2778  * This is a generated file.  Please modify 'configure.ac'
2779  */
2780
2781 #ifndef __GLIBCONFIG_H__
2782 #define __GLIBCONFIG_H__
2783
2784 #include <glib/gmacros.h>
2785
2786 _______EOF
2787
2788         echo '#include <limits.h>' >> $outfile
2789         echo '#include <float.h>' >> $outfile
2790         if test x$glib_values_h = xyes; then
2791           echo '#include <values.h>' >> $outfile
2792         fi
2793         if test "$glib_header_alloca_h" = "yes"; then
2794           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2795         fi
2796         if test x$glib_included_printf != xyes; then
2797           echo "
2798 /* Specifies that GLib's g_print*() functions wrap the
2799  * system printf functions.  This is useful to know, for example,
2800  * when using glibc's register_printf_function().
2801  */" >> $outfile
2802           echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2803         fi
2804
2805         cat >> $outfile <<_______EOF
2806
2807 G_BEGIN_DECLS
2808
2809 #define G_MINFLOAT      FLT_MIN
2810 #define G_MAXFLOAT      FLT_MAX
2811 #define G_MINDOUBLE     DBL_MIN
2812 #define G_MAXDOUBLE     DBL_MAX
2813 #define G_MINSHORT      SHRT_MIN
2814 #define G_MAXSHORT      SHRT_MAX
2815 #define G_MAXUSHORT     USHRT_MAX
2816 #define G_MININT        INT_MIN
2817 #define G_MAXINT        INT_MAX
2818 #define G_MAXUINT       UINT_MAX
2819 #define G_MINLONG       LONG_MIN
2820 #define G_MAXLONG       LONG_MAX
2821 #define G_MAXULONG      ULONG_MAX
2822
2823 _______EOF
2824
2825
2826         ### this should always be true in a modern C/C++ compiler
2827         cat >>$outfile <<_______EOF
2828 typedef signed char gint8;
2829 typedef unsigned char guint8;
2830 _______EOF
2831
2832
2833         if test -n "$gint16"; then
2834           cat >>$outfile <<_______EOF
2835 typedef signed $gint16 gint16;
2836 typedef unsigned $gint16 guint16;
2837 #define G_GINT16_MODIFIER $gint16_modifier
2838 #define G_GINT16_FORMAT $gint16_format
2839 #define G_GUINT16_FORMAT $guint16_format
2840 _______EOF
2841         fi
2842
2843
2844         if test -n "$gint32"; then
2845           cat >>$outfile <<_______EOF
2846 typedef signed $gint32 gint32;
2847 typedef unsigned $gint32 guint32;
2848 #define G_GINT32_MODIFIER $gint32_modifier
2849 #define G_GINT32_FORMAT $gint32_format
2850 #define G_GUINT32_FORMAT $guint32_format
2851 _______EOF
2852         fi
2853
2854         cat >>$outfile <<_______EOF
2855 #define G_HAVE_GINT64 1          /* deprecated, always true */
2856
2857 ${glib_extension}typedef signed $gint64 gint64;
2858 ${glib_extension}typedef unsigned $gint64 guint64;
2859
2860 #define G_GINT64_CONSTANT(val)  $gint64_constant
2861 #define G_GUINT64_CONSTANT(val) $guint64_constant
2862 _______EOF
2863
2864         if test x$gint64_format != x ; then
2865           cat >>$outfile <<_______EOF
2866 #define G_GINT64_MODIFIER $gint64_modifier
2867 #define G_GINT64_FORMAT $gint64_format
2868 #define G_GUINT64_FORMAT $guint64_format
2869 _______EOF
2870         else
2871           cat >>$outfile <<_______EOF
2872 #undef G_GINT64_MODIFIER
2873 #undef G_GINT64_FORMAT
2874 #undef G_GUINT64_FORMAT
2875 _______EOF
2876         fi
2877
2878         cat >>$outfile <<_______EOF
2879
2880 #define GLIB_SIZEOF_VOID_P $glib_void_p
2881 #define GLIB_SIZEOF_LONG   $glib_long
2882 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2883 #define GLIB_SIZEOF_SSIZE_T $glib_ssize_t
2884
2885 _______EOF
2886
2887         cat >>$outfile <<_______EOF
2888 typedef signed $glib_ssize_type_define gssize;
2889 typedef unsigned $glib_size_type_define gsize;
2890 #define G_GSIZE_MODIFIER $gsize_modifier
2891 #define G_GSSIZE_MODIFIER $gssize_modifier
2892 #define G_GSIZE_FORMAT $gsize_format
2893 #define G_GSSIZE_FORMAT $gssize_format
2894
2895 #define G_MAXSIZE       G_MAXU$glib_msize_type
2896 #define G_MINSSIZE      G_MIN$glib_mssize_type
2897 #define G_MAXSSIZE      G_MAX$glib_mssize_type
2898
2899 typedef gint64 goffset;
2900 #define G_MINOFFSET     G_MININT64
2901 #define G_MAXOFFSET     G_MAXINT64
2902
2903 #define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
2904 #define G_GOFFSET_FORMAT        G_GINT64_FORMAT
2905 #define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
2906
2907 _______EOF
2908
2909         if test -z "$glib_unknown_void_p"; then
2910           cat >>$outfile <<_______EOF
2911
2912 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2913 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2914
2915 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2916 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2917
2918 typedef signed $glib_intptr_type_define gintptr;
2919 typedef unsigned $glib_intptr_type_define guintptr;
2920
2921 #define G_GINTPTR_MODIFIER      $gintptr_modifier
2922 #define G_GINTPTR_FORMAT        $gintptr_format
2923 #define G_GUINTPTR_FORMAT       $guintptr_format
2924 _______EOF
2925         else
2926           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2927         fi
2928
2929
2930
2931         cat >>$outfile <<_______EOF
2932 #ifndef G_DISABLE_DEPRECATED
2933 #define g_ATEXIT(proc)  (atexit (proc))
2934 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END
2935 #endif
2936 $glib_defines
2937 $glib_os
2938 $glib_static_compilation
2939
2940 $glib_vacopy
2941
2942 #ifdef  __cplusplus
2943 #define G_HAVE_INLINE   1
2944 #else   /* !__cplusplus */
2945 $glib_inline
2946 #endif  /* !__cplusplus */
2947
2948 #ifdef  __cplusplus
2949 #define G_CAN_INLINE    1
2950 _______EOF
2951
2952         if test x$g_can_inline = xyes ; then
2953                 cat >>$outfile <<_______EOF
2954 #else   /* !__cplusplus */
2955 #define G_CAN_INLINE    1
2956 _______EOF
2957         fi
2958
2959         cat >>$outfile <<_______EOF
2960 #endif
2961
2962 _______EOF
2963
2964         if test x$g_have_iso_c_varargs = xyes ; then
2965                 cat >>$outfile <<_______EOF
2966 #ifndef __cplusplus
2967 # define G_HAVE_ISO_VARARGS 1
2968 #endif
2969 _______EOF
2970         fi
2971         if test x$g_have_iso_cxx_varargs = xyes ; then
2972                 cat >>$outfile <<_______EOF
2973 #ifdef __cplusplus
2974 # define G_HAVE_ISO_VARARGS 1
2975 #endif
2976 _______EOF
2977         fi
2978         if test x$g_have_gnuc_varargs = xyes ; then
2979                 cat >>$outfile <<_______EOF
2980
2981 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2982  * is passed ISO vararg support is turned off, and there is no work
2983  * around to turn it on, so we unconditionally turn it off.
2984  */
2985 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2986 #  undef G_HAVE_ISO_VARARGS
2987 #endif
2988
2989 #define G_HAVE_GNUC_VARARGS 1
2990 _______EOF
2991         fi
2992
2993         case x$g_stack_grows in
2994         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2995         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2996         esac
2997
2998
2999         echo >>$outfile
3000         if test x$g_have_eilseq = xno; then
3001                 cat >>$outfile <<_______EOF
3002 #ifndef EILSEQ
3003 /* On some pre-C99 systems, EILSEQ is not defined.
3004  * The correspondence between this and the corresponding definition
3005  * in libiconv is essential.
3006  */
3007 #  define EILSEQ ENOENT
3008 #endif
3009 _______EOF
3010
3011         fi
3012
3013         if test x$g_have_gnuc_visibility = xyes; then
3014                 cat >>$outfile <<_______EOF
3015 #define G_HAVE_GNUC_VISIBILITY 1
3016 _______EOF
3017         fi
3018                 cat >>$outfile <<_______EOF
3019 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
3020 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
3021 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
3022 #define G_GNUC_INTERNAL __hidden
3023 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
3024 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
3025 #else
3026 #define G_GNUC_INTERNAL
3027 #endif
3028 _______EOF
3029
3030         echo >>$outfile
3031         cat >>$outfile <<_______EOF
3032 #define G_THREADS_ENABLED
3033 #define G_THREADS_IMPL_$g_threads_impl_def
3034 _______EOF
3035
3036         if test x"$g_memory_barrier_needed" != xno; then
3037           echo >>$outfile
3038           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
3039         fi
3040         if test x"$g_atomic_lock_free" = xyes; then
3041           echo >>$outfile
3042           echo "#define G_ATOMIC_LOCK_FREE" >>$outfile
3043         fi
3044         echo >>$outfile
3045         g_bit_sizes="16 32 64"
3046         for bits in $g_bit_sizes; do
3047           cat >>$outfile <<_______EOF
3048 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
3049 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
3050 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
3051 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
3052 _______EOF
3053         done
3054
3055         cat >>$outfile <<_______EOF
3056 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
3057 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
3058 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
3059 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
3060 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
3061 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
3062 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
3063 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
3064 #define GSIZE_TO_LE(val)        ((gsize) GUINT${gsizebits}_TO_LE (val))
3065 #define GSSIZE_TO_LE(val)       ((gssize) GINT${gssizebits}_TO_LE (val))
3066 #define GSIZE_TO_BE(val)        ((gsize) GUINT${gsizebits}_TO_BE (val))
3067 #define GSSIZE_TO_BE(val)       ((gssize) GINT${gssizebits}_TO_BE (val))
3068 #define G_BYTE_ORDER $g_byte_order
3069
3070 #define GLIB_SYSDEF_POLLIN =$g_pollin
3071 #define GLIB_SYSDEF_POLLOUT =$g_pollout
3072 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
3073 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
3074 #define GLIB_SYSDEF_POLLERR =$g_pollerr
3075 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
3076
3077 #define G_MODULE_SUFFIX "$g_module_suffix"
3078
3079 typedef $g_pid_type GPid;
3080
3081 #define GLIB_SYSDEF_AF_UNIX $g_af_unix
3082 #define GLIB_SYSDEF_AF_INET $g_af_inet
3083 #define GLIB_SYSDEF_AF_INET6 $g_af_inet6
3084
3085 #define GLIB_SYSDEF_MSG_OOB $g_msg_oob
3086 #define GLIB_SYSDEF_MSG_PEEK $g_msg_peek
3087 #define GLIB_SYSDEF_MSG_DONTROUTE $g_msg_dontroute
3088
3089 G_END_DECLS
3090
3091 #endif /* __GLIBCONFIG_H__ */
3092 _______EOF
3093
3094
3095         if cmp -s $outfile glib/glibconfig.h; then
3096           AC_MSG_NOTICE([glib/glibconfig.h is unchanged])
3097           rm -f $outfile
3098         else
3099           mv $outfile glib/glibconfig.h
3100         fi
3101 ],[
3102
3103 # Note that if two cases are the same, case goes with the first one.
3104 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
3105 # on variable expansion in case labels.  Look at the generated config.status
3106 # for a hint.
3107
3108 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
3109   glib_header_alloca_h="$ac_cv_working_alloca_h"
3110 else
3111   glib_header_alloca_h="$ac_cv_header_alloca_h"
3112 fi
3113
3114 if test x$enable_included_printf = xyes ; then
3115   glib_included_printf=yes
3116 fi
3117
3118 case 2 in
3119 $ac_cv_sizeof_short)
3120   gint16=short
3121   gint16_modifier='"h"'
3122   gint16_format='"hi"'
3123   guint16_format='"hu"'
3124   ;;
3125 $ac_cv_sizeof_int)
3126   gint16=int
3127   gint16_modifier='""'
3128   gint16_format='"i"'
3129   guint16_format='"u"'
3130   ;;
3131 esac
3132 case 4 in
3133 $ac_cv_sizeof_short)
3134   gint32=short
3135   gint32_modifier='"h"'
3136   gint32_format='"hi"'
3137   guint32_format='"hu"'
3138   ;;
3139 $ac_cv_sizeof_int)
3140   gint32=int
3141   gint32_modifier='""'
3142   gint32_format='"i"'
3143   guint32_format='"u"'
3144   ;;
3145 $ac_cv_sizeof_long)
3146   gint32=long
3147   gint32_modifier='"l"'
3148   gint32_format='"li"'
3149   guint32_format='"lu"'
3150   ;;
3151 esac
3152 case 8 in
3153 $ac_cv_sizeof_int)
3154   gint64=int
3155   gint64_modifier='""'
3156   gint64_format='"i"'
3157   guint64_format='"u"'
3158   glib_extension=
3159   gint64_constant='(val)'
3160   guint64_constant='(val)'
3161   ;;
3162 $ac_cv_sizeof_long)
3163   gint64=long
3164   gint64_modifier='"l"'
3165   gint64_format='"li"'
3166   guint64_format='"lu"'
3167   glib_extension=
3168   gint64_constant='(val##L)'
3169   guint64_constant='(val##UL)'
3170   ;;
3171 $ac_cv_sizeof_long_long)
3172   gint64='long long'
3173   if test -n "$glib_cv_long_long_format"; then
3174     gint64_modifier='"'$glib_cv_long_long_format'"'
3175     gint64_format='"'$glib_cv_long_long_format'i"'
3176     guint64_format='"'$glib_cv_long_long_format'u"'
3177   fi
3178   glib_extension='G_GNUC_EXTENSION '
3179   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3180   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3181   ;;
3182 $ac_cv_sizeof___int64)
3183   gint64='__int64'
3184   if test -n "$glib_cv_long_long_format"; then
3185     gint64_modifier='"'$glib_cv_long_long_format'"'
3186     gint64_format='"'$glib_cv_long_long_format'i"'
3187     guint64_format='"'$glib_cv_long_long_format'u"'
3188   fi
3189   glib_extension=
3190   gint64_constant='(val##i64)'
3191   guint64_constant='(val##ui64)'
3192   ;;
3193 esac
3194 glib_size_t=$ac_cv_sizeof_size_t
3195 glib_ssize_t=$ac_cv_sizeof_ssize_t
3196 glib_size_type_define="$glib_size_type"
3197 glib_ssize_type_define="$glib_ssize_type"
3198 glib_void_p=$ac_cv_sizeof_void_p
3199 glib_long=$ac_cv_sizeof_long
3200
3201 case "$glib_size_type" in
3202 short)
3203   gsize_modifier='"h"'
3204   gsize_format='"hu"'
3205   glib_msize_type='SHRT'
3206   ;;
3207 int)
3208   gsize_modifier='""'
3209   gsize_format='"u"'
3210   glib_msize_type='INT'
3211   ;;
3212 long)
3213   gsize_modifier='"l"'
3214   gsize_format='"lu"'
3215   glib_msize_type='LONG'
3216   ;;
3217 "long long"|__int64)
3218   gsize_modifier='"I64"'
3219   gsize_format='"I64u"'
3220   glib_msize_type='INT64'
3221   ;;
3222 esac
3223
3224 case "$glib_ssize_type" in
3225 short)
3226   gssize_modifier='"h"'
3227   gssize_format='"hi"'
3228   glib_mssize_type='SHRT'
3229   ;;
3230 int)
3231   gssize_modifier='""'
3232   gssize_format='"i"'
3233   glib_mssize_type='INT'
3234   ;;
3235 long)
3236   gssize_modifier='"l"'
3237   gssize_format='"li"'
3238   glib_mssize_type='LONG'
3239   ;;
3240 "long long"|__int64)
3241   gssize_modifier='"I64"'
3242   gssize_format='"I64i"'
3243   glib_mssize_type='INT64'
3244   ;;
3245 esac
3246
3247 gintbits=`expr $ac_cv_sizeof_int \* 8`
3248 glongbits=`expr $ac_cv_sizeof_long \* 8`
3249 gsizebits=`expr $ac_cv_sizeof_size_t \* 8`
3250 gssizebits=`expr $ac_cv_sizeof_ssize_t \* 8`
3251
3252 case $ac_cv_sizeof_void_p in
3253 $ac_cv_sizeof_int)
3254   glib_intptr_type_define=int
3255   gintptr_modifier='""'
3256   gintptr_format='"i"'
3257   guintptr_format='"u"'
3258   glib_gpi_cast='(gint)'
3259   glib_gpui_cast='(guint)'
3260   ;;
3261 $ac_cv_sizeof_long)
3262   glib_intptr_type_define=long
3263   gintptr_modifier='"l"'
3264   gintptr_format='"li"'
3265   guintptr_format='"lu"'
3266   glib_gpi_cast='(glong)'
3267   glib_gpui_cast='(gulong)'
3268   ;;
3269 $ac_cv_sizeof_long_long)
3270   glib_intptr_type_define='long long'
3271   gintptr_modifier='"I64"'
3272   gintptr_format='"I64i"'
3273   guintptr_format='"I64u"'
3274   glib_gpi_cast='(gint64)'
3275   glib_gpui_cast='(guint64)'
3276   ;;
3277 $ac_cv_sizeof___int64)
3278   glib_intptr_type_define=__int64
3279   gintptr_modifier='"I64"'
3280   gintptr_format='"I64i"'
3281   guintptr_format='"I64u"'
3282   glib_gpi_cast='(gint64)'
3283   glib_gpui_cast='(guint64)'
3284   ;;
3285 *)
3286   glib_unknown_void_p=yes
3287   ;;
3288 esac
3289
3290
3291 glib_defines="
3292 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3293 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3294 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3295 "
3296
3297 case xyes in
3298 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3299 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3300 *)                      glib_vacopy=''
3301 esac
3302
3303 if test x$glib_cv_va_val_copy = xno; then
3304   glib_vacopy="\$glib_vacopy
3305 #define G_VA_COPY_AS_ARRAY 1"
3306 fi
3307
3308 if test x$glib_cv_hasinline = xyes; then
3309     glib_inline='#define G_HAVE_INLINE 1'
3310 fi
3311 if test x$glib_cv_has__inline = xyes; then
3312     glib_inline="\$glib_inline
3313 #define G_HAVE___INLINE 1"
3314 fi
3315 if test x$glib_cv_has__inline__ = xyes; then
3316     glib_inline="\$glib_inline
3317 #define G_HAVE___INLINE__ 1"
3318 fi
3319
3320 g_have_gnuc_varargs=$g_have_gnuc_varargs
3321 g_have_iso_c_varargs=$g_have_iso_c_varargs
3322 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3323
3324 g_can_inline=$g_can_inline
3325 g_have_gnuc_visibility=$g_have_gnuc_visibility
3326 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3327
3328 if test x$ac_cv_c_bigendian = xyes; then
3329   g_byte_order=G_BIG_ENDIAN
3330   g_bs_native=BE
3331   g_bs_alien=LE
3332 else
3333   g_byte_order=G_LITTLE_ENDIAN
3334   g_bs_native=LE
3335   g_bs_alien=BE
3336 fi
3337
3338 g_pollin=$glib_cv_value_POLLIN
3339 g_pollout=$glib_cv_value_POLLOUT
3340 g_pollpri=$glib_cv_value_POLLPRI
3341 g_pollhup=$glib_cv_value_POLLHUP
3342 g_pollerr=$glib_cv_value_POLLERR
3343 g_pollnval=$glib_cv_value_POLLNVAL
3344
3345 # If a family is not found on the system, define that family to
3346 # a negative value, picking a different one for each undefined
3347 # family (-1 for AF_UNIX, -2 for the next one, -3 ...)
3348 # This is needed because glib-mkenums doesn't handle optional
3349 # values in enums, and thus we have to have all existing values
3350 # defined in the enum.
3351 if test "x$glib_cv_value_AF_UNIX" != "x"; then
3352   g_af_unix=$glib_cv_value_AF_UNIX
3353 else
3354   g_af_unix=-1
3355 fi
3356 g_af_inet=$glib_cv_value_AF_INET
3357 g_af_inet6=$glib_cv_value_AF_INET6
3358
3359 g_msg_peek=$glib_cv_value_MSG_PEEK
3360 g_msg_oob=$glib_cv_value_MSG_OOB
3361 g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
3362
3363 g_stack_grows=$glib_cv_stack_grows
3364
3365 g_have_eilseq=$have_eilseq
3366
3367 g_threads_impl_def=$g_threads_impl
3368
3369 g_atomic_lock_free="$glib_cv_g_atomic_lock_free"
3370 g_memory_barrier_needed="$glib_memory_barrier_needed"
3371 g_gcc_atomic_ops="$glib_cv_gcc_has_builtin_atomic_operations"
3372
3373 g_module_suffix="$glib_gmodule_suffix"
3374
3375 g_pid_type="$glib_pid_type"
3376 case $host in
3377   *-*-cygwin*)
3378     glib_os="#define G_OS_UNIX
3379 #define G_PLATFORM_WIN32
3380 #define G_WITH_CYGWIN"
3381     ;;
3382   *-*-mingw*)
3383     glib_os="#define G_OS_WIN32
3384 #define G_PLATFORM_WIN32"
3385     ;;
3386   *)
3387     glib_os="#define G_OS_UNIX"
3388     ;;
3389 esac
3390 glib_static_compilation=""
3391 if test x$glib_win32_static_compilation = xyes; then
3392   glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3393 #define GOBJECT_STATIC_COMPILATION 1"
3394 fi
3395 ])
3396
3397 # Redo enough to get guint32 and guint64 for the alignment checks below
3398 case 4 in
3399 $ac_cv_sizeof_short)
3400   gint32=short
3401   ;;
3402 $ac_cv_sizeof_int)
3403   gint32=int
3404   ;;
3405 $ac_cv_sizeof_long)
3406   gint32=long
3407   ;;
3408 esac
3409 case 8 in
3410 $ac_cv_sizeof_int)
3411   gint64=int
3412   ;;
3413 $ac_cv_sizeof_long)
3414   gint64=long
3415   ;;
3416 $ac_cv_sizeof_long_long)
3417   gint64='long long'
3418   ;;
3419 $ac_cv_sizeof___int64)
3420   gint64='__int64'
3421   ;;
3422 esac
3423
3424 AC_CHECK_TYPE([guint32],,,[typedef unsigned $gint32 guint32;])
3425 AC_CHECK_ALIGNOF([guint32], [AC_INCLUDES_DEFAULT
3426 typedef unsigned $gint32 guint32;])
3427 AC_CHECK_TYPE([guint64],,,[typedef unsigned $gint64 guint64;])
3428 AC_CHECK_ALIGNOF([guint64], [AC_INCLUDES_DEFAULT
3429 typedef unsigned $gint64 guint64;])
3430 AC_CHECK_TYPE([unsigned long])
3431 AC_CHECK_ALIGNOF([unsigned long])
3432
3433 # Check for libdbus1 - Optional - is only used in the GDBus test cases
3434 #
3435 # 1.2.14 required for dbus_message_set_serial
3436 PKG_CHECK_MODULES(DBUS1,
3437      dbus-1 >= 1.2.14,
3438      [AC_DEFINE(HAVE_DBUS1, 1, [Define if dbus-1 is available]) have_dbus1=yes],
3439      have_dbus1=no)
3440 AC_SUBST(DBUS1_CFLAGS)
3441 AC_SUBST(DBUS1_LIBS)
3442 AM_CONDITIONAL(HAVE_DBUS1, [test "x$have_dbus1" = "xyes"])
3443
3444 AC_CHECK_PROGS([DBUS_DAEMON], [dbus-daemon])
3445 AM_CONDITIONAL([HAVE_DBUS_DAEMON], [test x$DBUS_DAEMON = xdbus-daemon ])
3446
3447 dnl
3448 dnl Check for -Bsymbolic-functions linker flag used to avoid
3449 dnl intra-library PLT jumps, if available.
3450 dnl
3451
3452 AC_ARG_ENABLE(Bsymbolic,
3453               [AS_HELP_STRING([--disable-Bsymbolic],
3454                               [avoid linking with -Bsymbolic])],,
3455               [SAVED_LDFLAGS="${LDFLAGS}"
3456                AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
3457                LDFLAGS=-Wl,-Bsymbolic-functions
3458                AC_TRY_LINK([], [int main (void) { return 0; }],
3459                            AC_MSG_RESULT(yes)
3460                            enable_Bsymbolic=yes,
3461                            AC_MSG_RESULT(no)
3462                            enable_Bsymbolic=no)
3463                LDFLAGS="${SAVED_LDFLAGS}"])
3464
3465 if test "x${enable_Bsymbolic}" = "xyes"; then
3466   GLIB_LINK_FLAGS=-Wl,-Bsymbolic-functions
3467 fi
3468
3469 AC_SUBST(GLIB_LINK_FLAGS)
3470
3471 dnl
3472 dnl Check for -fvisibility=hidden to determine if we can do GNU-style
3473 dnl visibility attributes for symbol export control
3474 dnl
3475 GLIB_HIDDEN_VISIBILITY_CFLAGS=""
3476 case "$host" in
3477   *-*-mingw*)
3478     dnl on mingw32 we do -fvisibility=hidden and __declspec(dllexport)
3479     AC_DEFINE([_GLIB_EXTERN], [__attribute__((visibility("default"))) __declspec(dllexport) extern],
3480               [defines how to decorate public symbols while building])
3481     CFLAGS="${CFLAGS} -fvisibility=hidden"
3482     ;;
3483   *)
3484     dnl on other compilers, check if we can do -fvisibility=hidden
3485     SAVED_CFLAGS="${CFLAGS}"
3486     CFLAGS="-fvisibility=hidden"
3487     AC_MSG_CHECKING([for -fvisibility=hidden compiler flag])
3488     AC_TRY_COMPILE([], [int main (void) { return 0; }],
3489                    AC_MSG_RESULT(yes)
3490                    enable_fvisibility_hidden=yes,
3491                    AC_MSG_RESULT(no)
3492                    enable_fvisibility_hidden=no)
3493     CFLAGS="${SAVED_CFLAGS}"
3494
3495     AS_IF([test "${enable_fvisibility_hidden}" = "yes"], [
3496       AC_DEFINE([_GLIB_EXTERN], [__attribute__((visibility("default"))) extern],
3497                 [defines how to decorate public symbols while building])
3498       GLIB_HIDDEN_VISIBILITY_CFLAGS="-fvisibility=hidden"
3499     ])
3500     ;;
3501 esac
3502 AC_SUBST(GLIB_HIDDEN_VISIBILITY_CFLAGS)
3503
3504 dnl Compiler flags; macro originates from systemd
3505 dnl See https://bugzilla.gnome.org/show_bug.cgi?id=608953
3506 AC_ARG_ENABLE(compile-warnings,
3507               [AS_HELP_STRING([--disable-compile-warnings],
3508                               [Don't use builtin compiler warnings])],,
3509                               enable_compile_warnings=yes)
3510 AS_IF([test "x$enable_compile_warnings" = xyes], [
3511   CC_CHECK_FLAGS_APPEND([GLIB_WARN_CFLAGS], [CFLAGS], [\
3512    -Wall -Wstrict-prototypes -Werror=declaration-after-statement \
3513    -Werror=missing-prototypes -Werror=implicit-function-declaration \
3514    -Werror=pointer-arith -Werror=init-self -Werror=format-security \
3515    -Werror=format=2 -Werror=missing-include-dirs])
3516 ])
3517 AC_SUBST(GLIB_WARN_CFLAGS)
3518
3519 #
3520 # Define variables corresponding to the correct include paths to use for
3521 # in-tree building.
3522 #
3523
3524 # for config.h:
3525 config_h_INCLUDES='-I$(top_builddir)'
3526 AC_SUBST(config_h_INCLUDES)
3527
3528 # glib:
3529 #   config.h
3530 #   $(top_builddir)/glib: for glibconfig.h
3531 #   $(top_srcdir)/glib:   for glib.h
3532 #   $(top_srcdir):        for everything
3533 glib_INCLUDES='$(config_h_INCLUDES) -I$(top_builddir)/glib -I$(top_srcdir)/glib -I$(top_srcdir)'
3534 AC_SUBST(glib_INCLUDES)
3535
3536 # gobject:
3537 #   same as glib
3538 gobject_INCLUDES='$(glib_INCLUDES)'
3539 AC_SUBST(gobject_INCLUDES)
3540
3541 # gmodule:
3542 #   glib includes
3543 #   $(top_srcdir)/gmodule: for gmodule.h
3544 gmodule_INCLUDES='$(glib_INCLUDES) -I$(top_srcdir)/gmodule'
3545 AC_SUBST(gmodule_INCLUDES)
3546
3547 # gio:
3548 #   same as gmodule
3549 gio_INCLUDES='$(gmodule_INCLUDES)'
3550 AC_SUBST(gio_INCLUDES)
3551
3552
3553 AC_CONFIG_FILES([
3554 glib-2.0.pc
3555 gmodule-2.0.pc
3556 gmodule-export-2.0.pc
3557 gmodule-no-export-2.0.pc
3558 gthread-2.0.pc
3559 gobject-2.0.pc
3560 gio-2.0.pc
3561 gio-unix-2.0.pc
3562 gio-windows-2.0.pc
3563 glib-zip
3564 glib-gettextize
3565 Makefile
3566 build/Makefile
3567 build/win32/Makefile
3568 build/win32/dirent/Makefile
3569 build/win32/vs9/Makefile
3570 build/win32/vs10/Makefile
3571 build/win32/vs11/Makefile
3572 glib/Makefile
3573 glib/glib.stp
3574 glib/libcharset/Makefile
3575 glib/gnulib/Makefile
3576 glib/pcre/Makefile
3577 glib/update-pcre/Makefile
3578 glib/tests/Makefile
3579 gmodule/Makefile
3580 gmodule/gmoduleconf.h
3581 gobject/Makefile
3582 gobject/gobject.stp
3583 gobject/glib-mkenums
3584 gobject/tests/Makefile
3585 gthread/Makefile
3586 gio/Makefile
3587 gio/gdbus-2.0/codegen/Makefile
3588 gio/gdbus-2.0/codegen/config.py
3589 gio/gnetworking.h
3590 gio/xdgmime/Makefile
3591 gio/inotify/Makefile
3592 gio/kqueue/Makefile
3593 gio/fen/Makefile
3594 gio/fam/Makefile
3595 gio/win32/Makefile
3596 gio/tests/Makefile
3597 gio/tests/gdbus-object-manager-example/Makefile
3598 gio/tests/services/Makefile
3599 gio/tests/services/org.gtk.GDBus.Examples.ObjectManager.service
3600 gio/tests/modules/Makefile
3601 po/Makefile.in
3602 docs/Makefile
3603 docs/reference/Makefile
3604 docs/reference/glib/Makefile
3605 docs/reference/glib/version.xml
3606 docs/reference/gobject/Makefile
3607 docs/reference/gobject/version.xml
3608 docs/reference/gio/Makefile
3609 docs/reference/gio/gdbus-object-manager-example/Makefile
3610 docs/reference/gio/version.xml
3611 tests/Makefile
3612 tests/gobject/Makefile
3613 tests/refcount/Makefile
3614 m4macros/Makefile
3615 ])
3616
3617 AC_CONFIG_COMMANDS([chmod-scripts],
3618 [chmod 0755 glib-zip
3619 chmod 0755 glib-gettextize
3620 chmod 0755 gobject/glib-mkenums])
3621
3622 # we want to invoke this macro solely so that the config.status script
3623 # and automake generated makefiles know about these generated files.
3624 # They are only needed to distcheck the package
3625 if false; then
3626   AC_CONFIG_FILES([
3627     INSTALL
3628     README
3629     config.h.win32
3630     glib/glibconfig.h.win32
3631     glib/makefile.msc
3632     glib/glib.rc
3633     gmodule/makefile.msc
3634     gmodule/gmodule.rc
3635     gobject/makefile.msc
3636     gobject/gobject.rc
3637     gthread/makefile.msc
3638     gthread/gthread.rc
3639     gio/gio.rc
3640     tests/makefile.msc
3641   ])
3642 fi
3643
3644 AC_OUTPUT