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