configure.in

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