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