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