configure.ac

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