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