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