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