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