configure.ac

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