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