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