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