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