configure.ac

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