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