configure.in

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