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