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