configure.in

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