configure.in

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