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