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 fi
1558 AC_SUBST(XATTR_LIBS)
1559
1560
1561 dnl ****************************************
1562 dnl *** platform dependent source checks ***
1563 dnl ****************************************
1564
1565 AC_MSG_CHECKING(for platform-dependent source)
1566 case "$host" in
1567   *-*-cygwin*|*-*-mingw*)
1568     PLATFORMDEP=gwin32.lo
1569     ;;
1570   *)
1571     PLATFORMDEP=
1572     ;;
1573 esac
1574 AC_MSG_RESULT($PLATFORMDEP)
1575 AC_SUBST(PLATFORMDEP)
1576
1577 AC_MSG_CHECKING([whether to compile timeloop])
1578 case "$host" in
1579   *-*-cygwin*|*-*-mingw*|*-*-minix)
1580     enable_timeloop=no
1581     ;;
1582   *)
1583     enable_timeloop=yes
1584     ;;
1585 esac
1586 AC_MSG_RESULT($enable_timeloop)
1587 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1588
1589 AC_MSG_CHECKING([if building for some Win32 platform])
1590 case "$host" in
1591   *-*-mingw*|*-*-cygwin*)
1592     platform_win32=yes
1593     ;;
1594   *)
1595     platform_win32=no
1596     ;;
1597 esac
1598 AC_MSG_RESULT($platform_win32)
1599 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1600
1601 dnl ***********************
1602 dnl *** g_thread checks ***
1603 dnl ***********************
1604
1605 AC_ARG_WITH(threads,
1606            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1607                            [specify a thread implementation to use])],
1608            [if test "x$with_threads" = x; then
1609                 want_threads=yes
1610             else
1611                 want_threads=$with_threads
1612             fi],
1613            [want_threads=yes])
1614 if test "x$enable_threads" = "xno"; then
1615         want_threads=no
1616 fi
1617
1618 dnl error and warning message
1619 dnl *************************
1620
1621 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1622                 computer. GLib will not have a default thread implementation."
1623
1624 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1625                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1626                 compilation now, but then your programs might not work.
1627                 Please provide information on how it is done on your system."
1628
1629 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1630                 "
1631
1632 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1633                 provide information on your thread implementation.
1634                 You can also run 'configure --disable-threads'
1635                 to compile without thread support."
1636
1637 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1638                 functions will not be MT-safe during their first call because
1639                 there is no working 'getpwuid_r' on your system."
1640
1641 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1642                 because there is no 'localtime_r' on your system."
1643
1644 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1645                 crude surrogate will be used. If you happen to know a
1646                 yield function for your system, please inform the GLib
1647                 developers."
1648
1649 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1650                 threads on your system. Thus threads can only have the default
1651                 priority. If you happen to know these main/max
1652                 priorities, please inform the GLib developers."
1653
1654 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1655                 linking threaded applications. As GLib cannot do that
1656                 automatically, you will get an linkg error everytime you are
1657                 not using the right compiler. In that case you have to relink
1658                 with the right compiler. Ususally just '_r' is appended
1659                 to the compiler name."
1660
1661 dnl determination of thread implementation
1662 dnl ***************************************
1663
1664 # have_threads=no   means no thread support
1665 # have_threads=none means no default thread implementation
1666
1667 have_threads=no
1668 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1669                                 || test "x$want_threads" = xdce; then
1670         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1671         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1672         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1673         glib_save_CPPFLAGS="$CPPFLAGS"
1674         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1675         if test "x$have_threads" = xno; then
1676                 AC_TRY_COMPILE([#include <pthread.h>],
1677                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1678                         have_threads=posix)
1679         fi
1680         if test "x$have_threads" = xno; then
1681                 AC_TRY_COMPILE([#include <pthread.h>],
1682                         [pthread_mutex_t m;
1683                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1684                         have_threads=dce)
1685         fi
1686         # Tru64Unix requires -pthread to find pthread.h. See #103020
1687         CPPFLAGS="$CPPFLAGS -pthread"
1688         if test "x$have_threads" = xno; then
1689         AC_TRY_COMPILE([#include <pthread.h>],
1690                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1691                        have_threads=posix)
1692         fi
1693         CPPFLAGS="$glib_save_CPPFLAGS"
1694 fi
1695 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1696         case $host in
1697                 *-*-mingw*)
1698                 have_threads=win32
1699                 ;;
1700         esac
1701 fi
1702 if test "x$want_threads" = xnone; then
1703         have_threads=none
1704 fi
1705
1706 AC_MSG_CHECKING(for thread implementation)
1707
1708 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1709         AC_MSG_RESULT(none available)
1710         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1711 else
1712         AC_MSG_RESULT($have_threads)
1713 fi
1714
1715
1716 dnl determination of G_THREAD_CFLAGS
1717 dnl ********************************
1718
1719 G_THREAD_LIBS=
1720 G_THREAD_LIBS_EXTRA=
1721 G_THREAD_CFLAGS=
1722
1723 dnl
1724 dnl Test program for basic POSIX threads functionality
1725 dnl
1726 m4_define([glib_thread_test],[
1727 #include <pthread.h>
1728 int check_me = 0;
1729 void* func(void* data) {check_me = 42; return &check_me;}
1730 int main()
1731  { pthread_t t;
1732    void *ret;
1733    pthread_create (&t, $1, func, 0);
1734    pthread_join (t, &ret);
1735    return (check_me != 42 || ret != &check_me);
1736 }])
1737
1738 dnl
1739 dnl Test program for sched_get_priority_min()
1740 dnl
1741 m4_define([glib_sched_priority_test],[
1742 #include <sched.h>
1743 #include <errno.h>
1744 int main() {
1745     errno = 0;
1746     return sched_get_priority_min(SCHED_OTHER)==-1
1747            && errno != 0;
1748 }])
1749
1750 if test x"$have_threads" != xno; then
1751
1752   if test x"$have_threads" = xposix; then
1753     # First we test for posix, whether -pthread or -pthreads do the trick as
1754     # both CPPFLAG and LIBS.
1755     # One of them does for most gcc versions and some other platforms/compilers
1756     # too and could be considered as the canonical way to go.
1757     case $host in
1758       *-*-cygwin*|*-*-darwin*)
1759          # skip cygwin and darwin -pthread or -pthreads test
1760          ;;
1761       *-solaris*)
1762         # These compiler/linker flags work with both Sun Studio and gcc
1763         # Sun Studio expands -mt to -D_REENTRANT and -lthread
1764         # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1765         G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1766         G_THREAD_LIBS="-lpthread -lthread"
1767         ;;
1768       *)
1769         for flag in pthread pthreads mt; do
1770           glib_save_CFLAGS="$CFLAGS"
1771           CFLAGS="$CFLAGS -$flag"
1772           AC_TRY_RUN(glib_thread_test(0),
1773                      glib_flag_works=yes,
1774                      glib_flag_works=no,
1775                      [AC_LINK_IFELSE(glib_thread_test(0),
1776                                      glib_flag_works=yes,
1777                                      glib_flag_works=no)])
1778           CFLAGS="$glib_save_CFLAGS"
1779           if test $glib_flag_works = yes ; then
1780              G_THREAD_CFLAGS=-$flag
1781              G_THREAD_LIBS=-$flag
1782              break;
1783           fi
1784         done
1785          ;;
1786     esac
1787   fi
1788
1789   if test x"$G_THREAD_CFLAGS" = x; then
1790
1791     # The canonical -pthread[s] does not work. Try something different.
1792
1793     case $host in
1794         *-aix*)
1795                 if test x"$GCC" = xyes; then
1796                         # GCC 3.0 and above needs -pthread.
1797                         # Should be coverd by the case above.
1798                         # GCC 2.x and below needs -mthreads
1799                         G_THREAD_CFLAGS="-mthreads"
1800                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1801                 else
1802                         # We are probably using the aix compiler. Normaly a
1803                         # program would have to be compiled with the _r variant
1804                         # of the corresponding compiler, but we as GLib cannot
1805                         # do that: but the good news is that for compiling the
1806                         # only difference is the added -D_THREAD_SAFE compile
1807                         # option. This is according to the "C for AIX User's
1808                         # Guide".
1809                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1810                 fi
1811                 ;;
1812         *-dg-dgux*)  # DG/UX
1813                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1814                 ;;
1815         *-osf*)
1816                 # So we are using dce threads. posix threads are already
1817                 # catched above.
1818                 G_THREAD_CFLAGS="-threads"
1819                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1820                 ;;
1821         *-sysv5uw7*) # UnixWare 7
1822                 # We are not using gcc with -pthread. Catched above.
1823                 G_THREAD_CFLAGS="-Kthread"
1824                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1825                 ;;
1826         *-mingw*)
1827                 # No flag needed when using MSVCRT.DLL
1828                 G_THREAD_CFLAGS=""
1829                 ;;
1830         *)
1831                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1832                 ;;
1833     esac
1834
1835   fi
1836
1837     # if we are not finding the localtime_r function, then we probably are
1838     # not using the proper multithread flag
1839
1840     glib_save_CPPFLAGS="$CPPFLAGS"
1841     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1842
1843     # First we test, whether localtime_r is declared in time.h
1844     # directly. Then we test whether a macro localtime_r exists, in
1845     # which case localtime_r in the test program is replaced and thus
1846     # if we still find localtime_r in the output, it is not defined as
1847     # a macro.
1848
1849     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1850       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1851                                                            localtime_r(a,b)],
1852                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1853
1854     CPPFLAGS="$glib_save_CPPFLAGS"
1855
1856     AC_MSG_CHECKING(thread related cflags)
1857     AC_MSG_RESULT($G_THREAD_CFLAGS)
1858     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1859 fi
1860
1861 dnl determination of G_THREAD_LIBS
1862 dnl ******************************
1863
1864 mutex_has_default=no
1865 case $have_threads in
1866         posix|dce)
1867           glib_save_CPPFLAGS="$CPPFLAGS"
1868           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1869           if test x"$G_THREAD_LIBS" = x; then
1870             case $host in
1871               *-aix*)
1872                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1873                 # probably using the aix compiler.
1874                 AC_MSG_WARN($AIX_COMPILE_INFO)
1875                 ;;
1876               *)
1877                 G_THREAD_LIBS=error
1878                 glib_save_LIBS="$LIBS"
1879                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1880                         if test x"$thread_lib" = x; then
1881                                 add_thread_lib=""
1882                                 IN=""
1883                         else
1884                                 add_thread_lib="-l$thread_lib"
1885                                 IN=" in -l$thread_lib"
1886                         fi
1887                         if test x"$have_threads" = xposix; then
1888                                 defattr=0
1889                         else
1890                                 defattr=pthread_attr_default
1891                         fi
1892
1893                         LIBS="$add_thread_lib $glib_save_LIBS"
1894
1895                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1896                         AC_TRY_RUN(glib_thread_test($defattr),
1897                                    glib_result=yes,
1898                                    glib_result=no,
1899                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
1900                                                    glib_result=yes,
1901                                                    glib_result=no)])
1902                         AC_MSG_RESULT($glib_result)
1903
1904                         if test "$glib_result" = "yes" ; then
1905                           G_THREAD_LIBS="$add_thread_lib"
1906                           break
1907                         fi
1908                 done
1909                 if test "x$G_THREAD_LIBS" = xerror; then
1910                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1911                 fi
1912                 LIBS="$glib_save_LIBS"
1913                 ;;
1914             esac
1915           fi
1916
1917           glib_save_LIBS="$LIBS"
1918           for thread_lib in "" rt rte; do
1919             if test x"$thread_lib" = x; then
1920               add_thread_lib=""
1921               IN=""
1922             else
1923               add_thread_lib="-l$thread_lib"
1924               IN=" in -l$thread_lib"
1925             fi
1926             LIBS="$add_thread_lib $glib_save_LIBS"
1927
1928             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1929             AC_TRY_RUN(glib_sched_priority_test,
1930                        glib_result=yes,
1931                        glib_result=no,
1932                        [AC_LINK_IFELSE(glib_sched_priority_test,
1933                                        glib_result=yes,
1934                                        glib_result=no)])
1935             AC_MSG_RESULT($glib_result)
1936
1937             if test "$glib_result" = "yes" ; then
1938                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1939                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1940                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1941                break
1942             fi
1943           done
1944           LIBS="$glib_save_LIBS"
1945           mutex_has_default=yes
1946           mutex_default_type='pthread_mutex_t'
1947           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1948           mutex_header_file='pthread.h'
1949           if test "x$have_threads" = "xposix"; then
1950             g_threads_impl="POSIX"
1951           else
1952             g_threads_impl="DCE"
1953             have_threads="posix"
1954           fi
1955           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1956           CPPFLAGS="$glib_save_CPPFLAGS"
1957           ;;
1958         win32)
1959            g_threads_impl="WIN32"
1960            ;;
1961         none|no)
1962            g_threads_impl="NONE"
1963            ;;
1964         *)
1965            g_threads_impl="NONE"
1966            G_THREAD_LIBS=error
1967            ;;
1968 esac
1969
1970 if test "x$G_THREAD_LIBS" = xerror; then
1971         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1972 fi
1973
1974 case $host in
1975   *-*-beos*)
1976     G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
1977     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1978     ;;
1979   *)
1980     ;;
1981 esac
1982
1983 AC_MSG_CHECKING(thread related libraries)
1984 AC_MSG_RESULT($G_THREAD_LIBS)
1985
1986 dnl check for mt safe function variants and some posix functions
1987 dnl ************************************************************
1988
1989 if test x"$have_threads" != xno; then
1990         glib_save_LIBS="$LIBS"
1991         # we are not doing the following for now, as this might require glib
1992         # to always be linked with the thread libs on some platforms.
1993         # LIBS="$LIBS $G_THREAD_LIBS"
1994         AC_CHECK_FUNCS(localtime_r)
1995         if test "$ac_cv_header_pwd_h" = "yes"; then
1996                 AC_CACHE_CHECK([for posix getpwuid_r],
1997                         ac_cv_func_posix_getpwuid_r,
1998                         [AC_TRY_RUN([
1999 #include <errno.h>
2000 #include <pwd.h>
2001 int main () {
2002     char buffer[10000];
2003     struct passwd pwd, *pwptr = &pwd;
2004     int error;
2005     errno = 0;
2006     error = getpwuid_r (0, &pwd, buffer,
2007                         sizeof (buffer), &pwptr);
2008    return (error < 0 && errno == ENOSYS)
2009            || error == ENOSYS;
2010 }                               ],
2011                                 [ac_cv_func_posix_getpwuid_r=yes],
2012                                 [ac_cv_func_posix_getpwuid_r=no])])
2013                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
2014                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
2015                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
2016                                 [Have POSIX function getpwuid_r])
2017                 else
2018                         AC_CACHE_CHECK([for nonposix getpwuid_r],
2019                                 ac_cv_func_nonposix_getpwuid_r,
2020                                 [AC_TRY_LINK([#include <pwd.h>],
2021                                         [char buffer[10000];
2022                                         struct passwd pwd;
2023                                         getpwuid_r (0, &pwd, buffer,
2024                                                         sizeof (buffer));],
2025                                         [ac_cv_func_nonposix_getpwuid_r=yes],
2026                                         [ac_cv_func_nonposix_getpwuid_r=no])])
2027                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
2028                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
2029                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
2030                                         [Have non-POSIX function getpwuid_r])
2031                         fi
2032                 fi
2033         fi
2034         if test "$ac_cv_header_grp_h" = "yes"; then
2035                 AC_CACHE_CHECK([for posix getgrgid_r],
2036                         ac_cv_func_posix_getgrgid_r,
2037                         [AC_TRY_RUN([
2038 #include <errno.h>
2039 #include <grp.h>
2040 int main () {
2041     char buffer[10000];
2042     struct group grp, *grpptr = &grp;
2043     int error;
2044     errno = 0;
2045     error = getgrgid_r (0, &grp, buffer,
2046                         sizeof (buffer), &grpptr);
2047    return (error < 0 && errno == ENOSYS)
2048            || error == ENOSYS;
2049 }                              ],
2050                                [ac_cv_func_posix_getgrgid_r=yes],
2051                                [ac_cv_func_posix_getgrgid_r=no])])
2052                 GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
2053                 if test "$ac_cv_func_posix_getgrgid_r" = yes; then
2054                         AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
2055                                 [Have POSIX function getgrgid_r])
2056                 else
2057                         AC_CACHE_CHECK([for nonposix getgrgid_r],
2058                                 ac_cv_func_nonposix_getgrgid_r,
2059                                 [AC_TRY_LINK([#include <grp.h>],
2060                                         [char buffer[10000];
2061                                         struct group grp;
2062                                         getgrgid_r (0, &grp, buffer,
2063                                         sizeof (buffer));],
2064                                 [ac_cv_func_nonposix_getgrgid_r=yes],
2065                                 [ac_cv_func_nonposix_getgrgid_r=no])])
2066                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
2067                         if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
2068                                 AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
2069                                         [Have non-POSIX function getgrgid_r])
2070                         fi
2071                 fi
2072         fi
2073         LIBS="$G_THREAD_LIBS $LIBS"
2074         if test x"$have_threads" = xposix; then
2075                 glib_save_CPPFLAGS="$CPPFLAGS"
2076                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2077                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
2078                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
2079                 # This is not AC_CHECK_FUNC to also work with function
2080                 # name mangling in header files.
2081                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
2082                 AC_TRY_LINK([#include <pthread.h>],
2083                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
2084                         [AC_MSG_RESULT(yes)
2085                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
2086                                   [Have function pthread_attr_setstacksize])],
2087                         [AC_MSG_RESULT(no)])
2088                 AC_MSG_CHECKING(for minimal/maximal thread priority)
2089                 if test x"$posix_priority_min" = x; then
2090                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
2091                                 PX_PRIO_MIN],,[
2092                                 posix_priority_min=PX_PRIO_MIN
2093                                 posix_priority_max=PX_PRIO_MAX])
2094                 fi
2095                 if test x"$posix_priority_min" = x; then
2096                         # AIX
2097                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
2098                                 PTHREAD_PRIO_MIN],,[
2099                                 posix_priority_min=PTHREAD_PRIO_MIN
2100                                 posix_priority_max=PTHREAD_PRIO_MAX])
2101                 fi
2102                 if test x"$posix_priority_min" = x; then
2103                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
2104                                 PRI_OTHER_MIN],,[
2105                                 posix_priority_min=PRI_OTHER_MIN
2106                                 posix_priority_max=PRI_OTHER_MAX])
2107                 fi
2108                 if test x"$posix_priority_min" = x; then
2109                         AC_MSG_RESULT(none found)
2110                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
2111                         posix_priority_min=-1
2112                         posix_priority_max=-1
2113                 else
2114                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
2115                         AC_MSG_CHECKING(for pthread_setschedparam)
2116                         AC_TRY_LINK([#include <pthread.h>],
2117                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
2118                           [AC_MSG_RESULT(yes)
2119                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
2120                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
2121                           [AC_MSG_RESULT(no)
2122                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
2123                 fi
2124                 posix_yield_func=none
2125                 AC_MSG_CHECKING(for posix yield function)
2126                 for yield_func in sched_yield pthread_yield_np pthread_yield \
2127                                                         thr_yield; do
2128                         AC_TRY_LINK([#include <pthread.h>],
2129                                 [$yield_func()],
2130                                 [posix_yield_func="$yield_func"
2131                                 break])
2132                 done
2133                 if test x"$posix_yield_func" = xnone; then
2134                         AC_MSG_RESULT(none found)
2135                         AC_MSG_WARN($POSIX_NO_YIELD)
2136                         posix_yield_func="g_usleep(1000)"
2137                 else
2138                         AC_MSG_RESULT($posix_yield_func)
2139                         posix_yield_func="$posix_yield_func()"
2140                 fi
2141                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
2142                 CPPFLAGS="$glib_save_CPPFLAGS"
2143
2144         elif test x"$have_threads" = xwin32; then
2145                 # It's a pointer to a private struct
2146                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
2147         fi
2148
2149         LIBS="$glib_save_LIBS"
2150
2151         # now spit out all the warnings.
2152         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
2153            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
2154                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
2155         fi
2156         if test "$ac_cv_func_localtime_r" != "yes"; then
2157                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
2158         fi
2159 fi
2160
2161 if test x"$glib_cv_sizeof_system_thread" = x; then
2162    # use a pointer as a fallback.
2163    GLIB_SIZEOF(,void *, system_thread)
2164 fi
2165
2166 #
2167 # Hack to deal with:
2168 #
2169 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
2170 #     building shared libraries with linux.
2171 #  b) FreeBSD doesn't do this either.
2172 #
2173 case $host in
2174   *-*-freebsd*|*-*-linux*)
2175     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
2176     ;;
2177   *)
2178     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2179     ;;
2180 esac
2181
2182 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
2183                    [Source file containing theread implementation])
2184 AC_SUBST(G_THREAD_CFLAGS)
2185 AC_SUBST(G_THREAD_LIBS)
2186 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2187 AC_SUBST(G_THREAD_LIBS_EXTRA)
2188
2189 dnl **********************************************
2190 dnl *** GDefaultMutex setup and initialization ***
2191 dnl **********************************************
2192 dnl
2193 dnl if mutex_has_default = yes, we also got
2194 dnl mutex_default_type, mutex_default_init and mutex_header_file
2195 if test $mutex_has_default = yes ; then
2196         glib_save_CPPFLAGS="$CPPFLAGS"
2197         glib_save_LIBS="$LIBS"
2198         LIBS="$G_THREAD_LIBS $LIBS"
2199         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2200         GLIB_SIZEOF([#include <$mutex_header_file>],
2201                     $mutex_default_type,
2202                     gmutex)
2203         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
2204                            $mutex_default_type,
2205                            gmutex,
2206                            $glib_cv_sizeof_gmutex,
2207                            $mutex_default_init)
2208         if test x"$glib_cv_byte_contents_gmutex" = xno; then
2209                 mutex_has_default=no
2210         fi
2211         CPPFLAGS="$glib_save_CPPFLAGS"
2212         LIBS="$glib_save_LIBS"
2213 fi
2214
2215 AC_CHECK_FUNCS(clock_gettime, [], [
2216   AC_CHECK_LIB(rt, clock_gettime, [
2217     AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2218     G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2219     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2220   ])
2221 ])
2222
2223 AC_CACHE_CHECK(for monotonic clocks,
2224     glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2225 #include <time.h>
2226 #include <unistd.h>
2227 int main() {
2228 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2229         #error No monotonic clock
2230 #endif
2231         return 0;
2232 }
2233 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2234 if test "$glib_cv_monotonic_clock" = "yes"; then
2235   AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2236 fi
2237
2238
2239 dnl ********************************
2240 dnl *** g_atomic_* tests for gcc ***
2241 dnl ********************************
2242
2243 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2244
2245 if test x"$GCC" = xyes; then
2246   case $host_cpu in
2247     i386)
2248       AC_MSG_RESULT([none])
2249       glib_memory_barrier_needed=no
2250       ;;
2251     i?86)
2252       AC_MSG_RESULT([i486])
2253       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2254                          [i486 atomic implementation])
2255       glib_memory_barrier_needed=no
2256       ;;
2257     sparc*)
2258       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2259                 when you are using a sparc with v9 instruction set (most
2260                 sparcs nowadays). This will make the code for atomic
2261                 operations much faster. The resulting code will not run
2262                 on very old sparcs though."
2263
2264       AC_LINK_IFELSE([[
2265         main ()
2266         {
2267           int tmp1, tmp2, tmp3;
2268           __asm__ __volatile__("casx [%2], %0, %1"
2269                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2270         }]],
2271         AC_MSG_RESULT([sparcv9])
2272         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2273                            [sparcv9 atomic implementation]),
2274         AC_MSG_RESULT([no])
2275         AC_MSG_WARN([[$SPARCV9_WARNING]]))
2276       glib_memory_barrier_needed=yes
2277       ;;
2278     alpha*)
2279       AC_MSG_RESULT([alpha])
2280       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2281                          [alpha atomic implementation])
2282       glib_memory_barrier_needed=yes
2283       ;;
2284     x86_64)
2285       AC_MSG_RESULT([x86_64])
2286       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2287                          [x86_64 atomic implementation])
2288       glib_memory_barrier_needed=no
2289      ;;
2290     powerpc*)
2291       AC_MSG_RESULT([powerpc])
2292       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2293                          [powerpc atomic implementation])
2294       glib_memory_barrier_needed=yes
2295       AC_MSG_CHECKING([whether asm supports numbered local labels])
2296       AC_TRY_COMPILE(
2297                 ,[
2298                         __asm__ __volatile__ ("1:       nop\n"
2299                                               "         bne-    1b")
2300                 ],[
2301                         AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2302                         AC_MSG_RESULT([yes])
2303                 ],[
2304                         AC_MSG_RESULT([no])
2305                 ])
2306       ;;
2307     ia64)
2308       AC_MSG_RESULT([ia64])
2309       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2310                          [ia64 atomic implementation])
2311       glib_memory_barrier_needed=yes
2312       ;;
2313     s390|s390x)
2314       AC_MSG_RESULT([s390])
2315       AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2316                          [s390 atomic implementation])
2317       glib_memory_barrier_needed=no
2318       ;;
2319     arm*)
2320       AC_MSG_RESULT([arm])
2321       AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2322                          [arm atomic implementation])
2323       glib_memory_barrier_needed=no
2324       ;;
2325     *)
2326       AC_MSG_RESULT([none])
2327       glib_memory_barrier_needed=yes
2328       ;;
2329   esac
2330 fi
2331
2332 dnl ****************************************
2333 dnl *** GLib POLL* compatibility defines ***
2334 dnl ****************************************
2335
2336 glib_poll_includes=["
2337 #include <sys/types.h>
2338 #include <sys/poll.h>
2339 "]
2340
2341 if test $ac_cv_header_sys_types_h = yes &&
2342    test $ac_cv_header_sys_poll_h = yes ; then
2343   glib_failed=false
2344   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2345   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2346   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2347   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2348   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2349   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2350   if $glib_failed ; then
2351     AC_MSG_ERROR([Could not determine values for POLL* constants])
2352   fi
2353 else
2354   glib_cv_value_POLLIN=1
2355   glib_cv_value_POLLOUT=4
2356   glib_cv_value_POLLPRI=2
2357   glib_cv_value_POLLERR=8
2358   glib_cv_value_POLLHUP=16
2359   glib_cv_value_POLLNVAL=32
2360 fi
2361
2362 AC_MSG_CHECKING([for broken poll])
2363 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2364         #include <stdlib.h>
2365         #include <fcntl.h>
2366         #include <poll.h>
2367         #ifdef HAVE_SYS_POLL_H
2368         #include <sys/poll.h>
2369         #endif
2370         int main(void) {
2371           struct pollfd fds[1];
2372           int fd;
2373           fd = open("/dev/null", 1);
2374           fds[0].fd = fd;
2375           fds[0].events = POLLIN;
2376           fds[0].revents = 0;
2377           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2378                 exit(1);  /* Does not work for devices -- fail */
2379           }
2380           exit(0);
2381         }]])],
2382   [broken_poll=no],
2383   [broken_poll=yes
2384    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2385   [broken_poll="no (cross compiling)"])
2386 AC_MSG_RESULT($broken_poll)
2387
2388 dnl *********************
2389 dnl *** GRegex checks ***
2390 dnl *********************
2391 PCRE_REQUIRED_VERSION=7.2
2392
2393 # Check if we should compile GRegex
2394 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2395               [disable the compilation of GRegex]),
2396 [case "${enableval}" in
2397   yes) enable_regex=true ;;
2398   no)  enable_regex=false ;;
2399   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2400 esac],
2401 [enable_regex=true])
2402
2403 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2404
2405 if test x$enable_regex = xtrue; then
2406   # Check if we should use the internal or the system-supplied pcre
2407   AC_ARG_WITH(pcre,
2408              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2409                              [specify whether to use the internal or the
2410                               system-supplied PCRE library])])
2411
2412   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2413
2414   if test "x$with_pcre" = xsystem; then
2415     PKG_CHECK_MODULES(PCRE,
2416                       libpcre >= $PCRE_REQUIRED_VERSION)
2417     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2418                    glib_save_CFLAGS="$CFLAGS"
2419                    glib_save_LDFLAGS="$LDFLAGS"
2420                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LDFLAGS="$LDFLAGS $PCRE_LIBS"
2421                    AC_TRY_RUN([#include <pcre.h>
2422                                int main () {
2423                                  int support;
2424                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2425                                  if (!support)
2426                                    return 1;
2427                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2428                                  if (!support)
2429                                    return 1;
2430                                  return 0;
2431                                }],
2432                    glib_cv_pcre_has_unicode=yes,
2433                    glib_cv_pcre_has_unicode=no,
2434                    glib_cv_pcre_has_unicode=yes)
2435                    CFLAGS="$glib_save_CFLAGS"
2436                    LDFLAGS="$glib_save_LDFLAGS"
2437         ])
2438     if test "$glib_cv_pcre_has_unicode" = "no"; then
2439       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2440     fi
2441     AC_SUBST(PCRE_CFLAGS)
2442     AC_SUBST(PCRE_LIBS)
2443     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2444     PCRE_REQUIRES=libpcre
2445     AC_SUBST(PCRE_REQUIRES)
2446   else
2447     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2448     if test x"$GCC" = xyes; then
2449       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2450       save_CFLAGS="$CFLAGS"
2451       CFLAGS="$CFLAGS -Wno-pointer-sign"
2452       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2453                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2454       CFLAGS="$save_CFLAGS"
2455     fi
2456   fi
2457   AC_SUBST(PCRE_WARN_CFLAGS)
2458 else
2459   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2460 fi
2461
2462 dnl **********************
2463 dnl *** Win32 API libs ***
2464 dnl **********************
2465
2466 case $host in
2467   *-*-cygwin*)
2468         G_LIBS_EXTRA="-luser32 -lkernel32"
2469     ;;
2470   *-*-mingw*)
2471         G_LIBS_EXTRA="-lws2_32 -lole32"
2472     ;;
2473   *)
2474         G_LIBS_EXTRA=""
2475     ;;
2476 esac
2477 AC_SUBST(G_LIBS_EXTRA)
2478
2479 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2480 dnl since we need it for g_iconv()
2481
2482 AC_MSG_CHECKING([for EILSEQ])
2483 AC_TRY_COMPILE([
2484 #include <errno.h>
2485 ],
2486 [
2487 int error = EILSEQ;
2488 ], have_eilseq=yes, have_eilseq=no);
2489 AC_MSG_RESULT($have_eilseq)
2490
2491 dnl ******************************************************************
2492 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2493 dnl ******************************************************************
2494
2495 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2496
2497 if test $cross_compiling = yes; then
2498   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2499   if test x$GLIB_GENMARSHAL = xno; then
2500     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2501   fi
2502 fi
2503
2504 dnl **************************
2505 dnl *** Checks for gtk-doc ***
2506 dnl **************************
2507
2508 GTK_DOC_CHECK([1.8])
2509
2510 AC_ARG_ENABLE(man,
2511               [AC_HELP_STRING([--enable-man],
2512                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2513               enable_man=no)
2514
2515 if test "${enable_man}" != no; then
2516 dnl
2517 dnl Check for xsltproc
2518 dnl
2519 AC_PATH_PROG([XSLTPROC], [xsltproc])
2520   if test -z "$XSLTPROC"; then
2521     enable_man=no
2522   fi
2523
2524   dnl check for DocBook DTD and stylesheets in the local catalog.
2525   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2526      [DocBook XML DTD V4.1.2],,enable_man=no)
2527   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2528      [DocBook XSL Stylesheets],,enable_man=no)
2529 fi
2530
2531 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2532
2533 dnl ******************************
2534 dnl *** output the whole stuff ***
2535 dnl ******************************
2536
2537 dnl this section will only be run if config.status is invoked with no
2538 dnl arguments, or with "glibconfig.h" as an argument.
2539 AC_CONFIG_COMMANDS([glibconfig.h],
2540 [
2541         outfile=glibconfig.h-tmp
2542         cat > $outfile <<\_______EOF
2543 /* glibconfig.h
2544  *
2545  * This is a generated file.  Please modify 'configure.in'
2546  */
2547
2548 #ifndef __G_LIBCONFIG_H__
2549 #define __G_LIBCONFIG_H__
2550
2551 #include <glib/gmacros.h>
2552
2553 _______EOF
2554
2555         if test x$glib_limits_h = xyes; then
2556           echo '#include <limits.h>' >> $outfile
2557         fi
2558         if test x$glib_float_h = xyes; then
2559           echo '#include <float.h>' >> $outfile
2560         fi
2561         if test x$glib_values_h = xyes; then
2562           echo '#include <values.h>' >> $outfile
2563         fi
2564         if test "$glib_header_alloca_h" = "yes"; then
2565           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2566         fi
2567         if test x$glib_sys_poll_h = xyes; then
2568           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2569         fi
2570
2571         cat >> $outfile <<_______EOF
2572
2573 G_BEGIN_DECLS
2574
2575 #define G_MINFLOAT      $glib_mf
2576 #define G_MAXFLOAT      $glib_Mf
2577 #define G_MINDOUBLE     $glib_md
2578 #define G_MAXDOUBLE     $glib_Md
2579 #define G_MINSHORT      $glib_ms
2580 #define G_MAXSHORT      $glib_Ms
2581 #define G_MAXUSHORT     $glib_Mus
2582 #define G_MININT        $glib_mi
2583 #define G_MAXINT        $glib_Mi
2584 #define G_MAXUINT       $glib_Mui
2585 #define G_MINLONG       $glib_ml
2586 #define G_MAXLONG       $glib_Ml
2587 #define G_MAXULONG      $glib_Mul
2588
2589 _______EOF
2590
2591
2592         ### this should always be true in a modern C/C++ compiler
2593         cat >>$outfile <<_______EOF
2594 typedef signed char gint8;
2595 typedef unsigned char guint8;
2596 _______EOF
2597
2598
2599         if test -n "$gint16"; then
2600           cat >>$outfile <<_______EOF
2601 typedef signed $gint16 gint16;
2602 typedef unsigned $gint16 guint16;
2603 #define G_GINT16_MODIFIER $gint16_modifier
2604 #define G_GINT16_FORMAT $gint16_format
2605 #define G_GUINT16_FORMAT $guint16_format
2606 _______EOF
2607         fi
2608
2609
2610         if test -n "$gint32"; then
2611           cat >>$outfile <<_______EOF
2612 typedef signed $gint32 gint32;
2613 typedef unsigned $gint32 guint32;
2614 #define G_GINT32_MODIFIER $gint32_modifier
2615 #define G_GINT32_FORMAT $gint32_format
2616 #define G_GUINT32_FORMAT $guint32_format
2617 _______EOF
2618         fi
2619
2620         cat >>$outfile <<_______EOF
2621 #define G_HAVE_GINT64 1          /* deprecated, always true */
2622
2623 ${glib_extension}typedef signed $gint64 gint64;
2624 ${glib_extension}typedef unsigned $gint64 guint64;
2625
2626 #define G_GINT64_CONSTANT(val)  $gint64_constant
2627 #define G_GUINT64_CONSTANT(val) $guint64_constant
2628 _______EOF
2629
2630         if test x$gint64_format != x ; then
2631           cat >>$outfile <<_______EOF
2632 #define G_GINT64_MODIFIER $gint64_modifier
2633 #define G_GINT64_FORMAT $gint64_format
2634 #define G_GUINT64_FORMAT $guint64_format
2635 _______EOF
2636         else
2637           cat >>$outfile <<_______EOF
2638 #undef G_GINT64_MODIFIER
2639 #undef G_GINT64_FORMAT
2640 #undef G_GUINT64_FORMAT
2641 _______EOF
2642         fi
2643
2644         cat >>$outfile <<_______EOF
2645
2646 #define GLIB_SIZEOF_VOID_P $glib_void_p
2647 #define GLIB_SIZEOF_LONG   $glib_long
2648 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2649
2650 _______EOF
2651
2652         cat >>$outfile <<_______EOF
2653 typedef signed $glib_size_type_define gssize;
2654 typedef unsigned $glib_size_type_define gsize;
2655 #define G_GSIZE_MODIFIER $gsize_modifier
2656 #define G_GSSIZE_FORMAT $gssize_format
2657 #define G_GSIZE_FORMAT $gsize_format
2658
2659 #define G_MAXSIZE       G_MAXU$glib_msize_type
2660 #define G_MINSSIZE      G_MIN$glib_msize_type
2661 #define G_MAXSSIZE      G_MAX$glib_msize_type
2662
2663 typedef gint64 goffset;
2664 #define G_MINOFFSET     G_MININT64
2665 #define G_MAXOFFSET     G_MAXINT64
2666
2667 _______EOF
2668
2669         if test -z "$glib_unknown_void_p"; then
2670           cat >>$outfile <<_______EOF
2671
2672 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2673 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2674
2675 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2676 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2677 _______EOF
2678         else
2679           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2680         fi
2681
2682
2683
2684         cat >>$outfile <<_______EOF
2685 $glib_atexit
2686 $glib_memmove
2687 $glib_defines
2688 $glib_os
2689
2690 $glib_vacopy
2691
2692 #ifdef  __cplusplus
2693 #define G_HAVE_INLINE   1
2694 #else   /* !__cplusplus */
2695 $glib_inline
2696 #endif  /* !__cplusplus */
2697
2698 #ifdef  __cplusplus
2699 #define G_CAN_INLINE    1
2700 _______EOF
2701
2702         if test x$g_can_inline = xyes ; then
2703                 cat >>$outfile <<_______EOF
2704 #else   /* !__cplusplus */
2705 #define G_CAN_INLINE    1
2706 _______EOF
2707         fi
2708
2709         cat >>$outfile <<_______EOF
2710 #endif
2711
2712 _______EOF
2713
2714         if test x$g_have_iso_c_varargs = xyes ; then
2715                 cat >>$outfile <<_______EOF
2716 #ifndef __cplusplus
2717 # define G_HAVE_ISO_VARARGS 1
2718 #endif
2719 _______EOF
2720         fi
2721         if test x$g_have_iso_cxx_varargs = xyes ; then
2722                 cat >>$outfile <<_______EOF
2723 #ifdef __cplusplus
2724 # define G_HAVE_ISO_VARARGS 1
2725 #endif
2726 _______EOF
2727         fi
2728         if test x$g_have_gnuc_varargs = xyes ; then
2729                 cat >>$outfile <<_______EOF
2730
2731 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2732  * is passed ISO vararg support is turned off, and there is no work
2733  * around to turn it on, so we unconditionally turn it off.
2734  */
2735 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2736 #  undef G_HAVE_ISO_VARARGS
2737 #endif
2738
2739 #define G_HAVE_GNUC_VARARGS 1
2740 _______EOF
2741         fi
2742
2743         case x$g_stack_grows in
2744         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2745         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2746         esac
2747
2748
2749         echo >>$outfile
2750         if test x$g_have_eilseq = xno; then
2751                 cat >>$outfile <<_______EOF
2752 #ifndef EILSEQ
2753 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2754  * The correspondence between this and the corresponding definition
2755  * in libiconv is essential.
2756  */
2757 #  define EILSEQ ENOENT
2758 #endif
2759 _______EOF
2760
2761         fi
2762
2763         if test x$g_have_gnuc_visibility = xyes; then
2764                 cat >>$outfile <<_______EOF
2765 #define G_HAVE_GNUC_VISIBILITY 1
2766 _______EOF
2767         fi
2768                 cat >>$outfile <<_______EOF
2769 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2770 #define G_GNUC_INTERNAL __hidden
2771 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2772 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2773 #else
2774 #define G_GNUC_INTERNAL
2775 #endif
2776 _______EOF
2777
2778
2779         echo >>$outfile
2780         if test x$g_mutex_has_default = xyes; then
2781                 cat >>$outfile <<_______EOF
2782 $g_enable_threads_def G_THREADS_ENABLED
2783 #define G_THREADS_IMPL_$g_threads_impl_def
2784 typedef struct _GStaticMutex GStaticMutex;
2785 struct _GStaticMutex
2786 {
2787   struct _GMutex *runtime_mutex;
2788   union {
2789     char   pad[[$g_mutex_sizeof]];
2790     double dummy_double;
2791     void  *dummy_pointer;
2792     long   dummy_long;
2793   } static_mutex;
2794 };
2795 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2796 #define g_static_mutex_get_mutex(mutex) \\
2797   (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2798    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2799 _______EOF
2800         else
2801                 cat >>$outfile <<_______EOF
2802 $g_enable_threads_def G_THREADS_ENABLED
2803 #define G_THREADS_IMPL_$g_threads_impl_def
2804 typedef struct _GMutex* GStaticMutex;
2805 #define G_STATIC_MUTEX_INIT NULL
2806 #define g_static_mutex_get_mutex(mutex) \\
2807   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2808 _______EOF
2809         fi
2810
2811         cat >>$outfile <<_______EOF
2812 /* This represents a system thread as used by the implementation. An
2813  * alien implementaion, as loaded by g_thread_init can only count on
2814  * "sizeof (gpointer)" bytes to store their info. We however need more
2815  * for some of our native implementations. */
2816 typedef union _GSystemThread GSystemThread;
2817 union _GSystemThread
2818 {
2819   char   data[[$g_system_thread_sizeof]];
2820   double dummy_double;
2821   void  *dummy_pointer;
2822   long   dummy_long;
2823 };
2824 _______EOF
2825         if test x"$g_memory_barrier_needed" != xno; then
2826           echo >>$outfile
2827           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2828         fi
2829
2830         echo >>$outfile
2831         g_bit_sizes="16 32 64"
2832         for bits in $g_bit_sizes; do
2833           cat >>$outfile <<_______EOF
2834 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2835 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2836 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2837 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2838 _______EOF
2839         done
2840
2841         cat >>$outfile <<_______EOF
2842 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2843 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2844 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2845 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2846 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2847 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2848 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2849 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2850 #define G_BYTE_ORDER $g_byte_order
2851
2852 #define GLIB_SYSDEF_POLLIN =$g_pollin
2853 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2854 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2855 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2856 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2857 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2858
2859 #define G_MODULE_SUFFIX "$g_module_suffix"
2860
2861 typedef $g_pid_type GPid;
2862
2863 G_END_DECLS
2864
2865 #endif /* GLIBCONFIG_H */
2866 _______EOF
2867
2868
2869         if cmp -s $outfile glibconfig.h; then
2870           AC_MSG_NOTICE([glibconfig.h is unchanged])
2871           rm -f $outfile
2872         else
2873           mv $outfile glibconfig.h
2874         fi
2875 ],[
2876
2877 # Note that if two cases are the same, case goes with the first one.
2878 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2879 # on variable expansion in case labels.  Look at the generated config.status
2880 # for a hint.
2881
2882 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2883   glib_header_alloca_h="$ac_cv_working_alloca_h"
2884 else
2885   glib_header_alloca_h="$ac_cv_header_alloca_h"
2886 fi
2887
2888 case xyes in
2889 x$ac_cv_header_float_h)
2890   glib_float_h=yes
2891   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2892   glib_md=DBL_MIN glib_Md=DBL_MAX
2893   ;;
2894 x$ac_cv_header_values_h)
2895   glib_values_h=yes
2896   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2897   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2898   ;;
2899 esac
2900
2901 case xyes in
2902 x$ac_cv_header_limits_h)
2903   glib_limits_h=yes
2904   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2905   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2906   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2907   ;;
2908 x$ac_cv_header_values_h)
2909   glib_values_h=yes
2910   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2911   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2912   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2913   ;;
2914 esac
2915
2916 if test x$ac_cv_header_sys_poll_h = xyes ; then
2917   glib_sys_poll_h=yes
2918 fi
2919
2920 case 2 in
2921 $ac_cv_sizeof_short)
2922   gint16=short
2923   gint16_modifier='"h"'
2924   gint16_format='"hi"'
2925   guint16_format='"hu"'
2926   ;;
2927 $ac_cv_sizeof_int)
2928   gint16=int
2929   gint16_modifier='""'
2930   gint16_format='"i"'
2931   guint16_format='"u"'
2932   ;;
2933 esac
2934 case 4 in
2935 $ac_cv_sizeof_short)
2936   gint32=short
2937   gint32_modifier='"h"'
2938   gint32_format='"hi"'
2939   guint32_format='"hu"'
2940   ;;
2941 $ac_cv_sizeof_int)
2942   gint32=int
2943   gint32_modifier='""'
2944   gint32_format='"i"'
2945   guint32_format='"u"'
2946   ;;
2947 $ac_cv_sizeof_long)
2948   gint32=long
2949   gint32_modifier='"l"'
2950   gint32_format='"li"'
2951   guint32_format='"lu"'
2952   ;;
2953 esac
2954 case 8 in
2955 $ac_cv_sizeof_int)
2956   gint64=int
2957   gint64_modifier='""'
2958   gint64_format='"i"'
2959   guint64_format='"u"'
2960   glib_extension=
2961   gint64_constant='(val)'
2962   guint64_constant='(val)'
2963   ;;
2964 $ac_cv_sizeof_long)
2965   gint64=long
2966   gint64_modifier='"l"'
2967   gint64_format='"li"'
2968   guint64_format='"lu"'
2969   glib_extension=
2970   gint64_constant='(val##L)'
2971   guint64_constant='(val##UL)'
2972   ;;
2973 $ac_cv_sizeof_long_long)
2974   gint64='long long'
2975   if test -n "$glib_cv_long_long_format"; then
2976     gint64_modifier='"'$glib_cv_long_long_format'"'
2977     gint64_format='"'$glib_cv_long_long_format'i"'
2978     guint64_format='"'$glib_cv_long_long_format'u"'
2979   fi
2980   glib_extension='G_GNUC_EXTENSION '
2981   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2982   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
2983   ;;
2984 $ac_cv_sizeof___int64)
2985   gint64='__int64'
2986   if test -n "$glib_cv_long_long_format"; then
2987     gint64_modifier='"'$glib_cv_long_long_format'"'
2988     gint64_format='"'$glib_cv_long_long_format'i"'
2989     guint64_format='"'$glib_cv_long_long_format'u"'
2990   fi
2991   glib_extension=
2992   gint64_constant='(val##i64)'
2993   guint64_constant='(val##ui64)'
2994   ;;
2995 esac
2996 glib_size_t=$ac_cv_sizeof_size_t
2997 glib_size_type_define=$glib_size_type
2998 glib_void_p=$ac_cv_sizeof_long
2999 glib_long=$ac_cv_sizeof_void_p
3000
3001 case $glib_size_type in
3002 short)
3003   gsize_modifier='"h"'
3004   gsize_format='"hu"'
3005   gssize_format='"hi"'
3006   glib_msize_type='SHRT'
3007   ;;
3008 int)
3009   gsize_modifier='""'
3010   gsize_format='"u"'
3011   gssize_format='"i"'
3012   glib_msize_type='INT'
3013   ;;
3014 long)
3015   gsize_modifier='"l"'
3016   gsize_format='"lu"'
3017   gssize_format='"li"'
3018   glib_msize_type='LONG'
3019   ;;
3020 esac
3021
3022 gintbits=`expr $ac_cv_sizeof_int \* 8`
3023 glongbits=`expr $ac_cv_sizeof_long \* 8`
3024
3025
3026 case $ac_cv_sizeof_void_p in
3027 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
3028 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
3029 *)                      glib_unknown_void_p=yes ;;
3030 esac
3031
3032
3033 case xyes in
3034 x$ac_cv_func_atexit)
3035   glib_atexit="
3036 #ifdef NeXT /* @#%@! NeXTStep */
3037 # define g_ATEXIT(proc) (!atexit (proc))
3038 #else
3039 # define g_ATEXIT(proc) (atexit (proc))
3040 #endif"
3041   ;;
3042 x$ac_cv_func_on_exit)
3043   glib_atexit="
3044 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
3045   ;;
3046 esac
3047
3048 case xyes in
3049 x$ac_cv_func_memmove)
3050   glib_memmove='
3051 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3052   ;;
3053 x$glib_cv_working_bcopy)
3054   glib_memmove="
3055 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3056 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3057   ;;
3058 *)
3059   glib_memmove="
3060 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3061  * so we have to roll our own copy routine. */
3062 void g_memmove (void* dest, const void * src, unsigned long len);"
3063   ;;
3064 esac
3065
3066 glib_defines="
3067 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3068 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3069 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3070 "
3071
3072 case xyes in
3073 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3074 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3075 *)                      glib_vacopy=''
3076 esac
3077
3078 if test x$glib_cv_va_val_copy = xno; then
3079   glib_vacopy="\$glib_vacopy
3080 #define G_VA_COPY_AS_ARRAY 1"
3081 fi
3082
3083 if test x$glib_cv_hasinline = xyes; then
3084     glib_inline='#define G_HAVE_INLINE 1'
3085 fi
3086 if test x$glib_cv_has__inline = xyes; then
3087     glib_inline="\$glib_inline
3088 #define G_HAVE___INLINE 1"
3089 fi
3090 if test x$glib_cv_has__inline__ = xyes; then
3091     glib_inline="\$glib_inline
3092 #define G_HAVE___INLINE__ 1"
3093 fi
3094
3095 g_have_gnuc_varargs=$g_have_gnuc_varargs
3096 g_have_iso_c_varargs=$g_have_iso_c_varargs
3097 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3098
3099 g_can_inline=$g_can_inline
3100 g_have_gnuc_visibility=$g_have_gnuc_visibility
3101 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3102
3103 case xyes in
3104 x$ac_cv_c_bigendian)
3105   g_byte_order=G_BIG_ENDIAN
3106   g_bs_native=BE
3107   g_bs_alien=LE
3108   ;;
3109 *)
3110   g_byte_order=G_LITTLE_ENDIAN
3111   g_bs_native=LE
3112   g_bs_alien=BE
3113   ;;
3114 esac
3115
3116 g_pollin=$glib_cv_value_POLLIN
3117 g_pollout=$glib_cv_value_POLLOUT
3118 g_pollpri=$glib_cv_value_POLLPRI
3119 g_pollhup=$glib_cv_value_POLLHUP
3120 g_pollerr=$glib_cv_value_POLLERR
3121 g_pollnval=$glib_cv_value_POLLNVAL
3122
3123 g_stack_grows=$glib_cv_stack_grows
3124
3125 g_have_eilseq=$have_eilseq
3126
3127 case x$have_threads in
3128 xno)    g_enable_threads_def="#undef";;
3129 *)      g_enable_threads_def="#define";;
3130 esac
3131
3132 g_threads_impl_def=$g_threads_impl
3133
3134 g_mutex_has_default="$mutex_has_default"
3135 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3136 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3137 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3138
3139 g_memory_barrier_needed="$glib_memory_barrier_needed"
3140
3141 g_module_suffix="$glib_gmodule_suffix"
3142
3143 g_pid_type="$glib_pid_type"
3144 case $host in
3145   *-*-beos*)
3146     glib_os="#define G_OS_BEOS"
3147     ;;
3148   *-*-cygwin*)
3149     glib_os="#define G_OS_UNIX
3150 #define G_PLATFORM_WIN32
3151 #define G_WITH_CYGWIN"
3152     ;;
3153   *-*-mingw*)
3154     glib_os="#define G_OS_WIN32
3155 #define G_PLATFORM_WIN32"
3156     ;;
3157   *)
3158     glib_os="#define G_OS_UNIX"
3159     ;;
3160 esac
3161 ])
3162
3163 AC_CONFIG_FILES([
3164 glib-2.0.pc
3165 glib-2.0-uninstalled.pc
3166 gmodule-2.0.pc
3167 gmodule-export-2.0.pc
3168 gmodule-no-export-2.0.pc
3169 gmodule-2.0-uninstalled.pc
3170 gmodule-no-export-2.0-uninstalled.pc
3171 gthread-2.0.pc
3172 gthread-2.0-uninstalled.pc
3173 gobject-2.0.pc
3174 gobject-2.0-uninstalled.pc
3175 gio-2.0.pc
3176 gio-unix-2.0.pc
3177 gio-2.0-uninstalled.pc
3178 gio-unix-2.0-uninstalled.pc
3179 glib-zip
3180 glib-gettextize
3181 Makefile
3182 build/Makefile
3183 build/win32/Makefile
3184 build/win32/dirent/Makefile
3185 build/win32/vs8/Makefile
3186 glib/Makefile
3187 glib/libcharset/Makefile
3188 glib/gnulib/Makefile
3189 glib/pcre/Makefile
3190 glib/update-pcre/Makefile
3191 glib/tests/Makefile
3192 gmodule/Makefile
3193 gmodule/gmoduleconf.h
3194 gobject/Makefile
3195 gobject/glib-mkenums
3196 gthread/Makefile
3197 gio/Makefile
3198 gio/xdgmime/Makefile
3199 gio/inotify/Makefile
3200 gio/fam/Makefile
3201 po/Makefile.in
3202 docs/Makefile
3203 docs/reference/Makefile
3204 docs/reference/glib/Makefile
3205 docs/reference/glib/version.xml
3206 docs/reference/gobject/Makefile
3207 docs/reference/gobject/version.xml
3208 docs/reference/gio/Makefile
3209 docs/reference/gio/version.xml
3210 tests/Makefile
3211 tests/gobject/Makefile
3212 tests/refcount/Makefile
3213 m4macros/Makefile
3214 ])
3215
3216 AC_CONFIG_COMMANDS([chmod-scripts],
3217 [chmod 0755 glib-zip
3218 chmod 0755 glib-gettextize
3219 chmod 0755 gobject/glib-mkenums])
3220
3221 # we want to invoke this macro solely so that the config.status script
3222 # and automake generated makefiles know about these generated files.
3223 # They are only needed to distcheck the package
3224 if false; then
3225   AC_CONFIG_FILES([
3226     INSTALL
3227     README
3228     config.h.win32
3229     glibconfig.h.win32
3230     glib/makefile.msc
3231     glib/glib.rc
3232     gmodule/makefile.msc
3233     gmodule/gmodule.rc
3234     gobject/makefile.msc
3235     gobject/gobject.rc
3236     gthread/makefile.msc
3237     gthread/gthread.rc
3238     tests/makefile.msc
3239   ])
3240 fi
3241
3242 AC_OUTPUT