configure.in

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