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], [20])
  26 m4_define([glib_micro_version], [2])
  27 m4_define([glib_interface_age], [2])
  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/socket.h>
 965   "]
 966 fi
 967
 968 glib_failed=false
 969 GLIB_CHECK_VALUE(AF_INET, $glib_inet_includes, glib_failed=true)
 970 GLIB_CHECK_VALUE(AF_INET6, $glib_inet_includes, glib_failed=true)
 971 # winsock defines this even though it doesn't support it
 972 GLIB_CHECK_VALUE(AF_UNIX, $glib_inet_includes, glib_failed=true)
 973 if $glib_failed ; then
 974   AC_MSG_ERROR([Could not determine values for AF_INET* constants])
 975 fi
 976
 977 # For gio/libasyncns
 978 if test $glib_native_win32 = no; then
 979   AC_CHECK_FUNCS(strndup setresuid setreuid)
 980   AC_CHECK_HEADERS(sys/prctl.h arpa/nameser_compat.h)
 981   AC_CHECK_FUNC(res_query, ,
 982     [AC_CHECK_LIB(resolv, res_query, [ LIBASYNCNS_LIBADD="-lresolv" ],
 983       [ save_libs="$LIBS"
 984         LIBS="-lresolv $LIBS"
 985         AC_MSG_CHECKING([for res_query in -lresolv (alternate version)])
 986         AC_LINK_IFELSE(
 987           [AC_LANG_PROGRAM([[#include <resolv.h>]], [[res_query(0,0,0,0,0)]])],
 988           [ AC_MSG_RESULT(yes)
 989           LIBASYNCNS_LIBADD="-lresolv" ],
 990           [ AC_MSG_RESULT(no)
 991             AC_CHECK_LIB(bind, res_query,
 992               [ LIBASYNCNS_LIBADD="-lbind" ],
 993             [ AC_MSG_ERROR(res_query not found) ] ) ] )
 994         LIBS="$save_libs"
 995       ] )
 996     ]
 997   )
 998   AC_SUBST(LIBASYNCNS_LIBADD)
 999 fi
1000
1001 dnl
1002 dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
1003 dnl
1004 if test "$ac_cv_func_statfs" = yes ; then
1005   AC_MSG_CHECKING([number of arguments to statfs()])
1006   AC_TRY_COMPILE([#include <unistd.h>
1007   #ifdef HAVE_SYS_PARAM_H
1008   #include <sys/param.h>
1009   #endif
1010   #ifdef HAVE_SYS_VFS_H
1011   #include <sys/vfs.h>
1012   #endif
1013   #ifdef HAVE_SYS_MOUNT_H
1014   #include <sys/mount.h>
1015   #endif
1016   #ifdef HAVE_SYS_STATFS_H
1017   #include <sys/statfs.h>
1018   #endif], [struct statfs st;
1019   statfs(NULL, &st);],[
1020     AC_MSG_RESULT([2])
1021     AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
1022     AC_TRY_COMPILE([#include <unistd.h>
1023   #ifdef HAVE_SYS_PARAM_H
1024   #include <sys/param.h>
1025   #endif
1026   #ifdef HAVE_SYS_VFS_H
1027   #include <sys/vfs.h>
1028   #endif
1029   #ifdef HAVE_SYS_MOUNT_H
1030   #include <sys/mount.h>
1031   #endif
1032   #ifdef HAVE_SYS_STATFS_H
1033   #include <sys/statfs.h>
1034   #endif], [struct statfs st;
1035   statfs(NULL, &st, sizeof (st), 0);],[
1036       AC_MSG_RESULT([4])
1037       AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
1038       AC_MSG_RESULT(unknown)
1039       AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
1040 fi
1041
1042 #
1043 # Check whether to use an included printf
1044 #
1045
1046 AC_ARG_ENABLE(included-printf,
1047               [AC_HELP_STRING([--enable-included-printf],
1048                               [use included printf [default=auto]])],
1049               enable_included_printf="$enableval")
1050
1051 need_included_printf=no
1052 if test "x$enable_included_printf" = "xyes" ; then
1053   need_included_printf=yes
1054 fi
1055 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
1056   need_included_printf=yes
1057 fi
1058 if test "$ac_cv_func_printf_unix98" != "yes" ; then
1059   need_included_printf=yes
1060 fi
1061 if test "x$ac_cv_sizeof_long_long" = "x8" &&
1062    test -z "$glib_cv_long_long_format" ; then
1063   need_included_printf=yes
1064 fi
1065
1066 if test "x$enable_included_printf" = "xno" &&
1067    test "x$need_included_printf" = "xyes" ; then
1068   AC_MSG_ERROR([
1069 *** Your C library's printf doesn't appear to have the features that
1070 *** GLib needs, but you specified --enable-included-printf=no.])
1071 fi
1072
1073 enable_included_printf=$need_included_printf
1074
1075 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
1076 if test "$enable_included_printf" != "yes" ; then
1077   AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
1078 else
1079   if test -z "$glib_cv_long_long_format" ; then
1080     glib_cv_long_long_format="ll"
1081   fi
1082   AC_DEFINE(HAVE_VASPRINTF,1)
1083 fi
1084
1085 # Checks needed for gnulib vasnprintf
1086 bh_C_SIGNED
1087 jm_AC_TYPE_LONG_LONG
1088 gt_TYPE_LONGDOUBLE
1089 gt_TYPE_WCHAR_T
1090 gt_TYPE_WINT_T
1091 AC_TYPE_SIZE_T
1092 AC_CHECK_TYPES(ptrdiff_t)
1093 jm_AC_TYPE_INTMAX_T
1094 AC_CHECK_FUNCS([snprintf wcslen])
1095 AC_FUNC_SNPRINTF_C99
1096
1097 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
1098 # The check is borrowed from the PERL Configure script.
1099 if test "$ac_cv_func_memmove" != "yes"; then
1100   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
1101     glib_cv_working_bcopy,[AC_TRY_RUN([
1102       int main() {
1103         char buf[128], abc[128], *b;
1104         int len, off, align;
1105         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
1106         for (align = 7; align >= 0; align--) {
1107           for (len = 36; len; len--) {
1108             b = buf+align; bcopy(abc, b, len);
1109             for (off = 1; off <= len; off++) {
1110               bcopy(b, b+off, len); bcopy(b+off, b, len);
1111                 if (bcmp(b, abc, len)) return(1);
1112             }
1113           }
1114         }
1115         return(0);
1116       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
1117
1118   GLIB_ASSERT_SET(glib_cv_working_bcopy)
1119   if test "$glib_cv_working_bcopy" = "yes"; then
1120     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
1121   fi
1122 fi
1123
1124 # Check for sys_errlist
1125 AC_MSG_CHECKING(for sys_errlist)
1126 AC_TRY_LINK(, [
1127 extern char *sys_errlist[];
1128 extern int sys_nerr;
1129 sys_errlist[sys_nerr-1][0] = 0;
1130 ], glib_ok=yes, glib_ok=no)
1131 AC_MSG_RESULT($glib_ok)
1132 if test "$glib_ok" = "no"; then
1133     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
1134 fi
1135
1136 # Check for sys_siglist
1137 AC_MSG_CHECKING(for sys_siglist)
1138 AC_TRY_LINK(, [
1139 extern char *sys_siglist[];
1140 exit (sys_siglist[0]);
1141 ], glib_ok=yes, glib_ok=no)
1142 AC_MSG_RESULT($glib_ok)
1143 if test "$glib_ok" = "no"; then
1144     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
1145 fi
1146
1147 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
1148 AC_MSG_CHECKING(for sys_siglist declaration)
1149 AC_TRY_COMPILE([#include <signal.h>], [
1150 strlen (sys_siglist[0]);
1151 ], glib_ok=yes, glib_ok=no)
1152 AC_MSG_RESULT($glib_ok)
1153 if test "$glib_ok" = "no"; then
1154     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1155 fi
1156
1157 # Check if <sys/select.h> needs to be included for fd_set
1158 AC_MSG_CHECKING([for fd_set])
1159 AC_TRY_COMPILE([#include <sys/types.h>],
1160         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1161 if test "$gtk_ok" = "yes"; then
1162     AC_MSG_RESULT([yes, found in sys/types.h])
1163 else
1164     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1165     if test "$gtk_ok" = "yes"; then
1166         # *** FIXME: give it a different name
1167         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1168         AC_MSG_RESULT([yes, found in sys/select.h])
1169     else
1170         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1171         AC_MSG_RESULT(no)
1172     fi
1173 fi
1174
1175 dnl *** check for sane realloc() ***
1176 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1177         AC_TRY_RUN([#include <stdlib.h>
1178         int main() {
1179           return realloc (0, sizeof (int)) == 0;
1180         }],
1181         [glib_cv_sane_realloc=yes],
1182         [glib_cv_sane_realloc=no],
1183         [glib_cv_sane_realloc=yes])
1184 ])
1185 if test x$glib_cv_sane_realloc = xyes; then
1186   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1187 fi
1188
1189 dnl Check for nl_langinfo and CODESET
1190 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1191         AC_TRY_COMPILE([#include <langinfo.h>],
1192                 [char *codeset = nl_langinfo (CODESET);],
1193                 [glib_cv_langinfo_codeset=yes],
1194                 [glib_cv_langinfo_codeset=no])])
1195 if test x$glib_cv_langinfo_codeset = xyes; then
1196   AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1197 fi
1198
1199 dnl ****************************************
1200 dnl *** posix_memalign                   ***
1201 dnl ****************************************
1202 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1203 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1204     glib_cv_compliant_posix_memalign=0
1205     if test "$ac_cv_func_posix_memalign" = "yes" ; then
1206         AC_TRY_RUN([
1207                 #define _XOPEN_SOURCE 600
1208                 #include <stdlib.h> /* posix_memalign() should be defined here */
1209                 /* some systems break if #include <malloc.h> used */
1210                 static void test_memalign (size_t boundary, size_t size) {
1211                     void *mem = 0;
1212                     if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1213                         exit (1);
1214                     else
1215                       free (mem);
1216                 }
1217                 int main() {
1218                     test_memalign (  128,   128 - 2 * sizeof (void*));
1219                     test_memalign (  256,   256 - 2 * sizeof (void*));
1220                     test_memalign (  512,   512 - 2 * sizeof (void*));
1221                     test_memalign ( 1024,  1024 - 2 * sizeof (void*));
1222                     test_memalign ( 2048,  2048 - 2 * sizeof (void*));
1223                     test_memalign ( 4096,  4096 - 2 * sizeof (void*));
1224                     test_memalign ( 8192,  8192 - 2 * sizeof (void*));
1225                     test_memalign (16384, 16384 - 2 * sizeof (void*));
1226                     test_memalign (32768, 32768 - 2 * sizeof (void*));
1227                     exit (0); /* success */
1228                 }
1229                 ],
1230             [glib_cv_compliant_posix_memalign=1], [], [:])
1231       :
1232     fi
1233     ])
1234 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1235     AC_MSG_RESULT(yes)
1236     AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1237 else
1238     AC_MSG_RESULT(no)
1239 fi
1240
1241
1242 dnl ****************************************
1243 dnl *** strlcpy/strlcat                  ***
1244 dnl ****************************************
1245 # Check for strlcpy
1246 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1247 AC_TRY_RUN([#include <stdlib.h>
1248 #include <string.h>
1249 int main() {
1250   char p[10];
1251   (void) strlcpy (p, "hi", 10);
1252   if (strlcat (p, "bye", 0) != 3)
1253     return 1;
1254   return 0;
1255 }], glib_cv_have_strlcpy=yes,
1256     glib_cv_have_strlcpy=no,
1257     glib_cv_have_strlcpy=no)])
1258 if test "$glib_cv_have_strlcpy" = "yes"; then
1259     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1260 fi
1261
1262
1263 dnl **********************
1264 dnl *** va_copy checks ***
1265 dnl **********************
1266 dnl we currently check for all three va_copy possibilities, so we get
1267 dnl all results in config.log for bug reports.
1268 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1269         AC_LINK_IFELSE([#include <stdarg.h>
1270 #include <stdlib.h>
1271         void f (int i, ...) {
1272         va_list args1, args2;
1273         va_start (args1, i);
1274         va_copy (args2, args1);
1275         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1276           exit (1);
1277         va_end (args1); va_end (args2);
1278         }
1279         int main() {
1280           f (0, 42);
1281           return 0;
1282         }],
1283         [glib_cv_va_copy=yes],
1284         [glib_cv_va_copy=no])
1285 ])
1286 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1287         AC_LINK_IFELSE([#include <stdarg.h>
1288 #include <stdlib.h>
1289         void f (int i, ...) {
1290         va_list args1, args2;
1291         va_start (args1, i);
1292         __va_copy (args2, args1);
1293         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1294           exit (1);
1295         va_end (args1); va_end (args2);
1296         }
1297         int main() {
1298           f (0, 42);
1299           return 0;
1300         }],
1301         [glib_cv___va_copy=yes],
1302         [glib_cv___va_copy=no])
1303 ])
1304
1305 if test "x$glib_cv_va_copy" = "xyes"; then
1306   g_va_copy_func=va_copy
1307 else if test "x$glib_cv___va_copy" = "xyes"; then
1308   g_va_copy_func=__va_copy
1309 fi
1310 fi
1311
1312 if test -n "$g_va_copy_func"; then
1313   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1314 fi
1315
1316 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1317         AC_TRY_RUN([#include <stdarg.h>
1318 #include <stdlib.h>
1319         void f (int i, ...) {
1320         va_list args1, args2;
1321         va_start (args1, i);
1322         args2 = args1;
1323         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1324           exit (1);
1325         va_end (args1); va_end (args2);
1326         }
1327         int main() {
1328           f (0, 42);
1329           return 0;
1330         }],
1331         [glib_cv_va_val_copy=yes],
1332         [glib_cv_va_val_copy=no],
1333         [glib_cv_va_val_copy=yes])
1334 ])
1335
1336 if test "x$glib_cv_va_val_copy" = "xno"; then
1337   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1338 fi
1339
1340 dnl ***********************
1341 dnl *** g_module checks ***
1342 dnl ***********************
1343 G_MODULE_LIBS=
1344 G_MODULE_LIBS_EXTRA=
1345 G_MODULE_PLUGIN_LIBS=
1346 if test x"$glib_native_win32" = xyes; then
1347   dnl No use for this on Win32
1348   G_MODULE_LDFLAGS=
1349 else
1350   export SED
1351   G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1352 fi
1353 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1354 G_MODULE_NEED_USCORE=0
1355 G_MODULE_BROKEN_RTLD_GLOBAL=0
1356 G_MODULE_HAVE_DLERROR=0
1357 dnl *** force native WIN32 shared lib loader
1358 if test -z "$G_MODULE_IMPL"; then
1359   case "$host" in
1360   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1361   esac
1362 fi
1363 dnl *** force native AIX library loader
1364 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1365 if test -z "$G_MODULE_IMPL"; then
1366   case "$host" in
1367   *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1368   esac
1369 fi
1370 dnl *** dlopen() and dlsym() in system libraries
1371 if test -z "$G_MODULE_IMPL"; then
1372         AC_CHECK_FUNC(dlopen,
1373                       [AC_CHECK_FUNC(dlsym,
1374                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1375                       [])
1376 fi
1377 dnl *** load_image (BeOS)
1378 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1379   AC_CHECK_LIB(root, load_image,
1380       [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1381       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1382       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1383       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1384       [])
1385 fi
1386 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1387 if test -z "$G_MODULE_IMPL"; then
1388         AC_CHECK_FUNC(NSLinkModule,
1389                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1390                        G_MODULE_NEED_USCORE=1],
1391                       [])
1392 fi
1393 dnl *** dlopen() and dlsym() in libdl
1394 if test -z "$G_MODULE_IMPL"; then
1395         AC_CHECK_LIB(dl, dlopen,
1396                      [AC_CHECK_LIB(dl, dlsym,
1397                                    [G_MODULE_LIBS=-ldl
1398                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1399                      [])
1400 fi
1401 dnl *** shl_load() in libdld (HP-UX)
1402 if test -z "$G_MODULE_IMPL"; then
1403         AC_CHECK_LIB(dld, shl_load,
1404                 [G_MODULE_LIBS=-ldld
1405                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1406                 [])
1407 fi
1408 dnl *** additional checks for G_MODULE_IMPL_DL
1409 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1410         LIBS_orig="$LIBS"
1411         LDFLAGS_orig="$LDFLAGS"
1412         LIBS="$G_MODULE_LIBS $LIBS"
1413         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1414 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1415         echo "void glib_plugin_test(void) { }" > plugin.c
1416         ${SHELL} ./libtool --mode=compile ${CC} -shared \
1417                 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1418         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1419                 glib_cv_rtldglobal_broken,[
1420                 AC_TRY_RUN([
1421 #include <dlfcn.h>
1422 #ifndef RTLD_GLOBAL
1423 #  define RTLD_GLOBAL 0
1424 #endif
1425 #ifndef RTLD_LAZY
1426 #  define RTLD_LAZY 0
1427 #endif
1428 int glib_plugin_test;
1429 int main () {
1430     void *handle, *global, *local;
1431     global = &glib_plugin_test;
1432     handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1433     if (!handle) return 0;
1434     local = dlsym (handle, "glib_plugin_test");
1435     return global == local;
1436 }                       ],
1437                         [glib_cv_rtldglobal_broken=no],
1438                         [glib_cv_rtldglobal_broken=yes],
1439                         [glib_cv_rtldglobal_broken=no])
1440                 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1441                 rmdir .libs 2>/dev/null
1442         ])
1443         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1444                 G_MODULE_BROKEN_RTLD_GLOBAL=1
1445         else
1446                 G_MODULE_BROKEN_RTLD_GLOBAL=0
1447         fi
1448 dnl *** check whether we need preceeding underscores
1449         AC_CACHE_CHECK([for preceeding underscore in symbols],
1450                 glib_cv_uscore,[
1451                 AC_TRY_RUN([#include <dlfcn.h>
1452                 int glib_underscore_test (void) { return 42; }
1453                 int main() {
1454                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
1455                   handle = dlopen ((void*)0, 0);
1456                   if (handle) {
1457                     f1 = dlsym (handle, "glib_underscore_test");
1458                     f2 = dlsym (handle, "_glib_underscore_test");
1459                   } return (!f2 || f1);
1460                 }],
1461                         [glib_cv_uscore=yes],
1462                         [glib_cv_uscore=no],
1463                         [])
1464                 rm -f plugin.c plugin.$ac_objext plugin.lo
1465         ])
1466         GLIB_ASSERT_SET(glib_cv_uscore)
1467         if test "x$glib_cv_uscore" = "xyes"; then
1468                 G_MODULE_NEED_USCORE=1
1469         else
1470                 G_MODULE_NEED_USCORE=0
1471         fi
1472
1473         LDFLAGS="$LDFLAGS_orig"
1474 dnl *** check for having dlerror()
1475         AC_CHECK_FUNC(dlerror,
1476                 [G_MODULE_HAVE_DLERROR=1],
1477                 [G_MODULE_HAVE_DLERROR=0])
1478         LIBS="$LIBS_orig"
1479 fi
1480 dnl *** done, have we got an implementation?
1481 if test -z "$G_MODULE_IMPL"; then
1482         G_MODULE_IMPL=0
1483         G_MODULE_SUPPORTED=false
1484 else
1485         G_MODULE_SUPPORTED=true
1486 fi
1487
1488 AC_MSG_CHECKING(for the suffix of module shared libraries)
1489 export SED
1490 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1491 eval $shrext_cmds
1492 module=yes eval std_shrext=$shrext_cmds
1493 # chop the initial dot
1494 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1495 AC_MSG_RESULT(.$glib_gmodule_suffix)
1496 # any reason it may fail?
1497 if test "x$glib_gmodule_suffix" = x; then
1498         AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1499 fi
1500
1501 AC_SUBST(G_MODULE_SUPPORTED)
1502 AC_SUBST(G_MODULE_IMPL)
1503 AC_SUBST(G_MODULE_LIBS)
1504 AC_SUBST(G_MODULE_LIBS_EXTRA)
1505 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1506 AC_SUBST(G_MODULE_LDFLAGS)
1507 AC_SUBST(G_MODULE_HAVE_DLERROR)
1508 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1509 AC_SUBST(G_MODULE_NEED_USCORE)
1510 AC_SUBST(GLIB_DEBUG_FLAGS)
1511
1512 dnl **********************
1513 dnl *** g_spawn checks ***
1514 dnl **********************
1515
1516 AC_MSG_CHECKING(for gspawn implementation)
1517 case "$host" in
1518   *-*-mingw*)
1519     GSPAWN=gspawn-win32.lo
1520     ;;
1521   *)
1522     GSPAWN=gspawn.lo
1523     ;;
1524 esac
1525 AC_MSG_RESULT($GSPAWN)
1526 AC_SUBST(GSPAWN)
1527
1528 dnl *************************
1529 dnl *** GIOChannel checks ***
1530 dnl *************************
1531
1532 AC_MSG_CHECKING(for GIOChannel implementation)
1533 case "$host" in
1534   *-*-mingw*)
1535     GIO=giowin32.lo
1536     ;;
1537   *)
1538     GIO=giounix.lo
1539     ;;
1540 esac
1541 AC_MSG_RESULT($GIO)
1542 AC_SUBST(GIO)
1543
1544 dnl *********************************
1545 dnl *** Directory for GIO modules ***
1546 dnl *********************************
1547
1548 AC_ARG_WITH(gio-module-dir,
1549            [AC_HELP_STRING([--with-gio-module-dir=PATH],
1550                            [Load gio modules from this directory [LIBDIR/gio/modules]])],
1551            [],
1552            [with_gio_module_dir='${libdir}/gio/modules'])
1553 GIO_MODULE_DIR=$with_gio_module_dir
1554 AC_SUBST(GIO_MODULE_DIR)
1555
1556 dnl **********************************
1557 dnl *** Check for libselinux (GIO) ***
1558 dnl **********************************
1559 AC_ARG_ENABLE(selinux, [  --disable-selinux       build without selinux support])
1560 msg_selinux=no
1561 SELINUX_LIBS=
1562 if test "x$enable_selinux" != "xno"; then
1563
1564  AC_CHECK_LIB(selinux, is_selinux_enabled,
1565    [AC_CHECK_HEADERS(selinux/selinux.h,
1566      [AC_CHECK_LIB(selinux, lgetfilecon_raw,
1567        [AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
1568         SELINUX_LIBS="-lselinux"
1569         msg_selinux=yes])
1570      ])
1571    ])
1572 fi
1573 AC_SUBST(SELINUX_LIBS)
1574
1575 dnl *****************************
1576 dnl ** Check for inotify (GIO) **
1577 dnl *****************************
1578 inotify_support=no
1579 AC_CHECK_HEADERS([sys/inotify.h],
1580 [
1581         inotify_support=yes
1582 ])
1583
1584 AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
1585
1586 dnl *********************************
1587 dnl ** Check for Solaris FEN (GIO) **
1588 dnl *********************************
1589 fen_support=no
1590 AC_COMPILE_IFELSE([
1591 #include <port.h>
1592 #ifndef PORT_SOURCE_FILE
1593 #error "Please upgrade to Nevada 72 or above to suppoert FEN"
1594 #endif
1595 int main() { return 0; } ],
1596 [
1597         fen_support=yes
1598 ],)
1599
1600 AM_CONDITIONAL(HAVE_FEN, [test "$fen_support" = "yes"])
1601
1602 dnl ****************************
1603 dnl *** Checks for FAM (GIO) ***
1604 dnl ****************************
1605
1606 should_disable_fam=no
1607
1608 AC_ARG_ENABLE(fam, [  --disable-fam          build without enabling fam for file system monitoring],
1609                          [
1610                                 if test "x$enable_fam" = "xno"; then
1611                                         should_disable_fam=yes
1612                                         echo "Not building FAM support"
1613                                 fi
1614                          ]
1615                          )
1616 fam_support=no
1617 FAM_LIBS=
1618 if test "x$should_disable_fam" = "xno"; then
1619 AC_CHECK_LIB(fam, FAMOpen,
1620   [AC_CHECK_HEADERS(fam.h,
1621     [AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
1622      AC_CHECK_LIB(fam, FAMNoExists,
1623                   AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
1624      FAM_LIBS="-lfam"]
1625      fam_support=yes,
1626     AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
1627   AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
1628 AC_SUBST(FAM_LIBS)
1629 fi
1630 AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
1631
1632
1633 dnl *****************************
1634 dnl *** Check for xattr (GIO) ***
1635 dnl *****************************
1636 AC_ARG_ENABLE(xattr, [  --disable-xattr           build without xattr support])
1637 msg_xattr=no
1638 XATTR_LIBS=
1639 if test "x$enable_xattr" != "xno"; then
1640
1641 dnl either glibc or libattr can provide xattr support
1642
1643 dnl for both of them, we check for getxattr being in
1644 dnl the library and a valid xattr header.
1645
1646 dnl try glibc
1647  AC_CHECK_LIB(c, getxattr,
1648    [AC_CHECK_HEADERS(sys/xattr.h,
1649      [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1650       msg_xattr=yes])
1651    ])
1652
1653   if test "x$msg_xattr" != "xyes"; then
1654 dnl   failure. try libattr
1655    AC_CHECK_LIB(attr, getxattr,
1656       [AC_CHECK_HEADERS(attr/xattr.h,
1657        [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1658         XATTR_LIBS="-lattr"
1659         msg_xattr=yes])
1660       ])
1661   fi
1662
1663   if test "x$msg_xattr" = "xyes"; then
1664     AC_MSG_CHECKING([for XATTR_NOFOLLOW])
1665     AC_TRY_COMPILE([
1666       #include <stdio.h>
1667       #ifdef HAVE_SYS_TYPES_H
1668       #include <sys/types.h>
1669       #endif
1670       #ifdef HAVE_SYS_XATTR_H
1671       #include <sys/xattr.h>
1672       #elif HAVE_ATTR_XATTR_H
1673       #include <attr/xattr.h>
1674       #endif
1675     ],
1676     [ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
1677     [
1678       AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
1679       AC_MSG_RESULT([yes])
1680     ],
1681     [AC_MSG_RESULT([no])]
1682     )
1683   fi
1684
1685 fi
1686 AC_SUBST(XATTR_LIBS)
1687
1688 dnl ****************************************
1689 dnl *** platform dependent source checks ***
1690 dnl ****************************************
1691
1692 AC_MSG_CHECKING(for platform-dependent source)
1693 case "$host" in
1694   *-*-cygwin*|*-*-mingw*)
1695     PLATFORMDEP=gwin32.lo
1696     ;;
1697   *)
1698     PLATFORMDEP=
1699     ;;
1700 esac
1701 AC_MSG_RESULT($PLATFORMDEP)
1702 AC_SUBST(PLATFORMDEP)
1703
1704 AC_MSG_CHECKING([whether to compile timeloop])
1705 case "$host" in
1706   *-*-cygwin*|*-*-mingw*|*-*-minix)
1707     enable_timeloop=no
1708     ;;
1709   *)
1710     enable_timeloop=yes
1711     ;;
1712 esac
1713 AC_MSG_RESULT($enable_timeloop)
1714 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1715
1716 AC_MSG_CHECKING([if building for some Win32 platform])
1717 case "$host" in
1718   *-*-mingw*|*-*-cygwin*)
1719     platform_win32=yes
1720     ;;
1721   *)
1722     platform_win32=no
1723     ;;
1724 esac
1725 AC_MSG_RESULT($platform_win32)
1726 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1727
1728 dnl ***********************
1729 dnl *** g_thread checks ***
1730 dnl ***********************
1731
1732 AC_ARG_WITH(threads,
1733            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1734                            [specify a thread implementation to use])],
1735            [if test "x$with_threads" = x; then
1736                 want_threads=yes
1737             else
1738                 want_threads=$with_threads
1739             fi],
1740            [want_threads=yes])
1741 if test "x$enable_threads" = "xno"; then
1742         want_threads=no
1743 fi
1744
1745 dnl error and warning message
1746 dnl *************************
1747
1748 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1749                 computer. GLib will not have a default thread implementation."
1750
1751 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1752                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1753                 compilation now, but then your programs might not work.
1754                 Please provide information on how it is done on your system."
1755
1756 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1757                 "
1758
1759 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1760                 provide information on your thread implementation.
1761                 You can also run 'configure --disable-threads'
1762                 to compile without thread support."
1763
1764 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1765                 functions will not be MT-safe during their first call because
1766                 there is no working 'getpwuid_r' on your system."
1767
1768 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1769                 because there is no 'localtime_r' on your system."
1770
1771 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1772                 crude surrogate will be used. If you happen to know a
1773                 yield function for your system, please inform the GLib
1774                 developers."
1775
1776 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1777                 threads on your system. Thus threads can only have the default
1778                 priority. If you happen to know these main/max
1779                 priorities, please inform the GLib developers."
1780
1781 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1782                 linking threaded applications. As GLib cannot do that
1783                 automatically, you will get an linkg error everytime you are
1784                 not using the right compiler. In that case you have to relink
1785                 with the right compiler. Ususally just '_r' is appended
1786                 to the compiler name."
1787
1788 dnl determination of thread implementation
1789 dnl ***************************************
1790
1791 # have_threads=no   means no thread support
1792 # have_threads=none means no default thread implementation
1793
1794 have_threads=no
1795 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1796                                 || test "x$want_threads" = xdce; then
1797         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1798         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1799         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1800         glib_save_CPPFLAGS="$CPPFLAGS"
1801         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1802         if test "x$have_threads" = xno; then
1803                 AC_TRY_COMPILE([#include <pthread.h>],
1804                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1805                         have_threads=posix)
1806         fi
1807         if test "x$have_threads" = xno; then
1808                 AC_TRY_COMPILE([#include <pthread.h>],
1809                         [pthread_mutex_t m;
1810                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1811                         have_threads=dce)
1812         fi
1813         # Tru64Unix requires -pthread to find pthread.h. See #103020
1814         CPPFLAGS="$CPPFLAGS -pthread"
1815         if test "x$have_threads" = xno; then
1816         AC_TRY_COMPILE([#include <pthread.h>],
1817                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1818                        have_threads=posix)
1819         fi
1820         CPPFLAGS="$glib_save_CPPFLAGS"
1821 fi
1822 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1823         case $host in
1824                 *-*-mingw*)
1825                 have_threads=win32
1826                 ;;
1827         esac
1828 fi
1829 if test "x$want_threads" = xnone; then
1830         have_threads=none
1831 fi
1832
1833 AC_MSG_CHECKING(for thread implementation)
1834
1835 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1836         AC_MSG_RESULT(none available)
1837         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1838 else
1839         AC_MSG_RESULT($have_threads)
1840 fi
1841
1842
1843 dnl determination of G_THREAD_CFLAGS
1844 dnl ********************************
1845
1846 G_THREAD_LIBS=
1847 G_THREAD_LIBS_EXTRA=
1848 G_THREAD_CFLAGS=
1849
1850 dnl
1851 dnl Test program for basic POSIX threads functionality
1852 dnl
1853 m4_define([glib_thread_test],[
1854 #include <pthread.h>
1855 int check_me = 0;
1856 void* func(void* data) {check_me = 42; return &check_me;}
1857 int main()
1858  { pthread_t t;
1859    void *ret;
1860    pthread_create (&t, $1, func, 0);
1861    pthread_join (t, &ret);
1862    return (check_me != 42 || ret != &check_me);
1863 }])
1864
1865 dnl
1866 dnl Test program for sched_get_priority_min()
1867 dnl
1868 m4_define([glib_sched_priority_test],[
1869 #include <sched.h>
1870 #include <errno.h>
1871 int main() {
1872     errno = 0;
1873     return sched_get_priority_min(SCHED_OTHER)==-1
1874            && errno != 0;
1875 }])
1876
1877 if test x"$have_threads" != xno; then
1878
1879   if test x"$have_threads" = xposix; then
1880     # First we test for posix, whether -pthread or -pthreads do the trick as
1881     # both CPPFLAG and LIBS.
1882     # One of them does for most gcc versions and some other platforms/compilers
1883     # too and could be considered as the canonical way to go.
1884     case $host in
1885       *-*-cygwin*|*-*-darwin*)
1886          # skip cygwin and darwin -pthread or -pthreads test
1887          ;;
1888       *-solaris*)
1889         # These compiler/linker flags work with both Sun Studio and gcc
1890         # Sun Studio expands -mt to -D_REENTRANT and -lthread
1891         # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1892         G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1893         G_THREAD_LIBS="-lpthread -lthread"
1894         ;;
1895       *)
1896         for flag in pthread pthreads mt; do
1897           glib_save_CFLAGS="$CFLAGS"
1898           CFLAGS="$CFLAGS -$flag"
1899           AC_TRY_RUN(glib_thread_test(0),
1900                      glib_flag_works=yes,
1901                      glib_flag_works=no,
1902                      [AC_LINK_IFELSE(glib_thread_test(0),
1903                                      glib_flag_works=yes,
1904                                      glib_flag_works=no)])
1905           CFLAGS="$glib_save_CFLAGS"
1906           if test $glib_flag_works = yes ; then
1907              G_THREAD_CFLAGS=-$flag
1908              G_THREAD_LIBS=-$flag
1909              break;
1910           fi
1911         done
1912          ;;
1913     esac
1914   fi
1915
1916   if test x"$G_THREAD_CFLAGS" = x; then
1917
1918     # The canonical -pthread[s] does not work. Try something different.
1919
1920     case $host in
1921         *-aix*)
1922                 if test x"$GCC" = xyes; then
1923                         # GCC 3.0 and above needs -pthread.
1924                         # Should be coverd by the case above.
1925                         # GCC 2.x and below needs -mthreads
1926                         G_THREAD_CFLAGS="-mthreads"
1927                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1928                 else
1929                         # We are probably using the aix compiler. Normaly a
1930                         # program would have to be compiled with the _r variant
1931                         # of the corresponding compiler, but we as GLib cannot
1932                         # do that: but the good news is that for compiling the
1933                         # only difference is the added -D_THREAD_SAFE compile
1934                         # option. This is according to the "C for AIX User's
1935                         # Guide".
1936                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1937                 fi
1938                 ;;
1939         *-dg-dgux*)  # DG/UX
1940                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1941                 ;;
1942         *-osf*)
1943                 # So we are using dce threads. posix threads are already
1944                 # catched above.
1945                 G_THREAD_CFLAGS="-threads"
1946                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1947                 ;;
1948         *-sysv5uw7*) # UnixWare 7
1949                 # We are not using gcc with -pthread. Catched above.
1950                 G_THREAD_CFLAGS="-Kthread"
1951                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1952                 ;;
1953         *-mingw*)
1954                 # No flag needed when using MSVCRT.DLL
1955                 G_THREAD_CFLAGS=""
1956                 ;;
1957         *)
1958                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1959                 ;;
1960     esac
1961
1962   fi
1963
1964     # if we are not finding the localtime_r function, then we probably are
1965     # not using the proper multithread flag
1966
1967     glib_save_CPPFLAGS="$CPPFLAGS"
1968     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1969
1970     # First we test, whether localtime_r is declared in time.h
1971     # directly. Then we test whether a macro localtime_r exists, in
1972     # which case localtime_r in the test program is replaced and thus
1973     # if we still find localtime_r in the output, it is not defined as
1974     # a macro.
1975
1976     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1977       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1978                                                            localtime_r(a,b)],
1979                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1980
1981     CPPFLAGS="$glib_save_CPPFLAGS"
1982
1983     AC_MSG_CHECKING(thread related cflags)
1984     AC_MSG_RESULT($G_THREAD_CFLAGS)
1985     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1986 fi
1987
1988 dnl determination of G_THREAD_LIBS
1989 dnl ******************************
1990
1991 mutex_has_default=no
1992 case $have_threads in
1993         posix|dce)
1994           glib_save_CPPFLAGS="$CPPFLAGS"
1995           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1996           if test x"$G_THREAD_LIBS" = x; then
1997             case $host in
1998               *-aix*)
1999                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
2000                 # probably using the aix compiler.
2001                 AC_MSG_WARN($AIX_COMPILE_INFO)
2002                 ;;
2003               *)
2004                 G_THREAD_LIBS=error
2005                 glib_save_LIBS="$LIBS"
2006                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
2007                         if test x"$thread_lib" = x; then
2008                                 add_thread_lib=""
2009                                 IN=""
2010                         else
2011                                 add_thread_lib="-l$thread_lib"
2012                                 IN=" in -l$thread_lib"
2013                         fi
2014                         if test x"$have_threads" = xposix; then
2015                                 defattr=0
2016                         else
2017                                 defattr=pthread_attr_default
2018                         fi
2019
2020                         LIBS="$add_thread_lib $glib_save_LIBS"
2021
2022                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
2023                         AC_TRY_RUN(glib_thread_test($defattr),
2024                                    glib_result=yes,
2025                                    glib_result=no,
2026                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
2027                                                    glib_result=yes,
2028                                                    glib_result=no)])
2029                         AC_MSG_RESULT($glib_result)
2030
2031                         if test "$glib_result" = "yes" ; then
2032                           G_THREAD_LIBS="$add_thread_lib"
2033                           break
2034                         fi
2035                 done
2036                 if test "x$G_THREAD_LIBS" = xerror; then
2037                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2038                 fi
2039                 LIBS="$glib_save_LIBS"
2040                 ;;
2041             esac
2042           fi
2043
2044           glib_save_LIBS="$LIBS"
2045           for thread_lib in "" rt rte; do
2046             if test x"$thread_lib" = x; then
2047               add_thread_lib=""
2048               IN=""
2049             else
2050               add_thread_lib="-l$thread_lib"
2051               IN=" in -l$thread_lib"
2052             fi
2053             LIBS="$add_thread_lib $glib_save_LIBS"
2054
2055             AC_MSG_CHECKING(for sched_get_priority_min$IN)
2056             AC_TRY_RUN(glib_sched_priority_test,
2057                        glib_result=yes,
2058                        glib_result=no,
2059                        [AC_LINK_IFELSE(glib_sched_priority_test,
2060                                        glib_result=yes,
2061                                        glib_result=no)])
2062             AC_MSG_RESULT($glib_result)
2063
2064             if test "$glib_result" = "yes" ; then
2065                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
2066                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
2067                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
2068                break
2069             fi
2070           done
2071           LIBS="$glib_save_LIBS"
2072           mutex_has_default=yes
2073           mutex_default_type='pthread_mutex_t'
2074           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
2075           mutex_header_file='pthread.h'
2076           if test "x$have_threads" = "xposix"; then
2077             g_threads_impl="POSIX"
2078           else
2079             g_threads_impl="DCE"
2080             have_threads="posix"
2081           fi
2082           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
2083           CPPFLAGS="$glib_save_CPPFLAGS"
2084           ;;
2085         win32)
2086            g_threads_impl="WIN32"
2087            ;;
2088         none|no)
2089            g_threads_impl="NONE"
2090            ;;
2091         *)
2092            g_threads_impl="NONE"
2093            G_THREAD_LIBS=error
2094            ;;
2095 esac
2096
2097 if test "x$G_THREAD_LIBS" = xerror; then
2098         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2099 fi
2100
2101 case $host in
2102   *-*-beos*)
2103     G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
2104     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
2105     ;;
2106   *)
2107     ;;
2108 esac
2109
2110 AC_MSG_CHECKING(thread related libraries)
2111 AC_MSG_RESULT($G_THREAD_LIBS)
2112
2113 dnl check for mt safe function variants and some posix functions
2114 dnl ************************************************************
2115
2116 if test x"$have_threads" != xno; then
2117         glib_save_LIBS="$LIBS"
2118         # we are not doing the following for now, as this might require glib
2119         # to always be linked with the thread libs on some platforms.
2120         # LIBS="$LIBS $G_THREAD_LIBS"
2121         AC_CHECK_FUNCS(localtime_r gmtime_r)
2122         if test "$ac_cv_header_pwd_h" = "yes"; then
2123                 AC_CACHE_CHECK([for posix getpwuid_r],
2124                         ac_cv_func_posix_getpwuid_r,
2125                         [AC_TRY_RUN([
2126 #include <errno.h>
2127 #include <pwd.h>
2128 int main () {
2129     char buffer[10000];
2130     struct passwd pwd, *pwptr = &pwd;
2131     int error;
2132     errno = 0;
2133     error = getpwuid_r (0, &pwd, buffer,
2134                         sizeof (buffer), &pwptr);
2135    return (error < 0 && errno == ENOSYS)
2136            || error == ENOSYS;
2137 }                               ],
2138                                 [ac_cv_func_posix_getpwuid_r=yes],
2139                                 [ac_cv_func_posix_getpwuid_r=no])])
2140                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
2141                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
2142                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
2143                                 [Have POSIX function getpwuid_r])
2144                 else
2145                         AC_CACHE_CHECK([for nonposix getpwuid_r],
2146                                 ac_cv_func_nonposix_getpwuid_r,
2147                                 [AC_TRY_LINK([#include <pwd.h>],
2148                                         [char buffer[10000];
2149                                         struct passwd pwd;
2150                                         getpwuid_r (0, &pwd, buffer,
2151                                                         sizeof (buffer));],
2152                                         [ac_cv_func_nonposix_getpwuid_r=yes],
2153                                         [ac_cv_func_nonposix_getpwuid_r=no])])
2154                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
2155                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
2156                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
2157                                         [Have non-POSIX function getpwuid_r])
2158                         fi
2159                 fi
2160         fi
2161         if test "$ac_cv_header_grp_h" = "yes"; then
2162                 AC_CACHE_CHECK([for posix getgrgid_r],
2163                         ac_cv_func_posix_getgrgid_r,
2164                         [AC_TRY_RUN([
2165 #include <errno.h>
2166 #include <grp.h>
2167 int main () {
2168     char buffer[10000];
2169     struct group grp, *grpptr = &grp;
2170     int error;
2171     errno = 0;
2172     error = getgrgid_r (0, &grp, buffer,
2173                         sizeof (buffer), &grpptr);
2174    return (error < 0 && errno == ENOSYS)
2175            || error == ENOSYS;
2176 }                              ],
2177                                [ac_cv_func_posix_getgrgid_r=yes],
2178                                [ac_cv_func_posix_getgrgid_r=no])])
2179                 GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
2180                 if test "$ac_cv_func_posix_getgrgid_r" = yes; then
2181                         AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
2182                                 [Have POSIX function getgrgid_r])
2183                 else
2184                         AC_CACHE_CHECK([for nonposix getgrgid_r],
2185                                 ac_cv_func_nonposix_getgrgid_r,
2186                                 [AC_TRY_LINK([#include <grp.h>],
2187                                         [char buffer[10000];
2188                                         struct group grp;
2189                                         getgrgid_r (0, &grp, buffer,
2190                                         sizeof (buffer));],
2191                                 [ac_cv_func_nonposix_getgrgid_r=yes],
2192                                 [ac_cv_func_nonposix_getgrgid_r=no])])
2193                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
2194                         if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
2195                                 AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
2196                                         [Have non-POSIX function getgrgid_r])
2197                         fi
2198                 fi
2199         fi
2200         LIBS="$G_THREAD_LIBS $LIBS"
2201         if test x"$have_threads" = xposix; then
2202                 glib_save_CPPFLAGS="$CPPFLAGS"
2203                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2204                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
2205                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
2206                 # This is not AC_CHECK_FUNC to also work with function
2207                 # name mangling in header files.
2208                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
2209                 AC_TRY_LINK([#include <pthread.h>],
2210                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
2211                         [AC_MSG_RESULT(yes)
2212                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
2213                                   [Have function pthread_attr_setstacksize])],
2214                         [AC_MSG_RESULT(no)])
2215                 AC_MSG_CHECKING(for minimal/maximal thread priority)
2216                 if test x"$posix_priority_min" = x; then
2217                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
2218                                 PX_PRIO_MIN],,[
2219                                 posix_priority_min=PX_PRIO_MIN
2220                                 posix_priority_max=PX_PRIO_MAX])
2221                 fi
2222                 if test x"$posix_priority_min" = x; then
2223                         # AIX
2224                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
2225                                 PTHREAD_PRIO_MIN],,[
2226                                 posix_priority_min=PTHREAD_PRIO_MIN
2227                                 posix_priority_max=PTHREAD_PRIO_MAX])
2228                 fi
2229                 if test x"$posix_priority_min" = x; then
2230                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
2231                                 PRI_OTHER_MIN],,[
2232                                 posix_priority_min=PRI_OTHER_MIN
2233                                 posix_priority_max=PRI_OTHER_MAX])
2234                 fi
2235                 if test x"$posix_priority_min" = x; then
2236                         AC_MSG_RESULT(none found)
2237                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
2238                         posix_priority_min=-1
2239                         posix_priority_max=-1
2240                 else
2241                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
2242                         AC_MSG_CHECKING(for pthread_setschedparam)
2243                         AC_TRY_LINK([#include <pthread.h>],
2244                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
2245                           [AC_MSG_RESULT(yes)
2246                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
2247                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
2248                           [AC_MSG_RESULT(no)
2249                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
2250                 fi
2251                 posix_yield_func=none
2252                 AC_MSG_CHECKING(for posix yield function)
2253                 for yield_func in sched_yield pthread_yield_np pthread_yield \
2254                                                         thr_yield; do
2255                         AC_TRY_LINK([#include <pthread.h>],
2256                                 [$yield_func()],
2257                                 [posix_yield_func="$yield_func"
2258                                 break])
2259                 done
2260                 if test x"$posix_yield_func" = xnone; then
2261                         AC_MSG_RESULT(none found)
2262                         AC_MSG_WARN($POSIX_NO_YIELD)
2263                         posix_yield_func="g_usleep(1000)"
2264                 else
2265                         AC_MSG_RESULT($posix_yield_func)
2266                         posix_yield_func="$posix_yield_func()"
2267                 fi
2268                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
2269                 CPPFLAGS="$glib_save_CPPFLAGS"
2270
2271         elif test x"$have_threads" = xwin32; then
2272                 # It's a pointer to a private struct
2273                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
2274         fi
2275
2276         LIBS="$glib_save_LIBS"
2277
2278         # now spit out all the warnings.
2279         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
2280            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
2281                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
2282         fi
2283         if test "$ac_cv_func_localtime_r" != "yes"; then
2284                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
2285         fi
2286 fi
2287
2288 if test x"$glib_cv_sizeof_system_thread" = x; then
2289    # use a pointer as a fallback.
2290    GLIB_SIZEOF(,void *, system_thread)
2291 fi
2292
2293 #
2294 # Hack to deal with:
2295 #
2296 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
2297 #     building shared libraries with linux.
2298 #  b) FreeBSD doesn't do this either.
2299 #
2300 case $host in
2301   *-*-freebsd*|*-*-linux*)
2302     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
2303     ;;
2304   *)
2305     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2306     ;;
2307 esac
2308
2309 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
2310                    [Source file containing theread implementation])
2311 AC_SUBST(G_THREAD_CFLAGS)
2312 AC_SUBST(G_THREAD_LIBS)
2313 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2314 AC_SUBST(G_THREAD_LIBS_EXTRA)
2315
2316 dnl **********************************************
2317 dnl *** GDefaultMutex setup and initialization ***
2318 dnl **********************************************
2319 dnl
2320 dnl if mutex_has_default = yes, we also got
2321 dnl mutex_default_type, mutex_default_init and mutex_header_file
2322 if test $mutex_has_default = yes ; then
2323         glib_save_CPPFLAGS="$CPPFLAGS"
2324         glib_save_LIBS="$LIBS"
2325         LIBS="$G_THREAD_LIBS $LIBS"
2326         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2327         GLIB_SIZEOF([#include <$mutex_header_file>],
2328                     $mutex_default_type,
2329                     gmutex)
2330         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
2331                            $mutex_default_type,
2332                            gmutex,
2333                            $glib_cv_sizeof_gmutex,
2334                            $mutex_default_init)
2335         if test x"$glib_cv_byte_contents_gmutex" = xno; then
2336                 mutex_has_default=no
2337         fi
2338         CPPFLAGS="$glib_save_CPPFLAGS"
2339         LIBS="$glib_save_LIBS"
2340 fi
2341
2342 AC_CHECK_FUNCS(clock_gettime, [], [
2343   AC_CHECK_LIB(rt, clock_gettime, [
2344     AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2345     G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2346     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2347   ])
2348 ])
2349
2350 AC_CACHE_CHECK(for monotonic clocks,
2351     glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2352 #include <time.h>
2353 #include <unistd.h>
2354 int main() {
2355 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2356         #error No monotonic clock
2357 #endif
2358         return 0;
2359 }
2360 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2361 if test "$glib_cv_monotonic_clock" = "yes"; then
2362   AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2363 fi
2364
2365
2366 dnl ********************************
2367 dnl *** g_atomic_* tests for gcc ***
2368 dnl ********************************
2369
2370 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2371
2372 if test x"$GCC" = xyes; then
2373   case $host_cpu in
2374     i386)
2375       AC_MSG_RESULT([none])
2376       glib_memory_barrier_needed=no
2377       ;;
2378     i?86)
2379       AC_MSG_RESULT([i486])
2380       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2381                          [i486 atomic implementation])
2382       glib_memory_barrier_needed=no
2383       ;;
2384     sparc*)
2385       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2386                 when you are using a sparc with v9 instruction set (most
2387                 sparcs nowadays). This will make the code for atomic
2388                 operations much faster. The resulting code will not run
2389                 on very old sparcs though."
2390
2391       AC_LINK_IFELSE([[
2392         main ()
2393         {
2394           int tmp1, tmp2, tmp3;
2395           __asm__ __volatile__("casx [%2], %0, %1"
2396                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2397         }]],
2398         AC_MSG_RESULT([sparcv9])
2399         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2400                            [sparcv9 atomic implementation]),
2401         AC_MSG_RESULT([no])
2402         AC_MSG_WARN([[$SPARCV9_WARNING]]))
2403       glib_memory_barrier_needed=yes
2404       ;;
2405     alpha*)
2406       AC_MSG_RESULT([alpha])
2407       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2408                          [alpha atomic implementation])
2409       glib_memory_barrier_needed=yes
2410       ;;
2411     x86_64)
2412       AC_MSG_RESULT([x86_64])
2413       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2414                          [x86_64 atomic implementation])
2415       glib_memory_barrier_needed=no
2416      ;;
2417     powerpc*)
2418       AC_MSG_RESULT([powerpc])
2419       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2420                          [powerpc atomic implementation])
2421       glib_memory_barrier_needed=yes
2422       AC_MSG_CHECKING([whether asm supports numbered local labels])
2423       AC_TRY_COMPILE(
2424                 ,[
2425                         __asm__ __volatile__ ("1:       nop\n"
2426                                               "         bne-    1b")
2427                 ],[
2428                         AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2429                         AC_MSG_RESULT([yes])
2430                 ],[
2431                         AC_MSG_RESULT([no])
2432                 ])
2433       ;;
2434     ia64)
2435       AC_MSG_RESULT([ia64])
2436       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2437                          [ia64 atomic implementation])
2438       glib_memory_barrier_needed=yes
2439       ;;
2440     s390|s390x)
2441       AC_MSG_RESULT([s390])
2442       AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2443                          [s390 atomic implementation])
2444       glib_memory_barrier_needed=no
2445       ;;
2446     arm*)
2447       AC_MSG_RESULT([arm])
2448       AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2449                          [arm atomic implementation])
2450       glib_memory_barrier_needed=no
2451       ;;
2452     crisv32*|etraxfs*)
2453       AC_MSG_RESULT([crisv32])
2454       AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
2455                          [crisv32 atomic implementation])
2456       glib_memory_barrier_needed=no
2457       ;;
2458     cris*|etrax*)
2459       AC_MSG_RESULT([cris])
2460       AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
2461                          [cris atomic implementation])
2462       glib_memory_barrier_needed=no
2463       ;;
2464     *)
2465       AC_MSG_RESULT([none])
2466       glib_memory_barrier_needed=yes
2467       ;;
2468   esac
2469 else
2470   if test $glib_native_win32 = yes; then
2471     # For Windows but not using gcc. No barriers needed then either.
2472     glib_memory_barrier_needed=no
2473   fi
2474 fi
2475
2476 dnl ****************************************
2477 dnl *** GLib POLL* compatibility defines ***
2478 dnl ****************************************
2479
2480 glib_poll_includes=["
2481 #include <sys/types.h>
2482 #include <sys/poll.h>
2483 "]
2484
2485 if test $ac_cv_header_sys_types_h = yes &&
2486    test $ac_cv_header_sys_poll_h = yes ; then
2487   glib_failed=false
2488   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2489   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2490   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2491   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2492   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2493   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2494   if $glib_failed ; then
2495     AC_MSG_ERROR([Could not determine values for POLL* constants])
2496   fi
2497 else
2498   glib_cv_value_POLLIN=1
2499   glib_cv_value_POLLOUT=4
2500   glib_cv_value_POLLPRI=2
2501   glib_cv_value_POLLERR=8
2502   glib_cv_value_POLLHUP=16
2503   glib_cv_value_POLLNVAL=32
2504 fi
2505
2506 AC_MSG_CHECKING([for broken poll])
2507 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2508         #include <stdlib.h>
2509         #include <fcntl.h>
2510         #include <poll.h>
2511         #ifdef HAVE_SYS_POLL_H
2512         #include <sys/poll.h>
2513         #endif
2514         int main(void) {
2515           struct pollfd fds[1];
2516           int fd;
2517           fd = open("/dev/null", 1);
2518           fds[0].fd = fd;
2519           fds[0].events = POLLIN;
2520           fds[0].revents = 0;
2521           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2522                 exit(1);  /* Does not work for devices -- fail */
2523           }
2524           exit(0);
2525         }]])],
2526   [broken_poll=no],
2527   [broken_poll=yes
2528    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2529   [broken_poll="no (cross compiling)"])
2530 AC_MSG_RESULT($broken_poll)
2531
2532 dnl *********************
2533 dnl *** GRegex checks ***
2534 dnl *********************
2535 PCRE_REQUIRED_VERSION=7.2
2536
2537 # Check if we should compile GRegex
2538 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2539               [disable the compilation of GRegex]),
2540 [case "${enableval}" in
2541   yes) enable_regex=true ;;
2542   no)  enable_regex=false ;;
2543   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2544 esac],
2545 [enable_regex=true])
2546
2547 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2548
2549 if test x$enable_regex = xtrue; then
2550   AC_DEFINE(ENABLE_REGEX, [], [include GRegex])
2551   # Check if we should use the internal or the system-supplied pcre
2552   AC_ARG_WITH(pcre,
2553              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2554                              [specify whether to use the internal or the
2555                               system-supplied PCRE library])])
2556
2557   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2558
2559   if test "x$with_pcre" = xsystem; then
2560     PKG_CHECK_MODULES(PCRE,
2561                       libpcre >= $PCRE_REQUIRED_VERSION)
2562     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2563                    glib_save_CFLAGS="$CFLAGS"
2564                    glib_save_LIBS="$LIBS"
2565                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2566                    AC_TRY_RUN([#include <pcre.h>
2567                                int main () {
2568                                  int support;
2569                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2570                                  if (!support)
2571                                    return 1;
2572                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2573                                  if (!support)
2574                                    return 1;
2575                                  return 0;
2576                                }],
2577                    glib_cv_pcre_has_unicode=yes,
2578                    glib_cv_pcre_has_unicode=no,
2579                    glib_cv_pcre_has_unicode=yes)
2580                    CFLAGS="$glib_save_CFLAGS"
2581                    LIBS="$glib_save_LIBS"
2582         ])
2583     if test "$glib_cv_pcre_has_unicode" = "no"; then
2584       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2585     fi
2586     AC_SUBST(PCRE_CFLAGS)
2587     AC_SUBST(PCRE_LIBS)
2588     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2589     PCRE_REQUIRES=libpcre
2590     AC_SUBST(PCRE_REQUIRES)
2591   else
2592     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2593     if test x"$GCC" = xyes; then
2594       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2595       save_CFLAGS="$CFLAGS"
2596       CFLAGS="$CFLAGS -Wno-pointer-sign"
2597       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2598                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2599       CFLAGS="$save_CFLAGS"
2600     fi
2601   fi
2602   AC_SUBST(PCRE_WARN_CFLAGS)
2603 else
2604   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2605 fi
2606
2607 dnl **********************
2608 dnl *** Win32 API libs ***
2609 dnl **********************
2610
2611 case $host in
2612   *-*-cygwin*)
2613         G_LIBS_EXTRA="-luser32 -lkernel32"
2614     ;;
2615   *-*-mingw*)
2616         G_LIBS_EXTRA="-lws2_32 -lole32"
2617     ;;
2618   *)
2619         G_LIBS_EXTRA=""
2620     ;;
2621 esac
2622 AC_SUBST(G_LIBS_EXTRA)
2623
2624 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2625 dnl since we need it for g_iconv()
2626
2627 AC_MSG_CHECKING([for EILSEQ])
2628 AC_TRY_COMPILE([
2629 #include <errno.h>
2630 ],
2631 [
2632 int error = EILSEQ;
2633 ], have_eilseq=yes, have_eilseq=no);
2634 AC_MSG_RESULT($have_eilseq)
2635
2636 dnl ******************************************************************
2637 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2638 dnl ******************************************************************
2639
2640 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2641
2642 if test $cross_compiling = yes; then
2643   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2644   if test x$GLIB_GENMARSHAL = xno; then
2645     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2646   fi
2647 fi
2648
2649 dnl **************************
2650 dnl *** Checks for gtk-doc ***
2651 dnl **************************
2652
2653 GTK_DOC_CHECK([1.11])
2654
2655 AC_ARG_ENABLE(man,
2656               [AC_HELP_STRING([--enable-man],
2657                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2658               enable_man=no)
2659
2660 if test "${enable_man}" != no; then
2661 dnl
2662 dnl Check for xsltproc
2663 dnl
2664 AC_PATH_PROG([XSLTPROC], [xsltproc])
2665   if test -z "$XSLTPROC"; then
2666     enable_man=no
2667   fi
2668
2669   dnl check for DocBook DTD and stylesheets in the local catalog.
2670   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2671      [DocBook XML DTD V4.1.2],,enable_man=no)
2672   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2673      [DocBook XSL Stylesheets],,enable_man=no)
2674 fi
2675
2676 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2677
2678 dnl ******************************
2679 dnl *** output the whole stuff ***
2680 dnl ******************************
2681
2682 dnl this section will only be run if config.status is invoked with no
2683 dnl arguments, or with "glibconfig.h" as an argument.
2684 AC_CONFIG_COMMANDS([glibconfig.h],
2685 [
2686         outfile=glibconfig.h-tmp
2687         cat > $outfile <<\_______EOF
2688 /* glibconfig.h
2689  *
2690  * This is a generated file.  Please modify 'configure.in'
2691  */
2692
2693 #ifndef __G_LIBCONFIG_H__
2694 #define __G_LIBCONFIG_H__
2695
2696 #include <glib/gmacros.h>
2697
2698 _______EOF
2699
2700         if test x$glib_limits_h = xyes; then
2701           echo '#include <limits.h>' >> $outfile
2702         fi
2703         if test x$glib_float_h = xyes; then
2704           echo '#include <float.h>' >> $outfile
2705         fi
2706         if test x$glib_values_h = xyes; then
2707           echo '#include <values.h>' >> $outfile
2708         fi
2709         if test "$glib_header_alloca_h" = "yes"; then
2710           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2711         fi
2712         if test x$glib_sys_poll_h = xyes; then
2713           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2714         fi
2715         if test x$glib_included_printf != xyes; then
2716           echo "
2717 /* Specifies that GLib's g_print*() functions wrap the
2718  * system printf functions.  This is useful to know, for example,
2719  * when using glibc's register_printf_function().
2720  */" >> $outfile
2721           echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2722         fi
2723
2724         cat >> $outfile <<_______EOF
2725
2726 G_BEGIN_DECLS
2727
2728 #define G_MINFLOAT      $glib_mf
2729 #define G_MAXFLOAT      $glib_Mf
2730 #define G_MINDOUBLE     $glib_md
2731 #define G_MAXDOUBLE     $glib_Md
2732 #define G_MINSHORT      $glib_ms
2733 #define G_MAXSHORT      $glib_Ms
2734 #define G_MAXUSHORT     $glib_Mus
2735 #define G_MININT        $glib_mi
2736 #define G_MAXINT        $glib_Mi
2737 #define G_MAXUINT       $glib_Mui
2738 #define G_MINLONG       $glib_ml
2739 #define G_MAXLONG       $glib_Ml
2740 #define G_MAXULONG      $glib_Mul
2741
2742 _______EOF
2743
2744
2745         ### this should always be true in a modern C/C++ compiler
2746         cat >>$outfile <<_______EOF
2747 typedef signed char gint8;
2748 typedef unsigned char guint8;
2749 _______EOF
2750
2751
2752         if test -n "$gint16"; then
2753           cat >>$outfile <<_______EOF
2754 typedef signed $gint16 gint16;
2755 typedef unsigned $gint16 guint16;
2756 #define G_GINT16_MODIFIER $gint16_modifier
2757 #define G_GINT16_FORMAT $gint16_format
2758 #define G_GUINT16_FORMAT $guint16_format
2759 _______EOF
2760         fi
2761
2762
2763         if test -n "$gint32"; then
2764           cat >>$outfile <<_______EOF
2765 typedef signed $gint32 gint32;
2766 typedef unsigned $gint32 guint32;
2767 #define G_GINT32_MODIFIER $gint32_modifier
2768 #define G_GINT32_FORMAT $gint32_format
2769 #define G_GUINT32_FORMAT $guint32_format
2770 _______EOF
2771         fi
2772
2773         cat >>$outfile <<_______EOF
2774 #define G_HAVE_GINT64 1          /* deprecated, always true */
2775
2776 ${glib_extension}typedef signed $gint64 gint64;
2777 ${glib_extension}typedef unsigned $gint64 guint64;
2778
2779 #define G_GINT64_CONSTANT(val)  $gint64_constant
2780 #define G_GUINT64_CONSTANT(val) $guint64_constant
2781 _______EOF
2782
2783         if test x$gint64_format != x ; then
2784           cat >>$outfile <<_______EOF
2785 #define G_GINT64_MODIFIER $gint64_modifier
2786 #define G_GINT64_FORMAT $gint64_format
2787 #define G_GUINT64_FORMAT $guint64_format
2788 _______EOF
2789         else
2790           cat >>$outfile <<_______EOF
2791 #undef G_GINT64_MODIFIER
2792 #undef G_GINT64_FORMAT
2793 #undef G_GUINT64_FORMAT
2794 _______EOF
2795         fi
2796
2797         cat >>$outfile <<_______EOF
2798
2799 #define GLIB_SIZEOF_VOID_P $glib_void_p
2800 #define GLIB_SIZEOF_LONG   $glib_long
2801 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2802
2803 _______EOF
2804
2805         cat >>$outfile <<_______EOF
2806 typedef signed $glib_size_type_define gssize;
2807 typedef unsigned $glib_size_type_define gsize;
2808 #define G_GSIZE_MODIFIER $gsize_modifier
2809 #define G_GSSIZE_FORMAT $gssize_format
2810 #define G_GSIZE_FORMAT $gsize_format
2811
2812 #define G_MAXSIZE       G_MAXU$glib_msize_type
2813 #define G_MINSSIZE      G_MIN$glib_msize_type
2814 #define G_MAXSSIZE      G_MAX$glib_msize_type
2815
2816 typedef gint64 goffset;
2817 #define G_MINOFFSET     G_MININT64
2818 #define G_MAXOFFSET     G_MAXINT64
2819
2820 #define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
2821 #define G_GOFFSET_FORMAT        G_GINT64_FORMAT
2822 #define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
2823
2824 _______EOF
2825
2826         if test -z "$glib_unknown_void_p"; then
2827           cat >>$outfile <<_______EOF
2828
2829 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2830 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2831
2832 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2833 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2834
2835 typedef signed $glib_intptr_type_define gintptr;
2836 typedef unsigned $glib_intptr_type_define guintptr;
2837 _______EOF
2838         else
2839           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2840         fi
2841
2842
2843
2844         cat >>$outfile <<_______EOF
2845 $glib_atexit
2846 $glib_memmove
2847 $glib_defines
2848 $glib_os
2849 $glib_static_compilation
2850
2851 $glib_vacopy
2852
2853 #ifdef  __cplusplus
2854 #define G_HAVE_INLINE   1
2855 #else   /* !__cplusplus */
2856 $glib_inline
2857 #endif  /* !__cplusplus */
2858
2859 #ifdef  __cplusplus
2860 #define G_CAN_INLINE    1
2861 _______EOF
2862
2863         if test x$g_can_inline = xyes ; then
2864                 cat >>$outfile <<_______EOF
2865 #else   /* !__cplusplus */
2866 #define G_CAN_INLINE    1
2867 _______EOF
2868         fi
2869
2870         cat >>$outfile <<_______EOF
2871 #endif
2872
2873 _______EOF
2874
2875         if test x$g_have_iso_c_varargs = xyes ; then
2876                 cat >>$outfile <<_______EOF
2877 #ifndef __cplusplus
2878 # define G_HAVE_ISO_VARARGS 1
2879 #endif
2880 _______EOF
2881         fi
2882         if test x$g_have_iso_cxx_varargs = xyes ; then
2883                 cat >>$outfile <<_______EOF
2884 #ifdef __cplusplus
2885 # define G_HAVE_ISO_VARARGS 1
2886 #endif
2887 _______EOF
2888         fi
2889         if test x$g_have_gnuc_varargs = xyes ; then
2890                 cat >>$outfile <<_______EOF
2891
2892 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2893  * is passed ISO vararg support is turned off, and there is no work
2894  * around to turn it on, so we unconditionally turn it off.
2895  */
2896 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2897 #  undef G_HAVE_ISO_VARARGS
2898 #endif
2899
2900 #define G_HAVE_GNUC_VARARGS 1
2901 _______EOF
2902         fi
2903
2904         case x$g_stack_grows in
2905         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2906         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2907         esac
2908
2909
2910         echo >>$outfile
2911         if test x$g_have_eilseq = xno; then
2912                 cat >>$outfile <<_______EOF
2913 #ifndef EILSEQ
2914 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2915  * The correspondence between this and the corresponding definition
2916  * in libiconv is essential.
2917  */
2918 #  define EILSEQ ENOENT
2919 #endif
2920 _______EOF
2921
2922         fi
2923
2924         if test x$g_have_gnuc_visibility = xyes; then
2925                 cat >>$outfile <<_______EOF
2926 #define G_HAVE_GNUC_VISIBILITY 1
2927 _______EOF
2928         fi
2929                 cat >>$outfile <<_______EOF
2930 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
2931 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2932 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2933 #define G_GNUC_INTERNAL __hidden
2934 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2935 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2936 #else
2937 #define G_GNUC_INTERNAL
2938 #endif
2939 _______EOF
2940
2941
2942         echo >>$outfile
2943         if test x$g_mutex_has_default = xyes; then
2944                 cat >>$outfile <<_______EOF
2945 $g_enable_threads_def G_THREADS_ENABLED
2946 #define G_THREADS_IMPL_$g_threads_impl_def
2947 typedef struct _GStaticMutex GStaticMutex;
2948 struct _GStaticMutex
2949 {
2950   struct _GMutex *runtime_mutex;
2951   union {
2952     char   pad[[$g_mutex_sizeof]];
2953     double dummy_double;
2954     void  *dummy_pointer;
2955     long   dummy_long;
2956   } static_mutex;
2957 };
2958 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2959 #define g_static_mutex_get_mutex(mutex) \\
2960   (g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
2961    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2962 _______EOF
2963         else
2964                 cat >>$outfile <<_______EOF
2965 $g_enable_threads_def G_THREADS_ENABLED
2966 #define G_THREADS_IMPL_$g_threads_impl_def
2967 typedef struct _GMutex* GStaticMutex;
2968 #define G_STATIC_MUTEX_INIT NULL
2969 #define g_static_mutex_get_mutex(mutex) \\
2970   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2971 _______EOF
2972         fi
2973
2974         cat >>$outfile <<_______EOF
2975 /* This represents a system thread as used by the implementation. An
2976  * alien implementaion, as loaded by g_thread_init can only count on
2977  * "sizeof (gpointer)" bytes to store their info. We however need more
2978  * for some of our native implementations. */
2979 typedef union _GSystemThread GSystemThread;
2980 union _GSystemThread
2981 {
2982   char   data[[$g_system_thread_sizeof]];
2983   double dummy_double;
2984   void  *dummy_pointer;
2985   long   dummy_long;
2986 };
2987 _______EOF
2988         if test x"$g_memory_barrier_needed" != xno; then
2989           echo >>$outfile
2990           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2991         fi
2992
2993         echo >>$outfile
2994         g_bit_sizes="16 32 64"
2995         for bits in $g_bit_sizes; do
2996           cat >>$outfile <<_______EOF
2997 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2998 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2999 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
3000 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
3001 _______EOF
3002         done
3003
3004         cat >>$outfile <<_______EOF
3005 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
3006 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
3007 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
3008 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
3009 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
3010 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
3011 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
3012 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
3013 #define G_BYTE_ORDER $g_byte_order
3014
3015 #define GLIB_SYSDEF_POLLIN =$g_pollin
3016 #define GLIB_SYSDEF_POLLOUT =$g_pollout
3017 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
3018 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
3019 #define GLIB_SYSDEF_POLLERR =$g_pollerr
3020 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
3021
3022 #define G_MODULE_SUFFIX "$g_module_suffix"
3023
3024 /* A GPid is an abstraction for a process "handle". It is *not* an
3025  * abstraction for a process identifier in general. GPid is used in
3026  * GLib only for descendant processes spawned with the g_spawn*
3027  * functions. On POSIX there is no "process handle" concept as such,
3028  * but on Windows a GPid is a handle to a process, a kind of pointer,
3029  * not a process identifier.
3030  */
3031 typedef $g_pid_type GPid;
3032
3033 #define GLIB_SYSDEF_AF_UNIX $g_af_unix
3034 #define GLIB_SYSDEF_AF_INET $g_af_inet
3035 #define GLIB_SYSDEF_AF_INET6 $g_af_inet6
3036
3037 G_END_DECLS
3038
3039 #endif /* GLIBCONFIG_H */
3040 _______EOF
3041
3042
3043         if cmp -s $outfile glibconfig.h; then
3044           AC_MSG_NOTICE([glibconfig.h is unchanged])
3045           rm -f $outfile
3046         else
3047           mv $outfile glibconfig.h
3048         fi
3049 ],[
3050
3051 # Note that if two cases are the same, case goes with the first one.
3052 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
3053 # on variable expansion in case labels.  Look at the generated config.status
3054 # for a hint.
3055
3056 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
3057   glib_header_alloca_h="$ac_cv_working_alloca_h"
3058 else
3059   glib_header_alloca_h="$ac_cv_header_alloca_h"
3060 fi
3061
3062 case xyes in
3063 x$ac_cv_header_float_h)
3064   glib_float_h=yes
3065   glib_mf=FLT_MIN glib_Mf=FLT_MAX
3066   glib_md=DBL_MIN glib_Md=DBL_MAX
3067   ;;
3068 x$ac_cv_header_values_h)
3069   glib_values_h=yes
3070   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
3071   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
3072   ;;
3073 esac
3074
3075 case xyes in
3076 x$ac_cv_header_limits_h)
3077   glib_limits_h=yes
3078   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
3079   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
3080   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
3081   ;;
3082 x$ac_cv_header_values_h)
3083   glib_values_h=yes
3084   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
3085   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
3086   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
3087   ;;
3088 esac
3089
3090 if test x$ac_cv_header_sys_poll_h = xyes ; then
3091   glib_sys_poll_h=yes
3092 fi
3093
3094 if test x$enable_included_printf = xyes ; then
3095   glib_included_printf=yes
3096 fi
3097
3098 case 2 in
3099 $ac_cv_sizeof_short)
3100   gint16=short
3101   gint16_modifier='"h"'
3102   gint16_format='"hi"'
3103   guint16_format='"hu"'
3104   ;;
3105 $ac_cv_sizeof_int)
3106   gint16=int
3107   gint16_modifier='""'
3108   gint16_format='"i"'
3109   guint16_format='"u"'
3110   ;;
3111 esac
3112 case 4 in
3113 $ac_cv_sizeof_short)
3114   gint32=short
3115   gint32_modifier='"h"'
3116   gint32_format='"hi"'
3117   guint32_format='"hu"'
3118   ;;
3119 $ac_cv_sizeof_int)
3120   gint32=int
3121   gint32_modifier='""'
3122   gint32_format='"i"'
3123   guint32_format='"u"'
3124   ;;
3125 $ac_cv_sizeof_long)
3126   gint32=long
3127   gint32_modifier='"l"'
3128   gint32_format='"li"'
3129   guint32_format='"lu"'
3130   ;;
3131 esac
3132 case 8 in
3133 $ac_cv_sizeof_int)
3134   gint64=int
3135   gint64_modifier='""'
3136   gint64_format='"i"'
3137   guint64_format='"u"'
3138   glib_extension=
3139   gint64_constant='(val)'
3140   guint64_constant='(val)'
3141   ;;
3142 $ac_cv_sizeof_long)
3143   gint64=long
3144   gint64_modifier='"l"'
3145   gint64_format='"li"'
3146   guint64_format='"lu"'
3147   glib_extension=
3148   gint64_constant='(val##L)'
3149   guint64_constant='(val##UL)'
3150   ;;
3151 $ac_cv_sizeof_long_long)
3152   gint64='long long'
3153   if test -n "$glib_cv_long_long_format"; then
3154     gint64_modifier='"'$glib_cv_long_long_format'"'
3155     gint64_format='"'$glib_cv_long_long_format'i"'
3156     guint64_format='"'$glib_cv_long_long_format'u"'
3157   fi
3158   glib_extension='G_GNUC_EXTENSION '
3159   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3160   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3161   ;;
3162 $ac_cv_sizeof___int64)
3163   gint64='__int64'
3164   if test -n "$glib_cv_long_long_format"; then
3165     gint64_modifier='"'$glib_cv_long_long_format'"'
3166     gint64_format='"'$glib_cv_long_long_format'i"'
3167     guint64_format='"'$glib_cv_long_long_format'u"'
3168   fi
3169   glib_extension=
3170   gint64_constant='(val##i64)'
3171   guint64_constant='(val##ui64)'
3172   ;;
3173 esac
3174 glib_size_t=$ac_cv_sizeof_size_t
3175 glib_size_type_define="$glib_size_type"
3176 glib_void_p=$ac_cv_sizeof_void_p
3177 glib_long=$ac_cv_sizeof_long
3178
3179 case "$glib_size_type" in
3180 short)
3181   gsize_modifier='"h"'
3182   gsize_format='"hu"'
3183   gssize_format='"hi"'
3184   glib_msize_type='SHRT'
3185   ;;
3186 int)
3187   gsize_modifier='""'
3188   gsize_format='"u"'
3189   gssize_format='"i"'
3190   glib_msize_type='INT'
3191   ;;
3192 long)
3193   gsize_modifier='"l"'
3194   gsize_format='"lu"'
3195   gssize_format='"li"'
3196   glib_msize_type='LONG'
3197   ;;
3198 "long long"|__int64)
3199   gsize_modifier='"I64"'
3200   gsize_format='"I64u"'
3201   gssize_format='"I64i"'
3202   glib_msize_type='INT64'
3203   ;;
3204 esac
3205
3206 gintbits=`expr $ac_cv_sizeof_int \* 8`
3207 glongbits=`expr $ac_cv_sizeof_long \* 8`
3208
3209 case $ac_cv_sizeof_void_p in
3210 $ac_cv_sizeof_int)
3211   glib_intptr_type_define=int
3212   glib_gpi_cast=''
3213   glib_gpui_cast=''
3214   ;;
3215 $ac_cv_sizeof_long)
3216   glib_intptr_type_define=long
3217   glib_gpi_cast='(glong)'
3218   glib_gpui_cast='(gulong)'
3219   ;;
3220 $ac_cv_sizeof_long_long)
3221   glib_intptr_type_define='long long'
3222   glib_gpi_cast='(gint64)'
3223   glib_gpui_cast='(guint64)'
3224   ;;
3225 $ac_cv_sizeof___int64)
3226   glib_intptr_type_define=__int64
3227   glib_gpi_cast='(gint64)'
3228   glib_gpui_cast='(guint64)'
3229   ;;
3230 *)
3231   glib_unknown_void_p=yes
3232   ;;
3233 esac
3234
3235
3236 case xyes in
3237 x$ac_cv_func_atexit)
3238   glib_atexit="
3239 #ifdef NeXT /* @#%@! NeXTStep */
3240 # define g_ATEXIT(proc) (!atexit (proc))
3241 #else
3242 # define g_ATEXIT(proc) (atexit (proc))
3243 #endif"
3244   ;;
3245 x$ac_cv_func_on_exit)
3246   glib_atexit="
3247 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
3248   ;;
3249 esac
3250
3251 case xyes in
3252 x$ac_cv_func_memmove)
3253   glib_memmove='
3254 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3255   ;;
3256 x$glib_cv_working_bcopy)
3257   glib_memmove="
3258 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3259 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3260   ;;
3261 *)
3262   glib_memmove="
3263 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3264  * so we have to roll our own copy routine. */
3265 void g_memmove (void* dest, const void * src, unsigned long len);"
3266   ;;
3267 esac
3268
3269 glib_defines="
3270 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3271 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3272 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3273 "
3274
3275 case xyes in
3276 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3277 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3278 *)                      glib_vacopy=''
3279 esac
3280
3281 if test x$glib_cv_va_val_copy = xno; then
3282   glib_vacopy="\$glib_vacopy
3283 #define G_VA_COPY_AS_ARRAY 1"
3284 fi
3285
3286 if test x$glib_cv_hasinline = xyes; then
3287     glib_inline='#define G_HAVE_INLINE 1'
3288 fi
3289 if test x$glib_cv_has__inline = xyes; then
3290     glib_inline="\$glib_inline
3291 #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
3298 g_have_gnuc_varargs=$g_have_gnuc_varargs
3299 g_have_iso_c_varargs=$g_have_iso_c_varargs
3300 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3301
3302 g_can_inline=$g_can_inline
3303 g_have_gnuc_visibility=$g_have_gnuc_visibility
3304 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3305
3306 if test x$ac_cv_c_bigendian = xyes; then
3307   g_byte_order=G_BIG_ENDIAN
3308   g_bs_native=BE
3309   g_bs_alien=LE
3310 else
3311   g_byte_order=G_LITTLE_ENDIAN
3312   g_bs_native=LE
3313   g_bs_alien=BE
3314 fi
3315
3316 g_pollin=$glib_cv_value_POLLIN
3317 g_pollout=$glib_cv_value_POLLOUT
3318 g_pollpri=$glib_cv_value_POLLPRI
3319 g_pollhup=$glib_cv_value_POLLHUP
3320 g_pollerr=$glib_cv_value_POLLERR
3321 g_pollnval=$glib_cv_value_POLLNVAL
3322
3323 g_af_unix=$glib_cv_value_AF_UNIX
3324 g_af_inet=$glib_cv_value_AF_INET
3325 g_af_inet6=$glib_cv_value_AF_INET6
3326
3327 g_stack_grows=$glib_cv_stack_grows
3328
3329 g_have_eilseq=$have_eilseq
3330
3331 case x$have_threads in
3332 xno)    g_enable_threads_def="#undef";;
3333 *)      g_enable_threads_def="#define";;
3334 esac
3335
3336 g_threads_impl_def=$g_threads_impl
3337
3338 g_mutex_has_default="$mutex_has_default"
3339 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3340 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3341 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3342
3343 g_memory_barrier_needed="$glib_memory_barrier_needed"
3344
3345 g_module_suffix="$glib_gmodule_suffix"
3346
3347 g_pid_type="$glib_pid_type"
3348 case $host in
3349   *-*-beos*)
3350     glib_os="#define G_OS_BEOS"
3351     ;;
3352   *-*-cygwin*)
3353     glib_os="#define G_OS_UNIX
3354 #define G_PLATFORM_WIN32
3355 #define G_WITH_CYGWIN"
3356     ;;
3357   *-*-mingw*)
3358     glib_os="#define G_OS_WIN32
3359 #define G_PLATFORM_WIN32"
3360     ;;
3361   *)
3362     glib_os="#define G_OS_UNIX"
3363     ;;
3364 esac
3365 glib_static_compilation=""
3366 if test x$glib_win32_static_compilation = xyes; then
3367   glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3368 #define GOBJECT_STATIC_COMPILATION 1"
3369 fi
3370 ])
3371
3372 AC_CONFIG_FILES([
3373 glib-2.0.pc
3374 glib-2.0-uninstalled.pc
3375 gmodule-2.0.pc
3376 gmodule-export-2.0.pc
3377 gmodule-no-export-2.0.pc
3378 gmodule-2.0-uninstalled.pc
3379 gmodule-no-export-2.0-uninstalled.pc
3380 gthread-2.0.pc
3381 gthread-2.0-uninstalled.pc
3382 gobject-2.0.pc
3383 gobject-2.0-uninstalled.pc
3384 gio-2.0.pc
3385 gio-unix-2.0.pc
3386 gio-2.0-uninstalled.pc
3387 gio-unix-2.0-uninstalled.pc
3388 glib-zip
3389 glib-gettextize
3390 Makefile
3391 build/Makefile
3392 build/win32/Makefile
3393 build/win32/dirent/Makefile
3394 build/win32/vs8/Makefile
3395 build/win32/vs9/Makefile
3396 glib/Makefile
3397 glib/libcharset/Makefile
3398 glib/gnulib/Makefile
3399 glib/pcre/Makefile
3400 glib/update-pcre/Makefile
3401 glib/tests/Makefile
3402 gmodule/Makefile
3403 gmodule/gmoduleconf.h
3404 gobject/Makefile
3405 gobject/glib-mkenums
3406 gobject/tests/Makefile
3407 gthread/Makefile
3408 gio/Makefile
3409 gio/xdgmime/Makefile
3410 gio/inotify/Makefile
3411 gio/libasyncns/Makefile
3412 gio/fen/Makefile
3413 gio/fam/Makefile
3414 gio/win32/Makefile
3415 gio/tests/Makefile
3416 po/Makefile.in
3417 docs/Makefile
3418 docs/reference/Makefile
3419 docs/reference/glib/Makefile
3420 docs/reference/glib/version.xml
3421 docs/reference/gobject/Makefile
3422 docs/reference/gobject/version.xml
3423 docs/reference/gio/Makefile
3424 docs/reference/gio/version.xml
3425 tests/Makefile
3426 tests/gobject/Makefile
3427 tests/refcount/Makefile
3428 m4macros/Makefile
3429 ])
3430
3431 AC_CONFIG_COMMANDS([chmod-scripts],
3432 [chmod 0755 glib-zip
3433 chmod 0755 glib-gettextize
3434 chmod 0755 gobject/glib-mkenums])
3435
3436 # we want to invoke this macro solely so that the config.status script
3437 # and automake generated makefiles know about these generated files.
3438 # They are only needed to distcheck the package
3439 if false; then
3440   AC_CONFIG_FILES([
3441     INSTALL
3442     README
3443     config.h.win32
3444     glibconfig.h.win32
3445     glib/makefile.msc
3446     glib/glib.rc
3447     gmodule/makefile.msc
3448     gmodule/gmodule.rc
3449     gobject/makefile.msc
3450     gobject/gobject.rc
3451     gthread/makefile.msc
3452     gthread/gthread.rc
3453     tests/makefile.msc
3454   ])
3455 fi
3456
3457 AC_OUTPUT