configure.ac

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