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