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