configure.ac

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