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