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