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], [25])
  25 m4_define([glib_micro_version], [16])
  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   ])
2388 ])
2389
2390 AC_CACHE_CHECK(for monotonic clocks,
2391     glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2392 #include <time.h>
2393 #include <unistd.h>
2394 int main() {
2395 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2396         #error No monotonic clock
2397 #endif
2398         return 0;
2399 }
2400 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2401 if test "$glib_cv_monotonic_clock" = "yes"; then
2402   AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2403 fi
2404
2405
2406 dnl ********************************
2407 dnl *** g_atomic_* tests for gcc ***
2408 dnl ********************************
2409
2410 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2411
2412 glib_cv_gcc_has_builtin_atomic_operations=no
2413 if test x"$GCC" = xyes; then
2414   AC_MSG_CHECKING([whether GCC supports build-in atomic intrinsics])
2415   AC_TRY_LINK([],
2416               [int i;
2417                __sync_synchronize ();
2418                __sync_bool_compare_and_swap (&i, 0, 1);
2419                __sync_fetch_and_add (&i, 1);
2420               ],
2421               [glib_cv_gcc_has_builtin_atomic_operations=yes],
2422               [glib_cv_gcc_has_builtin_atomic_operations=no])
2423
2424   AC_MSG_RESULT($glib_cv_gcc_has_builtin_atomic_operations)
2425   if test $glib_cv_gcc_has_builtin_atomic_operations = yes; then
2426     glib_memory_barrier_needed=yes
2427   else
2428     case $host_cpu in
2429       i386)
2430         AC_MSG_RESULT([none])
2431         glib_memory_barrier_needed=no
2432         ;;
2433       i?86)
2434         AC_MSG_RESULT([i486])
2435         AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2436                            [i486 atomic implementation])
2437         glib_memory_barrier_needed=no
2438         ;;
2439       sparc*)
2440         SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2441                          when you are using a sparc with v9 instruction set (most
2442                          sparcs nowadays). This will make the code for atomic
2443                          operations much faster. The resulting code will not run
2444                          on very old sparcs though."
2445
2446         AC_LINK_IFELSE([[
2447           main ()
2448           {
2449             int tmp1, tmp2, tmp3;
2450             __asm__ __volatile__("casx [%2], %0, %1"
2451                                  : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2452           }]],
2453           AC_MSG_RESULT([sparcv9])
2454           AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2455                              [sparcv9 atomic implementation]),
2456           AC_MSG_RESULT([no])
2457           AC_MSG_WARN([[$SPARCV9_WARNING]]))
2458         glib_memory_barrier_needed=yes
2459         ;;
2460       alpha*)
2461         AC_MSG_RESULT([alpha])
2462         AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2463                            [alpha atomic implementation])
2464         glib_memory_barrier_needed=yes
2465         ;;
2466       x86_64)
2467         AC_MSG_RESULT([x86_64])
2468         AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2469                            [x86_64 atomic implementation])
2470         glib_memory_barrier_needed=no
2471        ;;
2472       powerpc*)
2473         AC_MSG_RESULT([powerpc])
2474         AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2475                            [powerpc atomic implementation])
2476         glib_memory_barrier_needed=yes
2477         AC_MSG_CHECKING([whether asm supports numbered local labels])
2478         AC_TRY_COMPILE(
2479                        ,[
2480                        __asm__ __volatile__ ("1:       nop\n"
2481                                "         bne-    1b")
2482                        ],[
2483                        AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2484                        AC_MSG_RESULT([yes])
2485                        ],[
2486                        AC_MSG_RESULT([no])
2487                        ])
2488         ;;
2489       ia64)
2490         AC_MSG_RESULT([ia64])
2491         AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2492                            [ia64 atomic implementation])
2493         glib_memory_barrier_needed=yes
2494         ;;
2495       s390|s390x)
2496         AC_MSG_RESULT([s390])
2497         AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2498                            [s390 atomic implementation])
2499         glib_memory_barrier_needed=no
2500         ;;
2501       arm*)
2502         AC_MSG_RESULT([arm])
2503         AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2504                            [arm atomic implementation])
2505         glib_memory_barrier_needed=no
2506         ;;
2507       crisv32*|etraxfs*)
2508         AC_MSG_RESULT([crisv32])
2509         AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
2510                            [crisv32 atomic implementation])
2511         glib_memory_barrier_needed=no
2512         ;;
2513       cris*|etrax*)
2514         AC_MSG_RESULT([cris])
2515         AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
2516                            [cris atomic implementation])
2517         glib_memory_barrier_needed=no
2518         ;;
2519       *)
2520         AC_MSG_RESULT([none])
2521         glib_memory_barrier_needed=yes
2522         ;;
2523     esac
2524   fi
2525 else
2526   if test $glib_native_win32 = yes; then
2527     # For Windows but not using gcc. No barriers needed then either.
2528     glib_memory_barrier_needed=no
2529   fi
2530 fi
2531
2532 AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS,
2533                [test $glib_cv_gcc_has_builtin_atomic_operations = yes])
2534
2535 dnl ************************
2536 dnl ** Check for futex(2) **
2537 dnl ************************
2538 AC_MSG_CHECKING([for futex(2) system call])
2539 AC_COMPILE_IFELSE([
2540 #include <linux/futex.h>
2541 #include <syscall.h>
2542 #include <unistd.h>
2543
2544 int
2545 main (void)
2546 {
2547   /* it's not like this actually runs or anything... */
2548   syscall (SYS_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
2549   return 0;
2550 }
2551 ],
2552 [
2553   AC_MSG_RESULT(yes)
2554   AC_DEFINE(HAVE_FUTEX, [test "$have_futex" = "yes"],
2555             [we have the futex(2) system call])
2556 ],
2557 [
2558   AC_MSG_RESULT(no)
2559 ])
2560
2561 dnl ****************************************
2562 dnl *** GLib POLL* compatibility defines ***
2563 dnl ****************************************
2564
2565 glib_poll_includes=["
2566 #include <sys/types.h>
2567 #include <sys/poll.h>
2568 "]
2569
2570 if test $ac_cv_header_sys_types_h = yes &&
2571    test $ac_cv_header_sys_poll_h = yes ; then
2572   glib_failed=false
2573   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2574   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2575   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2576   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2577   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2578   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2579   if $glib_failed ; then
2580     AC_MSG_ERROR([Could not determine values for POLL* constants])
2581   fi
2582 else
2583   glib_cv_value_POLLIN=1
2584   glib_cv_value_POLLOUT=4
2585   glib_cv_value_POLLPRI=2
2586   glib_cv_value_POLLERR=8
2587   glib_cv_value_POLLHUP=16
2588   glib_cv_value_POLLNVAL=32
2589 fi
2590
2591 AC_MSG_CHECKING([for broken poll])
2592 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2593         #include <stdlib.h>
2594         #include <fcntl.h>
2595         #include <poll.h>
2596         #ifdef HAVE_SYS_POLL_H
2597         #include <sys/poll.h>
2598         #endif
2599         int main(void) {
2600           struct pollfd fds[1];
2601           int fd;
2602           fd = open("/dev/null", 1);
2603           fds[0].fd = fd;
2604           fds[0].events = POLLIN;
2605           fds[0].revents = 0;
2606           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2607                 exit(1);  /* Does not work for devices -- fail */
2608           }
2609           exit(0);
2610         }]])],
2611   [broken_poll=no],
2612   [broken_poll=yes
2613    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2614   [broken_poll="no (cross compiling)"])
2615 AC_MSG_RESULT($broken_poll)
2616
2617 dnl *********************
2618 dnl *** GRegex checks ***
2619 dnl *********************
2620 PCRE_REQUIRED_VERSION=7.2
2621
2622 # Check if we should compile GRegex
2623 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2624               [disable the compilation of GRegex]),
2625 [case "${enableval}" in
2626   yes) enable_regex=true ;;
2627   no)  enable_regex=false ;;
2628   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2629 esac],
2630 [enable_regex=true])
2631
2632 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2633
2634 if test x$enable_regex = xtrue; then
2635   AC_DEFINE(ENABLE_REGEX, [], [include GRegex])
2636   # Check if we should use the internal or the system-supplied pcre
2637   AC_ARG_WITH(pcre,
2638              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2639                              [specify whether to use the internal or the
2640                               system-supplied PCRE library])])
2641
2642   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2643
2644   if test "x$with_pcre" = xsystem; then
2645     PKG_CHECK_MODULES(PCRE,
2646                       libpcre >= $PCRE_REQUIRED_VERSION)
2647     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2648                    glib_save_CFLAGS="$CFLAGS"
2649                    glib_save_LIBS="$LIBS"
2650                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2651                    AC_TRY_RUN([#include <pcre.h>
2652                                int main () {
2653                                  int support;
2654                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2655                                  if (!support)
2656                                    return 1;
2657                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2658                                  if (!support)
2659                                    return 1;
2660                                  return 0;
2661                                }],
2662                    glib_cv_pcre_has_unicode=yes,
2663                    glib_cv_pcre_has_unicode=no,
2664                    glib_cv_pcre_has_unicode=yes)
2665                    CFLAGS="$glib_save_CFLAGS"
2666                    LIBS="$glib_save_LIBS"
2667         ])
2668     if test "$glib_cv_pcre_has_unicode" = "no"; then
2669       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2670     fi
2671     AC_SUBST(PCRE_CFLAGS)
2672     AC_SUBST(PCRE_LIBS)
2673     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2674     PCRE_REQUIRES=libpcre
2675     AC_SUBST(PCRE_REQUIRES)
2676   else
2677     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2678     if test x"$GCC" = xyes; then
2679       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2680       save_CFLAGS="$CFLAGS"
2681       CFLAGS="$CFLAGS -Wno-pointer-sign"
2682       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2683                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2684       CFLAGS="$save_CFLAGS"
2685     fi
2686   fi
2687   AC_SUBST(PCRE_WARN_CFLAGS)
2688 else
2689   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2690 fi
2691
2692 dnl **********************
2693 dnl *** Win32 API libs ***
2694 dnl **********************
2695
2696 case $host in
2697   *-*-cygwin*)
2698         G_LIBS_EXTRA="-luser32 -lkernel32"
2699     ;;
2700   *-*-mingw*)
2701         G_LIBS_EXTRA="-lws2_32 -lole32"
2702     ;;
2703   *)
2704         G_LIBS_EXTRA=""
2705     ;;
2706 esac
2707 AC_SUBST(G_LIBS_EXTRA)
2708
2709 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2710 dnl since we need it for g_iconv()
2711
2712 AC_MSG_CHECKING([for EILSEQ])
2713 AC_TRY_COMPILE([
2714 #include <errno.h>
2715 ],
2716 [
2717 int error = EILSEQ;
2718 ], have_eilseq=yes, have_eilseq=no);
2719 AC_MSG_RESULT($have_eilseq)
2720
2721 dnl ******************************************************************
2722 dnl *** If we are cross-compiling, look for glib-genmarshal and    ***
2723 dnl *** glib-compile-schemas in PATH                               ***
2724 dnl ******************************************************************
2725
2726 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2727
2728 if test $cross_compiling = yes; then
2729   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2730   if test x$GLIB_GENMARSHAL = xno; then
2731     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2732   fi
2733
2734   AC_PATH_PROG(GLIB_COMPILE_SCHEMAS, glib-compile-schemas, no)
2735   if test x$GLIB_COMPILE_SCHEMAS = xno; then
2736     AC_MSG_ERROR(Could not find a glib-compile-schemas in your PATH)
2737   fi
2738 fi
2739
2740 dnl **************************
2741 dnl *** Checks for gtk-doc ***
2742 dnl **************************
2743
2744 GTK_DOC_CHECK([1.15])
2745
2746 AC_ARG_ENABLE(man,
2747               [AC_HELP_STRING([--enable-man],
2748                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2749               enable_man=no)
2750
2751 if test "${enable_man}" != no; then
2752 dnl
2753 dnl Check for xsltproc
2754 dnl
2755 AC_PATH_PROG([XSLTPROC], [xsltproc])
2756   if test -z "$XSLTPROC"; then
2757     enable_man=no
2758   fi
2759
2760   dnl check for DocBook DTD and stylesheets in the local catalog.
2761   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2762      [DocBook XML DTD V4.1.2],,enable_man=no)
2763   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2764      [DocBook XSL Stylesheets],,enable_man=no)
2765 fi
2766
2767 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2768
2769 dnl
2770 dnl Tracing
2771 dnl
2772
2773 AC_ARG_ENABLE([dtrace],
2774              [AS_HELP_STRING([--enable-dtrace],
2775                               [Enable inclusion of dtrace trace support])])
2776 have_dtrace=no
2777 AC_MSG_CHECKING([whether to include dtrace tracing support])
2778 if test "x$enable_dtrace" != xno; then
2779   if test x$glib_have_carbon = xyes; then
2780     AC_MSG_RESULT([no (not yet compatible with MacOS dtrace)])
2781   else
2782     AC_MSG_RESULT([yes])
2783     AC_CHECK_PROGS(DTRACE, dtrace)
2784     if test -z "$DTRACE"; then
2785       if test "x$enable_dtrace" = xyes; then
2786         AC_MSG_ERROR([dtrace not found])
2787       fi
2788     fi
2789     AC_CHECK_HEADER([sys/sdt.h],have_dtrace=yes,
2790                     [if test "x$enable_dtrace" = xyes; then
2791                       AC_MSG_ERROR([dtrace support needs sys/sdt.h header])
2792                      fi])
2793   fi
2794 else
2795   AC_MSG_RESULT([no])
2796 fi
2797 if test "x$have_dtrace" = xyes; then
2798   AC_DEFINE([HAVE_DTRACE], [1], [Define to 1 if using dtrace probes.])
2799 fi
2800 AM_CONDITIONAL([ENABLE_DTRACE], [test x$have_dtrace = xyes ])
2801
2802 AC_MSG_CHECKING([whether to include systemtap tracing support])
2803 AC_ARG_ENABLE([systemtap],
2804              [AS_HELP_STRING([--enable-systemtap],
2805                               [Enable inclusion of systemtap trace support])])
2806 have_systemtap=no
2807 if test "x$enable_systemtap" != xno -a "x$have_dtrace" = xyes; then
2808   have_systemtap=yes
2809 fi
2810 AC_MSG_RESULT(${have_systemtap})
2811
2812 AM_CONDITIONAL([ENABLE_SYSTEMTAP], [test x$have_systemtap = xyes])
2813
2814 AC_ARG_WITH([tapset-install-dir],
2815             [AS_HELP_STRING([--with-tapset-install-dir],
2816             [The absolute path where the systemtap tapsets will be installed])],
2817             [if test "x${withval}" = x; then
2818                ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"
2819              else
2820                ABS_TAPSET_DIR="${withval}"
2821               fi],
2822             [ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"])
2823 AC_SUBST(ABS_TAPSET_DIR)
2824
2825 dnl ************************************
2826 dnl *** Enable lcov coverage reports ***
2827 dnl ************************************
2828
2829 AC_ARG_ENABLE(gcov,
2830   AS_HELP_STRING([--enable-gcov],
2831                  [Enable gcov]),
2832   [use_gcov=$enableval], [use_gcov=no])
2833
2834 if test "x$use_gcov" = "xyes"; then
2835   dnl we need gcc:
2836   if test "$GCC" != "yes"; then
2837     AC_MSG_ERROR([GCC is required for --enable-gcov])
2838   fi
2839
2840   dnl Check if ccache is being used
2841   AC_CHECK_PROG(SHTOOL, shtool, shtool)
2842   case `$SHTOOL path $CC` in
2843     *ccache*[)] gcc_ccache=yes;;
2844     *[)] gcc_ccache=no;;
2845   esac
2846
2847   if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
2848     AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
2849   fi
2850
2851   ltp_version_list="1.6 1.7 1.8"
2852   AC_CHECK_PROG(LTP, lcov, lcov)
2853   AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
2854
2855   if test "$LTP"; then
2856     AC_CACHE_CHECK([for ltp version], glib_cv_ltp_version, [
2857       glib_cv_ltp_version=invalid
2858       ltp_version=`$LTP -v 2>/dev/null | $SED -e 's/^.* //'`
2859       for ltp_check_version in $ltp_version_list; do
2860         if test "$ltp_version" = "$ltp_check_version"; then
2861           glib_cv_ltp_version="$ltp_check_version (ok)"
2862         fi
2863       done
2864     ])
2865   else
2866     ltp_msg="To enable code coverage reporting you must have one of the following LTP versions installed: $ltp_version_list"
2867     AC_MSG_ERROR([$ltp_msg])
2868   fi
2869
2870   case $glib_cv_ltp_version in
2871     ""|invalid[)]
2872       ltp_msg="You must have one of the following versions of LTP: $ltp_version_list (found: $ltp_version)."
2873       AC_MSG_ERROR([$ltp_msg])
2874       LTP="exit 0;"
2875       ;;
2876   esac
2877
2878   if test -z "$LTP_GENHTML"; then
2879     AC_MSG_ERROR([Could not find genhtml from the LTP package])
2880   fi
2881
2882   AC_DEFINE(HAVE_GCOV, 1, [Whether you have gcov])
2883
2884   dnl Remove all optimization flags from CFLAGS
2885   changequote({,})
2886   CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
2887   changequote([,])
2888
2889   dnl Add the special gcc flags
2890   CFLAGS="$CFLAGS -O0 -fprofile-arcs -ftest-coverage"
2891   LDFLAGS="$LDFLAGS -lgcov"
2892 fi
2893
2894 dnl ******************************
2895 dnl *** output the whole stuff ***
2896 dnl ******************************
2897
2898 dnl this section will only be run if config.status is invoked with no
2899 dnl arguments, or with "glib/glibconfig.h" as an argument.
2900 AC_CONFIG_COMMANDS([glib/glibconfig.h],
2901 [
2902         outfile=glib/glibconfig.h-tmp
2903         cat > $outfile <<\_______EOF
2904 /* glibconfig.h
2905  *
2906  * This is a generated file.  Please modify 'configure.ac'
2907  */
2908
2909 #ifndef __G_LIBCONFIG_H__
2910 #define __G_LIBCONFIG_H__
2911
2912 #include <glib/gmacros.h>
2913
2914 _______EOF
2915
2916         if test x$glib_limits_h = xyes; then
2917           echo '#include <limits.h>' >> $outfile
2918         fi
2919         if test x$glib_float_h = xyes; then
2920           echo '#include <float.h>' >> $outfile
2921         fi
2922         if test x$glib_values_h = xyes; then
2923           echo '#include <values.h>' >> $outfile
2924         fi
2925         if test "$glib_header_alloca_h" = "yes"; then
2926           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2927         fi
2928         if test x$glib_sys_poll_h = xyes; then
2929           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2930         fi
2931         if test x$glib_included_printf != xyes; then
2932           echo "
2933 /* Specifies that GLib's g_print*() functions wrap the
2934  * system printf functions.  This is useful to know, for example,
2935  * when using glibc's register_printf_function().
2936  */" >> $outfile
2937           echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2938         fi
2939
2940         cat >> $outfile <<_______EOF
2941
2942 G_BEGIN_DECLS
2943
2944 #define G_MINFLOAT      $glib_mf
2945 #define G_MAXFLOAT      $glib_Mf
2946 #define G_MINDOUBLE     $glib_md
2947 #define G_MAXDOUBLE     $glib_Md
2948 #define G_MINSHORT      $glib_ms
2949 #define G_MAXSHORT      $glib_Ms
2950 #define G_MAXUSHORT     $glib_Mus
2951 #define G_MININT        $glib_mi
2952 #define G_MAXINT        $glib_Mi
2953 #define G_MAXUINT       $glib_Mui
2954 #define G_MINLONG       $glib_ml
2955 #define G_MAXLONG       $glib_Ml
2956 #define G_MAXULONG      $glib_Mul
2957
2958 _______EOF
2959
2960
2961         ### this should always be true in a modern C/C++ compiler
2962         cat >>$outfile <<_______EOF
2963 typedef signed char gint8;
2964 typedef unsigned char guint8;
2965 _______EOF
2966
2967
2968         if test -n "$gint16"; then
2969           cat >>$outfile <<_______EOF
2970 typedef signed $gint16 gint16;
2971 typedef unsigned $gint16 guint16;
2972 #define G_GINT16_MODIFIER $gint16_modifier
2973 #define G_GINT16_FORMAT $gint16_format
2974 #define G_GUINT16_FORMAT $guint16_format
2975 _______EOF
2976         fi
2977
2978
2979         if test -n "$gint32"; then
2980           cat >>$outfile <<_______EOF
2981 typedef signed $gint32 gint32;
2982 typedef unsigned $gint32 guint32;
2983 #define G_GINT32_MODIFIER $gint32_modifier
2984 #define G_GINT32_FORMAT $gint32_format
2985 #define G_GUINT32_FORMAT $guint32_format
2986 _______EOF
2987         fi
2988
2989         cat >>$outfile <<_______EOF
2990 #define G_HAVE_GINT64 1          /* deprecated, always true */
2991
2992 ${glib_extension}typedef signed $gint64 gint64;
2993 ${glib_extension}typedef unsigned $gint64 guint64;
2994
2995 #define G_GINT64_CONSTANT(val)  $gint64_constant
2996 #define G_GUINT64_CONSTANT(val) $guint64_constant
2997 _______EOF
2998
2999         if test x$gint64_format != x ; then
3000           cat >>$outfile <<_______EOF
3001 #define G_GINT64_MODIFIER $gint64_modifier
3002 #define G_GINT64_FORMAT $gint64_format
3003 #define G_GUINT64_FORMAT $guint64_format
3004 _______EOF
3005         else
3006           cat >>$outfile <<_______EOF
3007 #undef G_GINT64_MODIFIER
3008 #undef G_GINT64_FORMAT
3009 #undef G_GUINT64_FORMAT
3010 _______EOF
3011         fi
3012
3013         cat >>$outfile <<_______EOF
3014
3015 #define GLIB_SIZEOF_VOID_P $glib_void_p
3016 #define GLIB_SIZEOF_LONG   $glib_long
3017 #define GLIB_SIZEOF_SIZE_T $glib_size_t
3018
3019 _______EOF
3020
3021         cat >>$outfile <<_______EOF
3022 typedef signed $glib_size_type_define gssize;
3023 typedef unsigned $glib_size_type_define gsize;
3024 #define G_GSIZE_MODIFIER $gsize_modifier
3025 #define G_GSSIZE_FORMAT $gssize_format
3026 #define G_GSIZE_FORMAT $gsize_format
3027
3028 #define G_MAXSIZE       G_MAXU$glib_msize_type
3029 #define G_MINSSIZE      G_MIN$glib_msize_type
3030 #define G_MAXSSIZE      G_MAX$glib_msize_type
3031
3032 typedef gint64 goffset;
3033 #define G_MINOFFSET     G_MININT64
3034 #define G_MAXOFFSET     G_MAXINT64
3035
3036 #define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
3037 #define G_GOFFSET_FORMAT        G_GINT64_FORMAT
3038 #define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
3039
3040 _______EOF
3041
3042         if test -z "$glib_unknown_void_p"; then
3043           cat >>$outfile <<_______EOF
3044
3045 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
3046 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
3047
3048 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
3049 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
3050
3051 typedef signed $glib_intptr_type_define gintptr;
3052 typedef unsigned $glib_intptr_type_define guintptr;
3053
3054 #define G_GINTPTR_MODIFIER      $gintptr_modifier
3055 #define G_GINTPTR_FORMAT        $gintptr_format
3056 #define G_GUINTPTR_FORMAT       $guintptr_format
3057 _______EOF
3058         else
3059           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
3060         fi
3061
3062
3063
3064         cat >>$outfile <<_______EOF
3065 $glib_atexit
3066 $glib_memmove
3067 $glib_defines
3068 $glib_os
3069 $glib_static_compilation
3070
3071 $glib_vacopy
3072
3073 #ifdef  __cplusplus
3074 #define G_HAVE_INLINE   1
3075 #else   /* !__cplusplus */
3076 $glib_inline
3077 #endif  /* !__cplusplus */
3078
3079 #ifdef  __cplusplus
3080 #define G_CAN_INLINE    1
3081 _______EOF
3082
3083         if test x$g_can_inline = xyes ; then
3084                 cat >>$outfile <<_______EOF
3085 #else   /* !__cplusplus */
3086 #define G_CAN_INLINE    1
3087 _______EOF
3088         fi
3089
3090         cat >>$outfile <<_______EOF
3091 #endif
3092
3093 _______EOF
3094
3095         if test x$g_have_iso_c_varargs = xyes ; then
3096                 cat >>$outfile <<_______EOF
3097 #ifndef __cplusplus
3098 # define G_HAVE_ISO_VARARGS 1
3099 #endif
3100 _______EOF
3101         fi
3102         if test x$g_have_iso_cxx_varargs = xyes ; then
3103                 cat >>$outfile <<_______EOF
3104 #ifdef __cplusplus
3105 # define G_HAVE_ISO_VARARGS 1
3106 #endif
3107 _______EOF
3108         fi
3109         if test x$g_have_gnuc_varargs = xyes ; then
3110                 cat >>$outfile <<_______EOF
3111
3112 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
3113  * is passed ISO vararg support is turned off, and there is no work
3114  * around to turn it on, so we unconditionally turn it off.
3115  */
3116 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
3117 #  undef G_HAVE_ISO_VARARGS
3118 #endif
3119
3120 #define G_HAVE_GNUC_VARARGS 1
3121 _______EOF
3122         fi
3123
3124         case x$g_stack_grows in
3125         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
3126         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
3127         esac
3128
3129
3130         echo >>$outfile
3131         if test x$g_have_eilseq = xno; then
3132                 cat >>$outfile <<_______EOF
3133 #ifndef EILSEQ
3134 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
3135  * The correspondence between this and the corresponding definition
3136  * in libiconv is essential.
3137  */
3138 #  define EILSEQ ENOENT
3139 #endif
3140 _______EOF
3141
3142         fi
3143
3144         if test x$g_have_gnuc_visibility = xyes; then
3145                 cat >>$outfile <<_______EOF
3146 #define G_HAVE_GNUC_VISIBILITY 1
3147 _______EOF
3148         fi
3149                 cat >>$outfile <<_______EOF
3150 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
3151 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
3152 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
3153 #define G_GNUC_INTERNAL __hidden
3154 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
3155 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
3156 #else
3157 #define G_GNUC_INTERNAL
3158 #endif
3159 _______EOF
3160
3161
3162         echo >>$outfile
3163         if test x$g_mutex_has_default = xyes; then
3164                 cat >>$outfile <<_______EOF
3165 $g_enable_threads_def G_THREADS_ENABLED
3166 #define G_THREADS_IMPL_$g_threads_impl_def
3167 typedef struct _GStaticMutex GStaticMutex;
3168 struct _GStaticMutex
3169 {
3170   struct _GMutex *runtime_mutex;
3171   union {
3172     char   pad[[$g_mutex_sizeof]];
3173     double dummy_double;
3174     void  *dummy_pointer;
3175     long   dummy_long;
3176   } static_mutex;
3177 };
3178 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
3179 #define g_static_mutex_get_mutex(mutex) \\
3180   (g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
3181    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
3182 _______EOF
3183         else
3184                 cat >>$outfile <<_______EOF
3185 $g_enable_threads_def G_THREADS_ENABLED
3186 #define G_THREADS_IMPL_$g_threads_impl_def
3187 typedef struct _GMutex* GStaticMutex;
3188 #define G_STATIC_MUTEX_INIT NULL
3189 #define g_static_mutex_get_mutex(mutex) \\
3190   (g_static_mutex_get_mutex_impl_shortcut (mutex))
3191 _______EOF
3192         fi
3193
3194         cat >>$outfile <<_______EOF
3195 /* This represents a system thread as used by the implementation. An
3196  * alien implementaion, as loaded by g_thread_init can only count on
3197  * "sizeof (gpointer)" bytes to store their info. We however need more
3198  * for some of our native implementations. */
3199 typedef union _GSystemThread GSystemThread;
3200 union _GSystemThread
3201 {
3202   char   data[[$g_system_thread_sizeof]];
3203   double dummy_double;
3204   void  *dummy_pointer;
3205   long   dummy_long;
3206 };
3207 _______EOF
3208         if test x"$g_memory_barrier_needed" != xno; then
3209           echo >>$outfile
3210           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
3211         fi
3212
3213         echo >>$outfile
3214         g_bit_sizes="16 32 64"
3215         for bits in $g_bit_sizes; do
3216           cat >>$outfile <<_______EOF
3217 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
3218 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
3219 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
3220 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
3221 _______EOF
3222         done
3223
3224         cat >>$outfile <<_______EOF
3225 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
3226 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
3227 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
3228 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
3229 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
3230 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
3231 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
3232 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
3233 #define GSIZE_TO_LE(val)        ((gsize) GUINT${gsizebits}_TO_LE (val))
3234 #define GSSIZE_TO_LE(val)       ((gssize) GINT${gsizebits}_TO_LE (val))
3235 #define GSIZE_TO_BE(val)        ((gsize) GUINT${gsizebits}_TO_BE (val))
3236 #define GSSIZE_TO_BE(val)       ((gssize) GINT${gsizebits}_TO_BE (val))
3237 #define G_BYTE_ORDER $g_byte_order
3238
3239 #define GLIB_SYSDEF_POLLIN =$g_pollin
3240 #define GLIB_SYSDEF_POLLOUT =$g_pollout
3241 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
3242 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
3243 #define GLIB_SYSDEF_POLLERR =$g_pollerr
3244 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
3245
3246 #define G_MODULE_SUFFIX "$g_module_suffix"
3247
3248 /* A GPid is an abstraction for a process "handle". It is *not* an
3249  * abstraction for a process identifier in general. GPid is used in
3250  * GLib only for descendant processes spawned with the g_spawn*
3251  * functions. On POSIX there is no "process handle" concept as such,
3252  * but on Windows a GPid is a handle to a process, a kind of pointer,
3253  * not a process identifier.
3254  */
3255 typedef $g_pid_type GPid;
3256
3257 #define GLIB_SYSDEF_AF_UNIX $g_af_unix
3258 #define GLIB_SYSDEF_AF_INET $g_af_inet
3259 #define GLIB_SYSDEF_AF_INET6 $g_af_inet6
3260
3261 #define GLIB_SYSDEF_MSG_OOB $g_msg_oob
3262 #define GLIB_SYSDEF_MSG_PEEK $g_msg_peek
3263 #define GLIB_SYSDEF_MSG_DONTROUTE $g_msg_dontroute
3264
3265 G_END_DECLS
3266
3267 #endif /* GLIBCONFIG_H */
3268 _______EOF
3269
3270
3271         if cmp -s $outfile glib/glibconfig.h; then
3272           AC_MSG_NOTICE([glib/glibconfig.h is unchanged])
3273           rm -f $outfile
3274         else
3275           mv $outfile glib/glibconfig.h
3276         fi
3277 ],[
3278
3279 # Note that if two cases are the same, case goes with the first one.
3280 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
3281 # on variable expansion in case labels.  Look at the generated config.status
3282 # for a hint.
3283
3284 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
3285   glib_header_alloca_h="$ac_cv_working_alloca_h"
3286 else
3287   glib_header_alloca_h="$ac_cv_header_alloca_h"
3288 fi
3289
3290 case xyes in
3291 x$ac_cv_header_float_h)
3292   glib_float_h=yes
3293   glib_mf=FLT_MIN glib_Mf=FLT_MAX
3294   glib_md=DBL_MIN glib_Md=DBL_MAX
3295   ;;
3296 x$ac_cv_header_values_h)
3297   glib_values_h=yes
3298   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
3299   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
3300   ;;
3301 esac
3302
3303 case xyes in
3304 x$ac_cv_header_limits_h)
3305   glib_limits_h=yes
3306   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
3307   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
3308   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
3309   ;;
3310 x$ac_cv_header_values_h)
3311   glib_values_h=yes
3312   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
3313   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
3314   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
3315   ;;
3316 esac
3317
3318 if test x$ac_cv_header_sys_poll_h = xyes ; then
3319   glib_sys_poll_h=yes
3320 fi
3321
3322 if test x$enable_included_printf = xyes ; then
3323   glib_included_printf=yes
3324 fi
3325
3326 case 2 in
3327 $ac_cv_sizeof_short)
3328   gint16=short
3329   gint16_modifier='"h"'
3330   gint16_format='"hi"'
3331   guint16_format='"hu"'
3332   ;;
3333 $ac_cv_sizeof_int)
3334   gint16=int
3335   gint16_modifier='""'
3336   gint16_format='"i"'
3337   guint16_format='"u"'
3338   ;;
3339 esac
3340 case 4 in
3341 $ac_cv_sizeof_short)
3342   gint32=short
3343   gint32_modifier='"h"'
3344   gint32_format='"hi"'
3345   guint32_format='"hu"'
3346   ;;
3347 $ac_cv_sizeof_int)
3348   gint32=int
3349   gint32_modifier='""'
3350   gint32_format='"i"'
3351   guint32_format='"u"'
3352   ;;
3353 $ac_cv_sizeof_long)
3354   gint32=long
3355   gint32_modifier='"l"'
3356   gint32_format='"li"'
3357   guint32_format='"lu"'
3358   ;;
3359 esac
3360 case 8 in
3361 $ac_cv_sizeof_int)
3362   gint64=int
3363   gint64_modifier='""'
3364   gint64_format='"i"'
3365   guint64_format='"u"'
3366   glib_extension=
3367   gint64_constant='(val)'
3368   guint64_constant='(val)'
3369   ;;
3370 $ac_cv_sizeof_long)
3371   gint64=long
3372   gint64_modifier='"l"'
3373   gint64_format='"li"'
3374   guint64_format='"lu"'
3375   glib_extension=
3376   gint64_constant='(val##L)'
3377   guint64_constant='(val##UL)'
3378   ;;
3379 $ac_cv_sizeof_long_long)
3380   gint64='long long'
3381   if test -n "$glib_cv_long_long_format"; then
3382     gint64_modifier='"'$glib_cv_long_long_format'"'
3383     gint64_format='"'$glib_cv_long_long_format'i"'
3384     guint64_format='"'$glib_cv_long_long_format'u"'
3385   fi
3386   glib_extension='G_GNUC_EXTENSION '
3387   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3388   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3389   ;;
3390 $ac_cv_sizeof___int64)
3391   gint64='__int64'
3392   if test -n "$glib_cv_long_long_format"; then
3393     gint64_modifier='"'$glib_cv_long_long_format'"'
3394     gint64_format='"'$glib_cv_long_long_format'i"'
3395     guint64_format='"'$glib_cv_long_long_format'u"'
3396   fi
3397   glib_extension=
3398   gint64_constant='(val##i64)'
3399   guint64_constant='(val##ui64)'
3400   ;;
3401 esac
3402 glib_size_t=$ac_cv_sizeof_size_t
3403 glib_size_type_define="$glib_size_type"
3404 glib_void_p=$ac_cv_sizeof_void_p
3405 glib_long=$ac_cv_sizeof_long
3406
3407 case "$glib_size_type" in
3408 short)
3409   gsize_modifier='"h"'
3410   gsize_format='"hu"'
3411   gssize_format='"hi"'
3412   glib_msize_type='SHRT'
3413   ;;
3414 int)
3415   gsize_modifier='""'
3416   gsize_format='"u"'
3417   gssize_format='"i"'
3418   glib_msize_type='INT'
3419   ;;
3420 long)
3421   gsize_modifier='"l"'
3422   gsize_format='"lu"'
3423   gssize_format='"li"'
3424   glib_msize_type='LONG'
3425   ;;
3426 "long long"|__int64)
3427   gsize_modifier='"I64"'
3428   gsize_format='"I64u"'
3429   gssize_format='"I64i"'
3430   glib_msize_type='INT64'
3431   ;;
3432 esac
3433
3434 gintbits=`expr $ac_cv_sizeof_int \* 8`
3435 glongbits=`expr $ac_cv_sizeof_long \* 8`
3436 gsizebits=`expr $ac_cv_sizeof_size_t \* 8`
3437
3438 case $ac_cv_sizeof_void_p in
3439 $ac_cv_sizeof_int)
3440   glib_intptr_type_define=int
3441   gintptr_modifier='""'
3442   gintptr_format='"i"'
3443   guintptr_format='"u"'
3444   glib_gpi_cast=''
3445   glib_gpui_cast=''
3446   ;;
3447 $ac_cv_sizeof_long)
3448   glib_intptr_type_define=long
3449   gintptr_modifier='"l"'
3450   gintptr_format='"li"'
3451   guintptr_format='"lu"'
3452   glib_gpi_cast='(glong)'
3453   glib_gpui_cast='(gulong)'
3454   ;;
3455 $ac_cv_sizeof_long_long)
3456   glib_intptr_type_define='long long'
3457   gintptr_modifier='"I64"'
3458   gintptr_format='"I64i"'
3459   guintptr_format='"I64u"'
3460   glib_gpi_cast='(gint64)'
3461   glib_gpui_cast='(guint64)'
3462   ;;
3463 $ac_cv_sizeof___int64)
3464   glib_intptr_type_define=__int64
3465   gintptr_modifier='"I64"'
3466   gintptr_format='"I64i"'
3467   guintptr_format='"I64u"'
3468   glib_gpi_cast='(gint64)'
3469   glib_gpui_cast='(guint64)'
3470   ;;
3471 *)
3472   glib_unknown_void_p=yes
3473   ;;
3474 esac
3475
3476
3477 case xyes in
3478 x$ac_cv_func_atexit)
3479   glib_atexit="
3480 #ifdef NeXT /* @#%@! NeXTStep */
3481 # define g_ATEXIT(proc) (!atexit (proc))
3482 #else
3483 # define g_ATEXIT(proc) (atexit (proc))
3484 #endif"
3485   ;;
3486 x$ac_cv_func_on_exit)
3487   glib_atexit="
3488 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
3489   ;;
3490 esac
3491
3492 case xyes in
3493 x$ac_cv_func_memmove)
3494   glib_memmove='
3495 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3496   ;;
3497 x$glib_cv_working_bcopy)
3498   glib_memmove="
3499 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3500 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3501   ;;
3502 *)
3503   glib_memmove="
3504 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3505  * so we have to roll our own copy routine. */
3506 void g_memmove (void* dest, const void * src, unsigned long len);"
3507   ;;
3508 esac
3509
3510 glib_defines="
3511 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3512 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3513 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3514 "
3515
3516 case xyes in
3517 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3518 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3519 *)                      glib_vacopy=''
3520 esac
3521
3522 if test x$glib_cv_va_val_copy = xno; then
3523   glib_vacopy="\$glib_vacopy
3524 #define G_VA_COPY_AS_ARRAY 1"
3525 fi
3526
3527 if test x$glib_cv_hasinline = xyes; then
3528     glib_inline='#define G_HAVE_INLINE 1'
3529 fi
3530 if test x$glib_cv_has__inline = xyes; then
3531     glib_inline="\$glib_inline
3532 #define G_HAVE___INLINE 1"
3533 fi
3534 if test x$glib_cv_has__inline__ = xyes; then
3535     glib_inline="\$glib_inline
3536 #define G_HAVE___INLINE__ 1"
3537 fi
3538
3539 g_have_gnuc_varargs=$g_have_gnuc_varargs
3540 g_have_iso_c_varargs=$g_have_iso_c_varargs
3541 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3542
3543 g_can_inline=$g_can_inline
3544 g_have_gnuc_visibility=$g_have_gnuc_visibility
3545 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3546
3547 if test x$ac_cv_c_bigendian = xyes; then
3548   g_byte_order=G_BIG_ENDIAN
3549   g_bs_native=BE
3550   g_bs_alien=LE
3551 else
3552   g_byte_order=G_LITTLE_ENDIAN
3553   g_bs_native=LE
3554   g_bs_alien=BE
3555 fi
3556
3557 g_pollin=$glib_cv_value_POLLIN
3558 g_pollout=$glib_cv_value_POLLOUT
3559 g_pollpri=$glib_cv_value_POLLPRI
3560 g_pollhup=$glib_cv_value_POLLHUP
3561 g_pollerr=$glib_cv_value_POLLERR
3562 g_pollnval=$glib_cv_value_POLLNVAL
3563
3564 g_af_unix=$glib_cv_value_AF_UNIX
3565 g_af_inet=$glib_cv_value_AF_INET
3566 g_af_inet6=$glib_cv_value_AF_INET6
3567
3568 g_msg_peek=$glib_cv_value_MSG_PEEK
3569 g_msg_oob=$glib_cv_value_MSG_OOB
3570 g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
3571
3572 g_stack_grows=$glib_cv_stack_grows
3573
3574 g_have_eilseq=$have_eilseq
3575
3576 case x$have_threads in
3577 xno)    g_enable_threads_def="#undef";;
3578 *)      g_enable_threads_def="#define";;
3579 esac
3580
3581 g_threads_impl_def=$g_threads_impl
3582
3583 g_mutex_has_default="$mutex_has_default"
3584 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3585 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3586 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3587
3588 g_memory_barrier_needed="$glib_memory_barrier_needed"
3589
3590 g_module_suffix="$glib_gmodule_suffix"
3591
3592 g_pid_type="$glib_pid_type"
3593 case $host in
3594   *-*-beos*)
3595     glib_os="#define G_OS_BEOS"
3596     ;;
3597   *-*-cygwin*)
3598     glib_os="#define G_OS_UNIX
3599 #define G_PLATFORM_WIN32
3600 #define G_WITH_CYGWIN"
3601     ;;
3602   *-*-mingw*)
3603     glib_os="#define G_OS_WIN32
3604 #define G_PLATFORM_WIN32"
3605     ;;
3606   *)
3607     glib_os="#define G_OS_UNIX"
3608     ;;
3609 esac
3610 glib_static_compilation=""
3611 if test x$glib_win32_static_compilation = xyes; then
3612   glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3613 #define GOBJECT_STATIC_COMPILATION 1"
3614 fi
3615 ])
3616
3617 # Check for libdbus1 - Optional - is only used in the GDBus test cases
3618 #
3619 # 1.2.14 required for dbus_message_set_serial
3620 PKG_CHECK_MODULES(DBUS1,
3621                   dbus-1 >= 1.2.14,
3622                   [AC_DEFINE(HAVE_DBUS1, 1, [Define if dbus-1 is available]) have_dbus1=yes],
3623                   have_dbus1=no)
3624 AC_SUBST(DBUS1_CFLAGS)
3625 AC_SUBST(DBUS1_LIBS)
3626 AM_CONDITIONAL(HAVE_DBUS1, [test "x$have_dbus1" = "xyes"])
3627
3628 dnl
3629 dnl Check for -Bsymbolic-functions linker flag used to avoid
3630 dnl intra-library PLT jumps, if available.
3631 dnl
3632
3633 AC_ARG_ENABLE(Bsymbolic,
3634               [AC_HELP_STRING([--disable-Bsymbolic],
3635                               [avoid linking with -Bsymbolic])],,
3636               [SAVED_LDFLAGS="${LDFLAGS}"
3637                AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
3638                LDFLAGS=-Wl,-Bsymbolic-functions
3639                AC_TRY_LINK([], [int main (void) { return 0; }],
3640                            AC_MSG_RESULT(yes)
3641                            enable_Bsymbolic=yes,
3642                            AC_MSG_RESULT(no)
3643                            enable_Bsymbolic=no)
3644                LDFLAGS="${SAVED_LDFLAGS}"])
3645
3646 if test "x${enable_Bsymbolic}" == "xyes"; then
3647   GLIB_LINK_FLAGS=-Wl,-Bsymbolic-functions
3648 fi
3649
3650 AC_SUBST(GLIB_LINK_FLAGS)
3651
3652 #
3653 # Define variables corresponding to the correct include paths to use for
3654 # in-tree building.
3655 #
3656
3657 # for config.h:
3658 config_h_INCLUDES='-I$(top_builddir)'
3659 AC_SUBST(config_h_INCLUDES)
3660
3661 # glib:
3662 #   config.h
3663 #   $(top_builddir)/glib: for glibconfig.h
3664 #   $(top_srcdir)/glib:   for glib.h
3665 #   $(top_srcdir):        for everything
3666 glib_INCLUDES='$(config_h_INCLUDES) -I$(top_builddir)/glib -I$(top_srcdir)/glib -I$(top_srcdir)'
3667 AC_SUBST(glib_INCLUDES)
3668
3669 # gthread:
3670 #   same as glib
3671 gthread_INCLUDES='$(glib_INCLUDES)'
3672 AC_SUBST(gthread_INCLUDES)
3673
3674 # gobject:
3675 #   same as gthread
3676 gobject_INCLUDES='$(gthread_INCLUDES)'
3677 AC_SUBST(gobject_INCLUDES)
3678
3679 # gmodule:
3680 #   glib includes
3681 #   $(top_srcdir)/gmodule: for gmodule.h
3682 gmodule_INCLUDES='$(glib_INCLUDES) -I$(top_srcdir)/gmodule'
3683 AC_SUBST(gmodule_INCLUDES)
3684
3685 # gio:
3686 #   same as gmodule
3687 gio_INCLUDES='$(gmodule_INCLUDES)'
3688 AC_SUBST(gio_INCLUDES)
3689
3690
3691 AC_CONFIG_FILES([
3692 glib-2.0.pc
3693 glib-2.0-uninstalled.pc
3694 gmodule-2.0.pc
3695 gmodule-export-2.0.pc
3696 gmodule-no-export-2.0.pc
3697 gmodule-2.0-uninstalled.pc
3698 gmodule-no-export-2.0-uninstalled.pc
3699 gthread-2.0.pc
3700 gthread-2.0-uninstalled.pc
3701 gobject-2.0.pc
3702 gobject-2.0-uninstalled.pc
3703 gio-2.0.pc
3704 gio-unix-2.0.pc
3705 gio-windows-2.0.pc
3706 gio-2.0-uninstalled.pc
3707 gio-unix-2.0-uninstalled.pc
3708 glib-zip
3709 glib-gettextize
3710 Makefile
3711 build/Makefile
3712 build/win32/Makefile
3713 build/win32/dirent/Makefile
3714 build/win32/vs9/Makefile
3715 glib/Makefile
3716 glib/glib.stp
3717 glib/libcharset/Makefile
3718 glib/gnulib/Makefile
3719 glib/pcre/Makefile
3720 glib/update-pcre/Makefile
3721 glib/tests/Makefile
3722 gmodule/Makefile
3723 gmodule/gmoduleconf.h
3724 gobject/Makefile
3725 gobject/gobject.stp
3726 gobject/glib-mkenums
3727 gobject/tests/Makefile
3728 gthread/Makefile
3729 gthread/tests/Makefile
3730 gio/Makefile
3731 gio/xdgmime/Makefile
3732 gio/inotify/Makefile
3733 gio/libasyncns/Makefile
3734 gio/fen/Makefile
3735 gio/fam/Makefile
3736 gio/win32/Makefile
3737 gio/tests/Makefile
3738 po/Makefile.in
3739 docs/Makefile
3740 docs/reference/Makefile
3741 docs/reference/glib/Makefile
3742 docs/reference/glib/version.xml
3743 docs/reference/gobject/Makefile
3744 docs/reference/gobject/version.xml
3745 docs/reference/gio/Makefile
3746 docs/reference/gio/version.xml
3747 tests/Makefile
3748 tests/gobject/Makefile
3749 tests/refcount/Makefile
3750 m4macros/Makefile
3751 ])
3752
3753 AC_CONFIG_COMMANDS([chmod-scripts],
3754 [chmod 0755 glib-zip
3755 chmod 0755 glib-gettextize
3756 chmod 0755 gobject/glib-mkenums])
3757
3758 # we want to invoke this macro solely so that the config.status script
3759 # and automake generated makefiles know about these generated files.
3760 # They are only needed to distcheck the package
3761 if false; then
3762   AC_CONFIG_FILES([
3763     INSTALL
3764     README
3765     config.h.win32
3766     glib/glibconfig.h.win32
3767     glib/makefile.msc
3768     glib/glib.rc
3769     gmodule/makefile.msc
3770     gmodule/gmodule.rc
3771     gobject/makefile.msc
3772     gobject/gobject.rc
3773     gthread/makefile.msc
3774     gthread/gthread.rc
3775     gio/gio.rc
3776     tests/makefile.msc
3777   ])
3778 fi
3779
3780 AC_OUTPUT