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 gl_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 AM_LANGINFO_CODESET
 843 gl_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 else
2371   if test $glib_native_win32 = yes; then
2372     # For Windows but not using gcc. No barriers needed then either.
2373     glib_memory_barrier_needed=no
2374   fi
2375 fi
2376
2377 dnl ****************************************
2378 dnl *** GLib POLL* compatibility defines ***
2379 dnl ****************************************
2380
2381 glib_poll_includes=["
2382 #include <sys/types.h>
2383 #include <sys/poll.h>
2384 "]
2385
2386 if test $ac_cv_header_sys_types_h = yes &&
2387    test $ac_cv_header_sys_poll_h = yes ; then
2388   glib_failed=false
2389   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2390   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2391   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2392   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2393   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2394   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2395   if $glib_failed ; then
2396     AC_MSG_ERROR([Could not determine values for POLL* constants])
2397   fi
2398 else
2399   glib_cv_value_POLLIN=1
2400   glib_cv_value_POLLOUT=4
2401   glib_cv_value_POLLPRI=2
2402   glib_cv_value_POLLERR=8
2403   glib_cv_value_POLLHUP=16
2404   glib_cv_value_POLLNVAL=32
2405 fi
2406
2407 AC_MSG_CHECKING([for broken poll])
2408 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2409         #include <stdlib.h>
2410         #include <fcntl.h>
2411         #include <poll.h>
2412         #ifdef HAVE_SYS_POLL_H
2413         #include <sys/poll.h>
2414         #endif
2415         int main(void) {
2416           struct pollfd fds[1];
2417           int fd;
2418           fd = open("/dev/null", 1);
2419           fds[0].fd = fd;
2420           fds[0].events = POLLIN;
2421           fds[0].revents = 0;
2422           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2423                 exit(1);  /* Does not work for devices -- fail */
2424           }
2425           exit(0);
2426         }]])],
2427   [broken_poll=no],
2428   [broken_poll=yes
2429    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2430   [broken_poll="no (cross compiling)"])
2431 AC_MSG_RESULT($broken_poll)
2432
2433 dnl *********************
2434 dnl *** GRegex checks ***
2435 dnl *********************
2436 PCRE_REQUIRED_VERSION=7.2
2437
2438 # Check if we should compile GRegex
2439 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2440               [disable the compilation of GRegex]),
2441 [case "${enableval}" in
2442   yes) enable_regex=true ;;
2443   no)  enable_regex=false ;;
2444   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2445 esac],
2446 [enable_regex=true])
2447
2448 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2449
2450 if test x$enable_regex = xtrue; then
2451   # Check if we should use the internal or the system-supplied pcre
2452   AC_ARG_WITH(pcre,
2453              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2454                              [specify whether to use the internal or the
2455                               system-supplied PCRE library])])
2456
2457   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2458
2459   if test "x$with_pcre" = xsystem; then
2460     PKG_CHECK_MODULES(PCRE,
2461                       libpcre >= $PCRE_REQUIRED_VERSION)
2462     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2463                    glib_save_CFLAGS="$CFLAGS"
2464                    glib_save_LIBS="$LIBS"
2465                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2466                    AC_TRY_RUN([#include <pcre.h>
2467                                int main () {
2468                                  int support;
2469                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2470                                  if (!support)
2471                                    return 1;
2472                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2473                                  if (!support)
2474                                    return 1;
2475                                  return 0;
2476                                }],
2477                    glib_cv_pcre_has_unicode=yes,
2478                    glib_cv_pcre_has_unicode=no,
2479                    glib_cv_pcre_has_unicode=yes)
2480                    CFLAGS="$glib_save_CFLAGS"
2481                    LIBS="$glib_save_LIBS"
2482         ])
2483     if test "$glib_cv_pcre_has_unicode" = "no"; then
2484       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2485     fi
2486     AC_SUBST(PCRE_CFLAGS)
2487     AC_SUBST(PCRE_LIBS)
2488     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2489     PCRE_REQUIRES=libpcre
2490     AC_SUBST(PCRE_REQUIRES)
2491   else
2492     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2493     if test x"$GCC" = xyes; then
2494       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2495       save_CFLAGS="$CFLAGS"
2496       CFLAGS="$CFLAGS -Wno-pointer-sign"
2497       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2498                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2499       CFLAGS="$save_CFLAGS"
2500     fi
2501   fi
2502   AC_SUBST(PCRE_WARN_CFLAGS)
2503 else
2504   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2505 fi
2506
2507 dnl **********************
2508 dnl *** Win32 API libs ***
2509 dnl **********************
2510
2511 case $host in
2512   *-*-cygwin*)
2513         G_LIBS_EXTRA="-luser32 -lkernel32"
2514     ;;
2515   *-*-mingw*)
2516         G_LIBS_EXTRA="-lws2_32 -lole32"
2517     ;;
2518   *)
2519         G_LIBS_EXTRA=""
2520     ;;
2521 esac
2522 AC_SUBST(G_LIBS_EXTRA)
2523
2524 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2525 dnl since we need it for g_iconv()
2526
2527 AC_MSG_CHECKING([for EILSEQ])
2528 AC_TRY_COMPILE([
2529 #include <errno.h>
2530 ],
2531 [
2532 int error = EILSEQ;
2533 ], have_eilseq=yes, have_eilseq=no);
2534 AC_MSG_RESULT($have_eilseq)
2535
2536 dnl ******************************************************************
2537 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2538 dnl ******************************************************************
2539
2540 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2541
2542 if test $cross_compiling = yes; then
2543   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2544   if test x$GLIB_GENMARSHAL = xno; then
2545     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2546   fi
2547 fi
2548
2549 dnl **************************
2550 dnl *** Checks for gtk-doc ***
2551 dnl **************************
2552
2553 GTK_DOC_CHECK([1.8])
2554
2555 AC_ARG_ENABLE(man,
2556               [AC_HELP_STRING([--enable-man],
2557                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2558               enable_man=no)
2559
2560 if test "${enable_man}" != no; then
2561 dnl
2562 dnl Check for xsltproc
2563 dnl
2564 AC_PATH_PROG([XSLTPROC], [xsltproc])
2565   if test -z "$XSLTPROC"; then
2566     enable_man=no
2567   fi
2568
2569   dnl check for DocBook DTD and stylesheets in the local catalog.
2570   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2571      [DocBook XML DTD V4.1.2],,enable_man=no)
2572   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2573      [DocBook XSL Stylesheets],,enable_man=no)
2574 fi
2575
2576 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2577
2578 dnl ******************************
2579 dnl *** output the whole stuff ***
2580 dnl ******************************
2581
2582 dnl this section will only be run if config.status is invoked with no
2583 dnl arguments, or with "glibconfig.h" as an argument.
2584 AC_CONFIG_COMMANDS([glibconfig.h],
2585 [
2586         outfile=glibconfig.h-tmp
2587         cat > $outfile <<\_______EOF
2588 /* glibconfig.h
2589  *
2590  * This is a generated file.  Please modify 'configure.in'
2591  */
2592
2593 #ifndef __G_LIBCONFIG_H__
2594 #define __G_LIBCONFIG_H__
2595
2596 #include <glib/gmacros.h>
2597
2598 _______EOF
2599
2600         if test x$glib_limits_h = xyes; then
2601           echo '#include <limits.h>' >> $outfile
2602         fi
2603         if test x$glib_float_h = xyes; then
2604           echo '#include <float.h>' >> $outfile
2605         fi
2606         if test x$glib_values_h = xyes; then
2607           echo '#include <values.h>' >> $outfile
2608         fi
2609         if test "$glib_header_alloca_h" = "yes"; then
2610           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2611         fi
2612         if test x$glib_sys_poll_h = xyes; then
2613           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2614         fi
2615
2616         cat >> $outfile <<_______EOF
2617
2618 G_BEGIN_DECLS
2619
2620 #define G_MINFLOAT      $glib_mf
2621 #define G_MAXFLOAT      $glib_Mf
2622 #define G_MINDOUBLE     $glib_md
2623 #define G_MAXDOUBLE     $glib_Md
2624 #define G_MINSHORT      $glib_ms
2625 #define G_MAXSHORT      $glib_Ms
2626 #define G_MAXUSHORT     $glib_Mus
2627 #define G_MININT        $glib_mi
2628 #define G_MAXINT        $glib_Mi
2629 #define G_MAXUINT       $glib_Mui
2630 #define G_MINLONG       $glib_ml
2631 #define G_MAXLONG       $glib_Ml
2632 #define G_MAXULONG      $glib_Mul
2633
2634 _______EOF
2635
2636
2637         ### this should always be true in a modern C/C++ compiler
2638         cat >>$outfile <<_______EOF
2639 typedef signed char gint8;
2640 typedef unsigned char guint8;
2641 _______EOF
2642
2643
2644         if test -n "$gint16"; then
2645           cat >>$outfile <<_______EOF
2646 typedef signed $gint16 gint16;
2647 typedef unsigned $gint16 guint16;
2648 #define G_GINT16_MODIFIER $gint16_modifier
2649 #define G_GINT16_FORMAT $gint16_format
2650 #define G_GUINT16_FORMAT $guint16_format
2651 _______EOF
2652         fi
2653
2654
2655         if test -n "$gint32"; then
2656           cat >>$outfile <<_______EOF
2657 typedef signed $gint32 gint32;
2658 typedef unsigned $gint32 guint32;
2659 #define G_GINT32_MODIFIER $gint32_modifier
2660 #define G_GINT32_FORMAT $gint32_format
2661 #define G_GUINT32_FORMAT $guint32_format
2662 _______EOF
2663         fi
2664
2665         cat >>$outfile <<_______EOF
2666 #define G_HAVE_GINT64 1          /* deprecated, always true */
2667
2668 ${glib_extension}typedef signed $gint64 gint64;
2669 ${glib_extension}typedef unsigned $gint64 guint64;
2670
2671 #define G_GINT64_CONSTANT(val)  $gint64_constant
2672 #define G_GUINT64_CONSTANT(val) $guint64_constant
2673 _______EOF
2674
2675         if test x$gint64_format != x ; then
2676           cat >>$outfile <<_______EOF
2677 #define G_GINT64_MODIFIER $gint64_modifier
2678 #define G_GINT64_FORMAT $gint64_format
2679 #define G_GUINT64_FORMAT $guint64_format
2680 _______EOF
2681         else
2682           cat >>$outfile <<_______EOF
2683 #undef G_GINT64_MODIFIER
2684 #undef G_GINT64_FORMAT
2685 #undef G_GUINT64_FORMAT
2686 _______EOF
2687         fi
2688
2689         cat >>$outfile <<_______EOF
2690
2691 #define GLIB_SIZEOF_VOID_P $glib_void_p
2692 #define GLIB_SIZEOF_LONG   $glib_long
2693 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2694
2695 _______EOF
2696
2697         cat >>$outfile <<_______EOF
2698 typedef signed $glib_size_type_define gssize;
2699 typedef unsigned $glib_size_type_define gsize;
2700 #define G_GSIZE_MODIFIER $gsize_modifier
2701 #define G_GSSIZE_FORMAT $gssize_format
2702 #define G_GSIZE_FORMAT $gsize_format
2703
2704 #define G_MAXSIZE       G_MAXU$glib_msize_type
2705 #define G_MINSSIZE      G_MIN$glib_msize_type
2706 #define G_MAXSSIZE      G_MAX$glib_msize_type
2707
2708 typedef gint64 goffset;
2709 #define G_MINOFFSET     G_MININT64
2710 #define G_MAXOFFSET     G_MAXINT64
2711
2712 _______EOF
2713
2714         if test -z "$glib_unknown_void_p"; then
2715           cat >>$outfile <<_______EOF
2716
2717 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2718 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2719
2720 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2721 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2722 _______EOF
2723         else
2724           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2725         fi
2726
2727
2728
2729         cat >>$outfile <<_______EOF
2730 $glib_atexit
2731 $glib_memmove
2732 $glib_defines
2733 $glib_os
2734 $glib_static_compilation
2735
2736 $glib_vacopy
2737
2738 #ifdef  __cplusplus
2739 #define G_HAVE_INLINE   1
2740 #else   /* !__cplusplus */
2741 $glib_inline
2742 #endif  /* !__cplusplus */
2743
2744 #ifdef  __cplusplus
2745 #define G_CAN_INLINE    1
2746 _______EOF
2747
2748         if test x$g_can_inline = xyes ; then
2749                 cat >>$outfile <<_______EOF
2750 #else   /* !__cplusplus */
2751 #define G_CAN_INLINE    1
2752 _______EOF
2753         fi
2754
2755         cat >>$outfile <<_______EOF
2756 #endif
2757
2758 _______EOF
2759
2760         if test x$g_have_iso_c_varargs = xyes ; then
2761                 cat >>$outfile <<_______EOF
2762 #ifndef __cplusplus
2763 # define G_HAVE_ISO_VARARGS 1
2764 #endif
2765 _______EOF
2766         fi
2767         if test x$g_have_iso_cxx_varargs = xyes ; then
2768                 cat >>$outfile <<_______EOF
2769 #ifdef __cplusplus
2770 # define G_HAVE_ISO_VARARGS 1
2771 #endif
2772 _______EOF
2773         fi
2774         if test x$g_have_gnuc_varargs = xyes ; then
2775                 cat >>$outfile <<_______EOF
2776
2777 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2778  * is passed ISO vararg support is turned off, and there is no work
2779  * around to turn it on, so we unconditionally turn it off.
2780  */
2781 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2782 #  undef G_HAVE_ISO_VARARGS
2783 #endif
2784
2785 #define G_HAVE_GNUC_VARARGS 1
2786 _______EOF
2787         fi
2788
2789         case x$g_stack_grows in
2790         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2791         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2792         esac
2793
2794
2795         echo >>$outfile
2796         if test x$g_have_eilseq = xno; then
2797                 cat >>$outfile <<_______EOF
2798 #ifndef EILSEQ
2799 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2800  * The correspondence between this and the corresponding definition
2801  * in libiconv is essential.
2802  */
2803 #  define EILSEQ ENOENT
2804 #endif
2805 _______EOF
2806
2807         fi
2808
2809         if test x$g_have_gnuc_visibility = xyes; then
2810                 cat >>$outfile <<_______EOF
2811 #define G_HAVE_GNUC_VISIBILITY 1
2812 _______EOF
2813         fi
2814                 cat >>$outfile <<_______EOF
2815 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2816 #define G_GNUC_INTERNAL __hidden
2817 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2818 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2819 #else
2820 #define G_GNUC_INTERNAL
2821 #endif
2822 _______EOF
2823
2824
2825         echo >>$outfile
2826         if test x$g_mutex_has_default = xyes; then
2827                 cat >>$outfile <<_______EOF
2828 $g_enable_threads_def G_THREADS_ENABLED
2829 #define G_THREADS_IMPL_$g_threads_impl_def
2830 typedef struct _GStaticMutex GStaticMutex;
2831 struct _GStaticMutex
2832 {
2833   struct _GMutex *runtime_mutex;
2834   union {
2835     char   pad[[$g_mutex_sizeof]];
2836     double dummy_double;
2837     void  *dummy_pointer;
2838     long   dummy_long;
2839   } static_mutex;
2840 };
2841 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2842 #ifdef __cplusplus
2843 #define g_static_mutex_get_mutex(mutex) \\
2844   (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2845    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2846 #else
2847 #define g_static_mutex_get_mutex(mutex) \\
2848   (g_thread_use_default_impl ? ((GMutex*) (void*) ((mutex)->static_mutex.pad)) : \\
2849    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2850 #endif
2851 _______EOF
2852         else
2853                 cat >>$outfile <<_______EOF
2854 $g_enable_threads_def G_THREADS_ENABLED
2855 #define G_THREADS_IMPL_$g_threads_impl_def
2856 typedef struct _GMutex* GStaticMutex;
2857 #define G_STATIC_MUTEX_INIT NULL
2858 #define g_static_mutex_get_mutex(mutex) \\
2859   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2860 _______EOF
2861         fi
2862
2863         cat >>$outfile <<_______EOF
2864 /* This represents a system thread as used by the implementation. An
2865  * alien implementaion, as loaded by g_thread_init can only count on
2866  * "sizeof (gpointer)" bytes to store their info. We however need more
2867  * for some of our native implementations. */
2868 typedef union _GSystemThread GSystemThread;
2869 union _GSystemThread
2870 {
2871   char   data[[$g_system_thread_sizeof]];
2872   double dummy_double;
2873   void  *dummy_pointer;
2874   long   dummy_long;
2875 };
2876 _______EOF
2877         if test x"$g_memory_barrier_needed" != xno; then
2878           echo >>$outfile
2879           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2880         fi
2881
2882         echo >>$outfile
2883         g_bit_sizes="16 32 64"
2884         for bits in $g_bit_sizes; do
2885           cat >>$outfile <<_______EOF
2886 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2887 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2888 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2889 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2890 _______EOF
2891         done
2892
2893         cat >>$outfile <<_______EOF
2894 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2895 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2896 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2897 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2898 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2899 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2900 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2901 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2902 #define G_BYTE_ORDER $g_byte_order
2903
2904 #define GLIB_SYSDEF_POLLIN =$g_pollin
2905 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2906 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2907 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2908 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2909 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2910
2911 #define G_MODULE_SUFFIX "$g_module_suffix"
2912
2913 typedef $g_pid_type GPid;
2914
2915 G_END_DECLS
2916
2917 #endif /* GLIBCONFIG_H */
2918 _______EOF
2919
2920
2921         if cmp -s $outfile glibconfig.h; then
2922           AC_MSG_NOTICE([glibconfig.h is unchanged])
2923           rm -f $outfile
2924         else
2925           mv $outfile glibconfig.h
2926         fi
2927 ],[
2928
2929 # Note that if two cases are the same, case goes with the first one.
2930 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2931 # on variable expansion in case labels.  Look at the generated config.status
2932 # for a hint.
2933
2934 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2935   glib_header_alloca_h="$ac_cv_working_alloca_h"
2936 else
2937   glib_header_alloca_h="$ac_cv_header_alloca_h"
2938 fi
2939
2940 case xyes in
2941 x$ac_cv_header_float_h)
2942   glib_float_h=yes
2943   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2944   glib_md=DBL_MIN glib_Md=DBL_MAX
2945   ;;
2946 x$ac_cv_header_values_h)
2947   glib_values_h=yes
2948   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2949   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2950   ;;
2951 esac
2952
2953 case xyes in
2954 x$ac_cv_header_limits_h)
2955   glib_limits_h=yes
2956   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2957   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2958   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2959   ;;
2960 x$ac_cv_header_values_h)
2961   glib_values_h=yes
2962   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2963   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2964   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2965   ;;
2966 esac
2967
2968 if test x$ac_cv_header_sys_poll_h = xyes ; then
2969   glib_sys_poll_h=yes
2970 fi
2971
2972 case 2 in
2973 $ac_cv_sizeof_short)
2974   gint16=short
2975   gint16_modifier='"h"'
2976   gint16_format='"hi"'
2977   guint16_format='"hu"'
2978   ;;
2979 $ac_cv_sizeof_int)
2980   gint16=int
2981   gint16_modifier='""'
2982   gint16_format='"i"'
2983   guint16_format='"u"'
2984   ;;
2985 esac
2986 case 4 in
2987 $ac_cv_sizeof_short)
2988   gint32=short
2989   gint32_modifier='"h"'
2990   gint32_format='"hi"'
2991   guint32_format='"hu"'
2992   ;;
2993 $ac_cv_sizeof_int)
2994   gint32=int
2995   gint32_modifier='""'
2996   gint32_format='"i"'
2997   guint32_format='"u"'
2998   ;;
2999 $ac_cv_sizeof_long)
3000   gint32=long
3001   gint32_modifier='"l"'
3002   gint32_format='"li"'
3003   guint32_format='"lu"'
3004   ;;
3005 esac
3006 case 8 in
3007 $ac_cv_sizeof_int)
3008   gint64=int
3009   gint64_modifier='""'
3010   gint64_format='"i"'
3011   guint64_format='"u"'
3012   glib_extension=
3013   gint64_constant='(val)'
3014   guint64_constant='(val)'
3015   ;;
3016 $ac_cv_sizeof_long)
3017   gint64=long
3018   gint64_modifier='"l"'
3019   gint64_format='"li"'
3020   guint64_format='"lu"'
3021   glib_extension=
3022   gint64_constant='(val##L)'
3023   guint64_constant='(val##UL)'
3024   ;;
3025 $ac_cv_sizeof_long_long)
3026   gint64='long long'
3027   if test -n "$glib_cv_long_long_format"; then
3028     gint64_modifier='"'$glib_cv_long_long_format'"'
3029     gint64_format='"'$glib_cv_long_long_format'i"'
3030     guint64_format='"'$glib_cv_long_long_format'u"'
3031   fi
3032   glib_extension='G_GNUC_EXTENSION '
3033   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3034   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3035   ;;
3036 $ac_cv_sizeof___int64)
3037   gint64='__int64'
3038   if test -n "$glib_cv_long_long_format"; then
3039     gint64_modifier='"'$glib_cv_long_long_format'"'
3040     gint64_format='"'$glib_cv_long_long_format'i"'
3041     guint64_format='"'$glib_cv_long_long_format'u"'
3042   fi
3043   glib_extension=
3044   gint64_constant='(val##i64)'
3045   guint64_constant='(val##ui64)'
3046   ;;
3047 esac
3048 glib_size_t=$ac_cv_sizeof_size_t
3049 glib_size_type_define=$glib_size_type
3050 glib_void_p=$ac_cv_sizeof_long
3051 glib_long=$ac_cv_sizeof_void_p
3052
3053 case $glib_size_type in
3054 short)
3055   gsize_modifier='"h"'
3056   gsize_format='"hu"'
3057   gssize_format='"hi"'
3058   glib_msize_type='SHRT'
3059   ;;
3060 int)
3061   gsize_modifier='""'
3062   gsize_format='"u"'
3063   gssize_format='"i"'
3064   glib_msize_type='INT'
3065   ;;
3066 long)
3067   gsize_modifier='"l"'
3068   gsize_format='"lu"'
3069   gssize_format='"li"'
3070   glib_msize_type='LONG'
3071   ;;
3072 esac
3073
3074 gintbits=`expr $ac_cv_sizeof_int \* 8`
3075 glongbits=`expr $ac_cv_sizeof_long \* 8`
3076
3077
3078 case $ac_cv_sizeof_void_p in
3079 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
3080 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
3081 *)                      glib_unknown_void_p=yes ;;
3082 esac
3083
3084
3085 case xyes in
3086 x$ac_cv_func_atexit)
3087   glib_atexit="
3088 #ifdef NeXT /* @#%@! NeXTStep */
3089 # define g_ATEXIT(proc) (!atexit (proc))
3090 #else
3091 # define g_ATEXIT(proc) (atexit (proc))
3092 #endif"
3093   ;;
3094 x$ac_cv_func_on_exit)
3095   glib_atexit="
3096 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
3097   ;;
3098 esac
3099
3100 case xyes in
3101 x$ac_cv_func_memmove)
3102   glib_memmove='
3103 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3104   ;;
3105 x$glib_cv_working_bcopy)
3106   glib_memmove="
3107 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3108 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3109   ;;
3110 *)
3111   glib_memmove="
3112 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3113  * so we have to roll our own copy routine. */
3114 void g_memmove (void* dest, const void * src, unsigned long len);"
3115   ;;
3116 esac
3117
3118 glib_defines="
3119 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3120 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3121 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3122 "
3123
3124 case xyes in
3125 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3126 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3127 *)                      glib_vacopy=''
3128 esac
3129
3130 if test x$glib_cv_va_val_copy = xno; then
3131   glib_vacopy="\$glib_vacopy
3132 #define G_VA_COPY_AS_ARRAY 1"
3133 fi
3134
3135 if test x$glib_cv_hasinline = xyes; then
3136     glib_inline='#define G_HAVE_INLINE 1'
3137 fi
3138 if test x$glib_cv_has__inline = xyes; then
3139     glib_inline="\$glib_inline
3140 #define G_HAVE___INLINE 1"
3141 fi
3142 if test x$glib_cv_has__inline__ = xyes; then
3143     glib_inline="\$glib_inline
3144 #define G_HAVE___INLINE__ 1"
3145 fi
3146
3147 g_have_gnuc_varargs=$g_have_gnuc_varargs
3148 g_have_iso_c_varargs=$g_have_iso_c_varargs
3149 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3150
3151 g_can_inline=$g_can_inline
3152 g_have_gnuc_visibility=$g_have_gnuc_visibility
3153 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3154
3155 case xyes in
3156 x$ac_cv_c_bigendian)
3157   g_byte_order=G_BIG_ENDIAN
3158   g_bs_native=BE
3159   g_bs_alien=LE
3160   ;;
3161 *)
3162   g_byte_order=G_LITTLE_ENDIAN
3163   g_bs_native=LE
3164   g_bs_alien=BE
3165   ;;
3166 esac
3167
3168 g_pollin=$glib_cv_value_POLLIN
3169 g_pollout=$glib_cv_value_POLLOUT
3170 g_pollpri=$glib_cv_value_POLLPRI
3171 g_pollhup=$glib_cv_value_POLLHUP
3172 g_pollerr=$glib_cv_value_POLLERR
3173 g_pollnval=$glib_cv_value_POLLNVAL
3174
3175 g_stack_grows=$glib_cv_stack_grows
3176
3177 g_have_eilseq=$have_eilseq
3178
3179 case x$have_threads in
3180 xno)    g_enable_threads_def="#undef";;
3181 *)      g_enable_threads_def="#define";;
3182 esac
3183
3184 g_threads_impl_def=$g_threads_impl
3185
3186 g_mutex_has_default="$mutex_has_default"
3187 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3188 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3189 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3190
3191 g_memory_barrier_needed="$glib_memory_barrier_needed"
3192
3193 g_module_suffix="$glib_gmodule_suffix"
3194
3195 g_pid_type="$glib_pid_type"
3196 case $host in
3197   *-*-beos*)
3198     glib_os="#define G_OS_BEOS"
3199     ;;
3200   *-*-cygwin*)
3201     glib_os="#define G_OS_UNIX
3202 #define G_PLATFORM_WIN32
3203 #define G_WITH_CYGWIN"
3204     ;;
3205   *-*-mingw*)
3206     glib_os="#define G_OS_WIN32
3207 #define G_PLATFORM_WIN32"
3208     ;;
3209   *)
3210     glib_os="#define G_OS_UNIX"
3211     ;;
3212 esac
3213 glib_static_compilation=""
3214 if test x$glib_win32_static_compilation = xyes; then
3215   glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3216 #define GOBJECT_STATIC_COMPILATION 1"
3217 fi
3218 ])
3219
3220 AC_CONFIG_FILES([
3221 glib-2.0.pc
3222 glib-2.0-uninstalled.pc
3223 gmodule-2.0.pc
3224 gmodule-export-2.0.pc
3225 gmodule-no-export-2.0.pc
3226 gmodule-2.0-uninstalled.pc
3227 gmodule-no-export-2.0-uninstalled.pc
3228 gthread-2.0.pc
3229 gthread-2.0-uninstalled.pc
3230 gobject-2.0.pc
3231 gobject-2.0-uninstalled.pc
3232 gio-2.0.pc
3233 gio-unix-2.0.pc
3234 gio-2.0-uninstalled.pc
3235 gio-unix-2.0-uninstalled.pc
3236 glib-zip
3237 glib-gettextize
3238 Makefile
3239 build/Makefile
3240 build/win32/Makefile
3241 build/win32/dirent/Makefile
3242 build/win32/vs8/Makefile
3243 glib/Makefile
3244 glib/libcharset/Makefile
3245 glib/gnulib/Makefile
3246 glib/pcre/Makefile
3247 glib/update-pcre/Makefile
3248 glib/tests/Makefile
3249 gmodule/Makefile
3250 gmodule/gmoduleconf.h
3251 gobject/Makefile
3252 gobject/glib-mkenums
3253 gobject/tests/Makefile
3254 gthread/Makefile
3255 gio/Makefile
3256 gio/xdgmime/Makefile
3257 gio/inotify/Makefile
3258 gio/fen/Makefile
3259 gio/fam/Makefile
3260 gio/win32/Makefile
3261 gio/tests/Makefile
3262 po/Makefile.in
3263 docs/Makefile
3264 docs/reference/Makefile
3265 docs/reference/glib/Makefile
3266 docs/reference/glib/version.xml
3267 docs/reference/gobject/Makefile
3268 docs/reference/gobject/version.xml
3269 docs/reference/gio/Makefile
3270 docs/reference/gio/version.xml
3271 tests/Makefile
3272 tests/gobject/Makefile
3273 tests/refcount/Makefile
3274 m4macros/Makefile
3275 ])
3276
3277 AC_CONFIG_COMMANDS([chmod-scripts],
3278 [chmod 0755 glib-zip
3279 chmod 0755 glib-gettextize
3280 chmod 0755 gobject/glib-mkenums])
3281
3282 # we want to invoke this macro solely so that the config.status script
3283 # and automake generated makefiles know about these generated files.
3284 # They are only needed to distcheck the package
3285 if false; then
3286   AC_CONFIG_FILES([
3287     INSTALL
3288     README
3289     config.h.win32
3290     glibconfig.h.win32
3291     glib/makefile.msc
3292     glib/glib.rc
3293     gmodule/makefile.msc
3294     gmodule/gmodule.rc
3295     gobject/makefile.msc
3296     gobject/gobject.rc
3297     gthread/makefile.msc
3298     gthread/gthread.rc
3299     tests/makefile.msc
3300   ])
3301 fi
3302
3303 AC_OUTPUT