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