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