configure.in

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