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], [5])
  30 m4_define([glib_micro_version], [6])
  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 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 #  b) libtool doesn't recognize -pthread as a library dependency.
1840 #
1841 case $host in
1842   *-*-linux*)
1843     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1844     ;;
1845   *)
1846     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
1847     ;;
1848 esac
1849
1850 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1851                    [Source file containing theread implementation])
1852 AC_SUBST(G_THREAD_CFLAGS)
1853 AC_SUBST(G_THREAD_LIBS)
1854 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1855 AC_SUBST(G_THREAD_LIBS_EXTRA)
1856
1857 dnl **********************************************
1858 dnl *** GDefaultMutex setup and initialization ***
1859 dnl **********************************************
1860 dnl
1861 dnl if mutex_has_default = yes, we also got
1862 dnl mutex_default_type, mutex_default_init and mutex_header_file
1863 if test $mutex_has_default = yes ; then
1864         glib_save_CPPFLAGS="$CPPFLAGS"
1865         glib_save_LIBS="$LIBS"
1866         LIBS="$G_THREAD_LIBS $LIBS"
1867         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1868         GLIB_SIZEOF([#include <$mutex_header_file>],
1869                     $mutex_default_type,
1870                     gmutex)
1871         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1872                            $mutex_default_type,
1873                            gmutex,
1874                            $glib_cv_sizeof_gmutex,
1875                            $mutex_default_init)
1876         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1877                 mutex_has_default=no
1878         fi
1879         CPPFLAGS="$glib_save_CPPFLAGS"
1880         LIBS="$glib_save_LIBS"
1881 fi
1882
1883 dnl ********************************
1884 dnl *** g_atomic_* tests for gcc ***
1885 dnl ********************************
1886
1887 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1888
1889 if test x"$GCC" = xyes; then
1890   case $host_cpu in
1891     i386)
1892       AC_MSG_RESULT([none])
1893       glib_memory_barrier_needed=no
1894       ;;
1895     i?86)
1896       AC_MSG_RESULT([i486])
1897       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1898                          [i486 atomic implementation])
1899       glib_memory_barrier_needed=no
1900       ;;
1901     sparc*)
1902       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1903                 when you are using a sparc with v9 instruction set (most
1904                 sparcs nowadays). This will make the code for atomic
1905                 operations much faster. The resulting code will not run
1906                 on very old sparcs though."
1907
1908       AC_LINK_IFELSE([[
1909         main ()
1910         {
1911           int tmp1, tmp2, tmp3;
1912           __asm__ __volatile__("casx [%2], %0, %1"
1913                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1914         }]],
1915         AC_MSG_RESULT([sparcv9])
1916         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1917                            [sparcv9 atomic implementation]),
1918         AC_MSG_RESULT([no])
1919         AC_MSG_WARN([[$SPARCV9_WARNING]]))
1920       glib_memory_barrier_needed=yes
1921       ;;
1922     alpha*)
1923       AC_MSG_RESULT([alpha])
1924       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1925                          [alpha atomic implementation])
1926       glib_memory_barrier_needed=yes
1927       ;;
1928     x86_64)
1929       AC_MSG_RESULT([x86_64])
1930       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1931                          [x86_64 atomic implementation])
1932       glib_memory_barrier_needed=no
1933      ;;
1934     powerpc*)
1935       AC_MSG_RESULT([powerpc])
1936       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1937                          [powerpc atomic implementation])
1938       glib_memory_barrier_needed=yes
1939       ;;
1940     ia64)
1941       AC_MSG_RESULT([ia64])
1942       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1943                          [ia64 atomic implementation])
1944       glib_memory_barrier_needed=yes
1945       ;;
1946     *)
1947       AC_MSG_RESULT([none])
1948       glib_memory_barrier_needed=yes
1949       ;;
1950   esac
1951 fi
1952
1953 dnl ****************************************
1954 dnl *** GLib POLL* compatibility defines ***
1955 dnl ****************************************
1956
1957 glib_poll_includes=["
1958 #include <sys/types.h>
1959 #include <sys/poll.h>
1960 "]
1961
1962 if test $ac_cv_header_sys_types_h = yes &&
1963    test $ac_cv_header_sys_poll_h = yes ; then
1964   glib_failed=false
1965   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1966   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1967   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1968   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1969   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1970   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1971   if $glib_failed ; then
1972     AC_MSG_ERROR([Could not determine values for POLL* constants])
1973   fi
1974 else
1975   glib_cv_value_POLLIN=1
1976   glib_cv_value_POLLOUT=4
1977   glib_cv_value_POLLPRI=2
1978   glib_cv_value_POLLERR=8
1979   glib_cv_value_POLLHUP=16
1980   glib_cv_value_POLLNVAL=32
1981 fi
1982
1983 dnl **********************
1984 dnl *** Win32 API libs ***
1985 dnl **********************
1986
1987 case $host in
1988   *-*-cygwin*)
1989         G_LIBS_EXTRA="-luser32 -lkernel32"
1990     ;;
1991   *-*-mingw*)
1992         G_LIBS_EXTRA="-lwsock32 -lole32"
1993     ;;
1994   *)
1995         G_LIBS_EXTRA=""
1996     ;;
1997 esac
1998 AC_SUBST(G_LIBS_EXTRA)
1999
2000 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2001 dnl since we need it for g_iconv()
2002
2003 AC_MSG_CHECKING([for EILSEQ])
2004 AC_TRY_COMPILE([
2005 #include <errno.h>
2006 ],
2007 [
2008 int error = EILSEQ;
2009 ], have_eilseq=yes, have_eilseq=no);
2010 AC_MSG_RESULT($have_eilseq)
2011
2012 dnl ******************************************************************
2013 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2014 dnl ******************************************************************
2015
2016 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2017
2018 if test $cross_compiling = yes; then
2019   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2020   if test x$GLIB_GENMARSHAL = xno; then
2021     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2022   fi
2023 fi
2024
2025 dnl **************************
2026 dnl *** Checks for gtk-doc ***
2027 dnl **************************
2028
2029 GTK_DOC_CHECK([1.0])
2030
2031 AC_ARG_ENABLE(man,
2032               [AC_HELP_STRING([--enable-man],
2033                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2034               enable_man=no)
2035
2036 if test "${enable_man}" != no; then
2037 dnl
2038 dnl Check for xsltproc
2039 dnl
2040 AC_PATH_PROG([XSLTPROC], [xsltproc])
2041   if test -z "$XSLTPROC"; then
2042     enable_man=no
2043   fi
2044
2045   dnl check for DocBook DTD and stylesheets in the local catalog.
2046   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2047      [DocBook XML DTD V4.1.2],,enable_man=no)
2048   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2049      [DocBook XSL Stylesheets],,enable_man=no)
2050 fi
2051
2052 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2053
2054 dnl ******************************
2055 dnl *** output the whole stuff ***
2056 dnl ******************************
2057
2058 dnl this section will only be run if config.status is invoked with no
2059 dnl arguments, or with "glibconfig.h" as an argument.
2060 AC_CONFIG_COMMANDS([glibconfig.h],
2061 [
2062         outfile=glibconfig.h-tmp
2063         cat > $outfile <<\_______EOF
2064 /* glibconfig.h
2065  *
2066  * This is a generated file.  Please modify 'configure.in'
2067  */
2068
2069 #ifndef __G_LIBCONFIG_H__
2070 #define __G_LIBCONFIG_H__
2071
2072 #include <glib/gmacros.h>
2073
2074 _______EOF
2075
2076         if test x$glib_limits_h = xyes; then
2077           echo '#include <limits.h>' >> $outfile
2078         fi
2079         if test x$glib_float_h = xyes; then
2080           echo '#include <float.h>' >> $outfile
2081         fi
2082         if test x$glib_values_h = xyes; then
2083           echo '#include <values.h>' >> $outfile
2084         fi
2085         if test "$glib_header_alloca_h" = "yes"; then
2086           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2087         fi
2088         if test x$glib_sys_poll_h = xyes; then
2089           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2090         fi
2091
2092         cat >> $outfile <<_______EOF
2093
2094 G_BEGIN_DECLS
2095
2096 #define G_MINFLOAT      $glib_mf
2097 #define G_MAXFLOAT      $glib_Mf
2098 #define G_MINDOUBLE     $glib_md
2099 #define G_MAXDOUBLE     $glib_Md
2100 #define G_MINSHORT      $glib_ms
2101 #define G_MAXSHORT      $glib_Ms
2102 #define G_MAXUSHORT     $glib_Mus
2103 #define G_MININT        $glib_mi
2104 #define G_MAXINT        $glib_Mi
2105 #define G_MAXUINT       $glib_Mui
2106 #define G_MINLONG       $glib_ml
2107 #define G_MAXLONG       $glib_Ml
2108 #define G_MAXULONG      $glib_Mul
2109
2110 _______EOF
2111
2112
2113         ### this should always be true in a modern C/C++ compiler
2114         cat >>$outfile <<_______EOF
2115 typedef signed char gint8;
2116 typedef unsigned char guint8;
2117 _______EOF
2118
2119
2120         if test -n "$gint16"; then
2121           cat >>$outfile <<_______EOF
2122 typedef signed $gint16 gint16;
2123 typedef unsigned $gint16 guint16;
2124 #define G_GINT16_MODIFIER $gint16_modifier
2125 #define G_GINT16_FORMAT $gint16_format
2126 #define G_GUINT16_FORMAT $guint16_format
2127 _______EOF
2128         fi
2129
2130
2131         if test -n "$gint32"; then
2132           cat >>$outfile <<_______EOF
2133 typedef signed $gint32 gint32;
2134 typedef unsigned $gint32 guint32;
2135 #define G_GINT32_MODIFIER $gint32_modifier
2136 #define G_GINT32_FORMAT $gint32_format
2137 #define G_GUINT32_FORMAT $guint32_format
2138 _______EOF
2139         fi
2140
2141         cat >>$outfile <<_______EOF
2142 #define G_HAVE_GINT64 1          /* deprecated, always true */
2143
2144 ${glib_extension}typedef signed $gint64 gint64;
2145 ${glib_extension}typedef unsigned $gint64 guint64;
2146
2147 #define G_GINT64_CONSTANT(val)  $gint64_constant
2148 _______EOF
2149
2150         if test x$gint64_format != x ; then
2151           cat >>$outfile <<_______EOF
2152 #define G_GINT64_MODIFIER $gint64_modifier
2153 #define G_GINT64_FORMAT $gint64_format
2154 #define G_GUINT64_FORMAT $guint64_format
2155 _______EOF
2156         else
2157           cat >>$outfile <<_______EOF
2158 #undef G_GINT64_MODIFIER
2159 #undef G_GINT64_FORMAT
2160 #undef G_GUINT64_FORMAT
2161 _______EOF
2162         fi
2163
2164         cat >>$outfile <<_______EOF
2165
2166 #define GLIB_SIZEOF_VOID_P $glib_void_p
2167 #define GLIB_SIZEOF_LONG   $glib_long
2168 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2169
2170 _______EOF
2171
2172         cat >>$outfile <<_______EOF
2173 typedef signed $glib_size_type_define gssize;
2174 typedef unsigned $glib_size_type_define gsize;
2175 #define G_GSIZE_MODIFIER $gsize_modifier
2176 #define G_GSSIZE_FORMAT $gssize_format
2177 #define G_GSIZE_FORMAT $gsize_format
2178
2179 #define G_MAXSIZE       G_MAXU$glib_msize_type
2180 _______EOF
2181
2182         if test -z "$glib_unknown_void_p"; then
2183           cat >>$outfile <<_______EOF
2184
2185 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2186 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2187
2188 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2189 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2190 _______EOF
2191         else
2192           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2193         fi
2194
2195
2196
2197         cat >>$outfile <<_______EOF
2198 $glib_atexit
2199 $glib_memmove
2200 $glib_defines
2201 $glib_os
2202
2203 $glib_vacopy
2204
2205 #ifdef  __cplusplus
2206 #define G_HAVE_INLINE   1
2207 #else   /* !__cplusplus */
2208 $glib_inline
2209 #endif  /* !__cplusplus */
2210
2211 _______EOF
2212
2213         if test x$g_have_iso_c_varargs = xyes ; then
2214                 cat >>$outfile <<_______EOF
2215 #ifndef __cplusplus
2216 # define G_HAVE_ISO_VARARGS 1
2217 #endif
2218 _______EOF
2219         fi
2220         if test x$g_have_iso_cxx_varargs = xyes ; then
2221                 cat >>$outfile <<_______EOF
2222 #ifdef __cplusplus
2223 # define G_HAVE_ISO_VARARGS 1
2224 #endif
2225 _______EOF
2226         fi
2227         if test x$g_have_gnuc_varargs = xyes ; then
2228                 cat >>$outfile <<_______EOF
2229
2230 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2231  * is passed ISO vararg support is turned off, and there is no work
2232  * around to turn it on, so we unconditionally turn it off.
2233  */
2234 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2235 #  undef G_HAVE_ISO_VARARGS
2236 #endif
2237
2238 #define G_HAVE_GNUC_VARARGS 1
2239 _______EOF
2240         fi
2241
2242         case x$g_stack_grows in
2243         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2244         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2245         esac
2246
2247
2248         echo >>$outfile
2249         if test x$g_have_eilseq = xno; then
2250                 cat >>$outfile <<_______EOF
2251 #ifndef EILSEQ
2252 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2253  * The correspondence between this and the corresponding definition
2254  * in libiconv is essential.
2255  */
2256 #  define EILSEQ ENOENT
2257 #endif
2258 _______EOF
2259
2260         fi
2261
2262         if test x$g_have_gnuc_visibility = xyes ; then
2263                 cat >>$outfile <<_______EOF
2264 #define G_HAVE_GNUC_VISIBILITY 1
2265 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2266 _______EOF
2267         else
2268                 cat >>$outfile <<_______EOF
2269 #define G_GNUC_INTERNAL
2270 _______EOF
2271         fi
2272
2273
2274         echo >>$outfile
2275         if test x$g_mutex_has_default = xyes; then
2276                 cat >>$outfile <<_______EOF
2277 $g_enable_threads_def G_THREADS_ENABLED
2278 #define G_THREADS_IMPL_$g_threads_impl_def
2279 typedef struct _GStaticMutex GStaticMutex;
2280 struct _GStaticMutex
2281 {
2282   struct _GMutex *runtime_mutex;
2283   union {
2284     char   pad[[$g_mutex_sizeof]];
2285     double dummy_double;
2286     void  *dummy_pointer;
2287     long   dummy_long;
2288   } static_mutex;
2289 };
2290 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2291 #define g_static_mutex_get_mutex(mutex) \\
2292   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2293    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2294 _______EOF
2295         else
2296                 cat >>$outfile <<_______EOF
2297 $g_enable_threads_def G_THREADS_ENABLED
2298 #define G_THREADS_IMPL_$g_threads_impl_def
2299 typedef struct _GMutex* GStaticMutex;
2300 #define G_STATIC_MUTEX_INIT NULL
2301 #define g_static_mutex_get_mutex(mutex) \\
2302   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2303 _______EOF
2304         fi
2305
2306         cat >>$outfile <<_______EOF
2307 /* This represents a system thread as used by the implementation. An
2308  * alien implementaion, as loaded by g_thread_init can only count on
2309  * "sizeof (gpointer)" bytes to store their info. We however need more
2310  * for some of our native implementations. */
2311 typedef union _GSystemThread GSystemThread;
2312 union _GSystemThread
2313 {
2314   char   data[[$g_system_thread_sizeof]];
2315   double dummy_double;
2316   void  *dummy_pointer;
2317   long   dummy_long;
2318 };
2319 _______EOF
2320         if test x"$g_memory_barrier_needed" != xno; then
2321           echo >>$outfile
2322           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2323         fi
2324
2325         echo >>$outfile
2326         g_bit_sizes="16 32 64"
2327         for bits in $g_bit_sizes; do
2328           cat >>$outfile <<_______EOF
2329 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2330 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2331 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2332 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2333 _______EOF
2334         done
2335
2336         cat >>$outfile <<_______EOF
2337 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2338 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2339 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2340 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2341 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2342 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2343 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2344 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2345 #define G_BYTE_ORDER $g_byte_order
2346
2347 #define GLIB_SYSDEF_POLLIN =$g_pollin
2348 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2349 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2350 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2351 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2352 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2353
2354 #define G_MODULE_SUFFIX "$g_module_suffix"
2355
2356 typedef $g_pid_type GPid;
2357
2358 G_END_DECLS
2359
2360 #endif /* GLIBCONFIG_H */
2361 _______EOF
2362
2363
2364         if cmp -s $outfile glibconfig.h; then
2365           AC_MSG_NOTICE([glibconfig.h is unchanged])
2366           rm -f $outfile
2367         else
2368           mv $outfile glibconfig.h
2369         fi
2370 ],[
2371
2372 # Note that if two cases are the same, case goes with the first one.
2373 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2374 # on variable expansion in case labels.  Look at the generated config.status
2375 # for a hint.
2376
2377 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2378   glib_header_alloca_h="$ac_cv_working_alloca_h"
2379 else
2380   glib_header_alloca_h="$ac_cv_header_alloca_h"
2381 fi
2382
2383 case xyes in
2384 x$ac_cv_header_float_h)
2385   glib_float_h=yes
2386   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2387   glib_md=DBL_MIN glib_Md=DBL_MAX
2388   ;;
2389 x$ac_cv_header_values_h)
2390   glib_values_h=yes
2391   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2392   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2393   ;;
2394 esac
2395
2396 case xyes in
2397 x$ac_cv_header_limits_h)
2398   glib_limits_h=yes
2399   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2400   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2401   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2402   ;;
2403 x$ac_cv_header_values_h)
2404   glib_values_h=yes
2405   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2406   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2407   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2408   ;;
2409 esac
2410
2411 if test x$ac_cv_header_sys_poll_h = xyes ; then
2412   glib_sys_poll_h=yes
2413 fi
2414
2415 case 2 in
2416 $ac_cv_sizeof_short)
2417   gint16=short
2418   gint16_modifier='"h"'
2419   gint16_format='"hi"'
2420   guint16_format='"hu"'
2421   ;;
2422 $ac_cv_sizeof_int)
2423   gint16=int
2424   gint16_modifier='""'
2425   gint16_format='"i"'
2426   guint16_format='"u"'
2427   ;;
2428 esac
2429 case 4 in
2430 $ac_cv_sizeof_short)
2431   gint32=short
2432   gint32_modifier='"h"'
2433   gint32_format='"hi"'
2434   guint32_format='"hu"'
2435   ;;
2436 $ac_cv_sizeof_int)
2437   gint32=int
2438   gint32_modifier='""'
2439   gint32_format='"i"'
2440   guint32_format='"u"'
2441   ;;
2442 $ac_cv_sizeof_long)
2443   gint32=long
2444   gint32_modifier='"l"'
2445   gint32_format='"li"'
2446   guint32_format='"lu"'
2447   ;;
2448 esac
2449 case 8 in
2450 $ac_cv_sizeof_int)
2451   gint64=int
2452   gint64_modifier='""'
2453   gint64_format='"i"'
2454   guint64_format='"u"'
2455   glib_extension=
2456   gint64_constant='(val)'
2457   ;;
2458 $ac_cv_sizeof_long)
2459   gint64=long
2460   gint64_modifier='"l"'
2461   gint64_format='"li"'
2462   guint64_format='"lu"'
2463   glib_extension=
2464   gint64_constant='(val##L)'
2465   ;;
2466 $ac_cv_sizeof_long_long)
2467   gint64='long long'
2468   if test -n "$glib_cv_long_long_format"; then
2469     gint64_modifier='"'$glib_cv_long_long_format'"'
2470     gint64_format='"'$glib_cv_long_long_format'i"'
2471     guint64_format='"'$glib_cv_long_long_format'u"'
2472   fi
2473   glib_extension='G_GNUC_EXTENSION '
2474   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2475   ;;
2476 $ac_cv_sizeof___int64)
2477   gint64='__int64'
2478   if test -n "$glib_cv_long_long_format"; then
2479     gint64_modifier='"'$glib_cv_long_long_format'"'
2480     gint64_format='"'$glib_cv_long_long_format'i"'
2481     guint64_format='"'$glib_cv_long_long_format'u"'
2482   fi
2483   glib_extension=
2484   gint64_constant='(val##i64)'
2485   ;;
2486 esac
2487 glib_size_t=$ac_cv_sizeof_size_t
2488 glib_size_type_define=$glib_size_type
2489 glib_void_p=$ac_cv_sizeof_long
2490 glib_long=$ac_cv_sizeof_void_p
2491
2492 case $glib_size_type in
2493 short)
2494   gsize_modifier='"h"'
2495   gsize_format='"hu"'
2496   gssize_format='"hi"'
2497   glib_msize_type='SHRT'
2498   ;;
2499 int)
2500   gsize_modifier='""'
2501   gsize_format='"u"'
2502   gssize_format='"i"'
2503   glib_msize_type='INT'
2504   ;;
2505 long)
2506   gsize_modifier='"l"'
2507   gsize_format='"lu"'
2508   gssize_format='"li"'
2509   glib_msize_type='LONG'
2510   ;;
2511 esac
2512
2513 gintbits=`expr $ac_cv_sizeof_int \* 8`
2514 glongbits=`expr $ac_cv_sizeof_long \* 8`
2515
2516
2517 case $ac_cv_sizeof_void_p in
2518 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2519 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2520 *)                      glib_unknown_void_p=yes ;;
2521 esac
2522
2523
2524 case xyes in
2525 x$ac_cv_func_atexit)
2526   glib_atexit="
2527 #ifdef NeXT /* @#%@! NeXTStep */
2528 # define g_ATEXIT(proc) (!atexit (proc))
2529 #else
2530 # define g_ATEXIT(proc) (atexit (proc))
2531 #endif"
2532   ;;
2533 x$ac_cv_func_on_exit)
2534   glib_atexit="
2535 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2536   ;;
2537 esac
2538
2539 case xyes in
2540 x$ac_cv_func_memmove)
2541   glib_memmove='
2542 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2543   ;;
2544 x$glib_cv_working_bcopy)
2545   glib_memmove="
2546 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2547 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2548   ;;
2549 *)
2550   glib_memmove="
2551 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2552  * so we have to roll our own copy routine. */
2553 void g_memmove (void* dest, const void * src, unsigned long len);"
2554   ;;
2555 esac
2556
2557 glib_defines="
2558 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2559 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2560 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2561 "
2562
2563 case xyes in
2564 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2565 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2566 *)                      glib_vacopy=''
2567 esac
2568
2569 if test x$glib_cv_va_val_copy = xno; then
2570   glib_vacopy="\$glib_vacopy
2571 #define G_VA_COPY_AS_ARRAY 1"
2572 fi
2573
2574 if test x$glib_cv_hasinline = xyes; then
2575     glib_inline='#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 if test x$glib_cv_has__inline__ = xyes; then
2582     glib_inline="\$glib_inline
2583 #define G_HAVE___INLINE__ 1"
2584 fi
2585
2586 g_have_gnuc_varargs=$g_have_gnuc_varargs
2587 g_have_iso_c_varargs=$g_have_iso_c_varargs
2588 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2589
2590 g_have_gnuc_visibility=$g_have_gnuc_visibility
2591
2592 case xyes in
2593 x$ac_cv_c_bigendian)
2594   g_byte_order=G_BIG_ENDIAN
2595   g_bs_native=BE
2596   g_bs_alien=LE
2597   ;;
2598 *)
2599   g_byte_order=G_LITTLE_ENDIAN
2600   g_bs_native=LE
2601   g_bs_alien=BE
2602   ;;
2603 esac
2604
2605 g_pollin=$glib_cv_value_POLLIN
2606 g_pollout=$glib_cv_value_POLLOUT
2607 g_pollpri=$glib_cv_value_POLLPRI
2608 g_pollhup=$glib_cv_value_POLLHUP
2609 g_pollerr=$glib_cv_value_POLLERR
2610 g_pollnval=$glib_cv_value_POLLNVAL
2611
2612 g_stack_grows=$glib_cv_stack_grows
2613
2614 g_have_eilseq=$have_eilseq
2615
2616 case x$have_threads in
2617 xno)    g_enable_threads_def="#undef";;
2618 *)      g_enable_threads_def="#define";;
2619 esac
2620
2621 g_threads_impl_def=$g_threads_impl
2622
2623 g_mutex_has_default="$mutex_has_default"
2624 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2625 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2626 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2627
2628 g_memory_barrier_needed="$glib_memory_barrier_needed"
2629
2630 g_module_suffix="$glib_gmodule_suffix"
2631
2632 g_pid_type="$glib_pid_type"
2633 case $host in
2634   *-*-beos*)
2635     glib_os="#define G_OS_BEOS"
2636     ;;
2637   *-*-cygwin*)
2638     glib_os="#define G_OS_UNIX
2639 #define G_PLATFORM_WIN32
2640 #define G_WITH_CYGWIN"
2641     ;;
2642   *-*-mingw*)
2643     glib_os="#define G_OS_WIN32
2644 #define G_PLATFORM_WIN32"
2645     ;;
2646   *)
2647     glib_os="#define G_OS_UNIX"
2648     ;;
2649 esac
2650 ])
2651
2652 AC_CONFIG_FILES([
2653 glib-2.0.pc
2654 glib-2.0-uninstalled.pc
2655 gmodule-2.0.pc
2656 gmodule-2.0-uninstalled.pc
2657 gthread-2.0.pc
2658 gthread-2.0-uninstalled.pc
2659 gobject-2.0.pc
2660 gobject-2.0-uninstalled.pc
2661 glib-zip
2662 glib-gettextize
2663 Makefile
2664 build/Makefile
2665 build/win32/Makefile
2666 build/win32/dirent/Makefile
2667 glib/Makefile
2668 glib/libcharset/Makefile
2669 glib/gnulib/Makefile
2670 gmodule/Makefile
2671 gmodule/gmoduleconf.h
2672 gobject/Makefile
2673 gobject/glib-mkenums
2674 gthread/Makefile
2675 po/Makefile.in
2676 docs/Makefile
2677 docs/reference/Makefile
2678 docs/reference/glib/Makefile
2679 docs/reference/glib/version.xml
2680 docs/reference/gobject/Makefile
2681 docs/reference/gobject/version.xml
2682 tests/Makefile
2683 tests/gobject/Makefile
2684 m4macros/Makefile
2685 ])
2686
2687 AC_CONFIG_COMMANDS([chmod-scripts],
2688 [chmod 0755 glib-zip
2689 chmod 0755 glib-gettextize
2690 chmod 0755 gobject/glib-mkenums])
2691
2692 # we want to invoke this macro solely so that the config.status script
2693 # and automake generated makefiles know about these generated files.
2694 # They are only needed to distcheck the package
2695 if false; then
2696   AC_CONFIG_FILES([
2697     INSTALL
2698     README
2699     config.h.win32
2700     glibconfig.h.win32
2701     glib/makefile.msc
2702     glib/glib.rc
2703     gmodule/makefile.msc
2704     gmodule/gmodule.rc
2705     gobject/makefile.msc
2706     gobject/gobject.rc
2707     gthread/makefile.msc
2708     gthread/gthread.rc
2709     tests/makefile.msc
2710   ])
2711 fi
2712
2713 AC_OUTPUT