configure.in

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