configure.ac

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