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