configure.in

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