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