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