configure.in

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