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