configure.in

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