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