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