configure.in

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