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