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