configure.in

   1 dnl ***********************************
   2 dnl *** include special GLib macros ***
   3 dnl ***********************************
   4 builtin(include, acglib.m4)dnl
   5
   6 # require autoconf 2.13
   7 AC_PREREQ(2.13)
   8
   9 # Process this file with autoconf to produce a configure script.
  10 AC_INIT(glist.c)
  11
  12 # Save this value here, since automake will set cflags later
  13 cflags_set=${CFLAGS+set}
  14
  15 # we rewrite this file
  16 rm -f glibconfig-sysdefs.h
  17
  18 GLIB_AC_DIVERT_BEFORE_HELP([
  19 #
  20 # The following version number definitions apply to GLib, GModule, GObject
  21 # and GThread as a whole, so if changes occoured in any of them, they are all
  22 # treated with the same interface and binary age.
  23 #
  24 # Making releases:
  25 #   GLIB_MICRO_VERSION += 1;
  26 #   GLIB_INTERFACE_AGE += 1;
  27 #   GLIB_BINARY_AGE += 1;
  28 # if any functions have been added, set GLIB_INTERFACE_AGE to 0.
  29 # if backwards compatibility has been broken,
  30 # set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0.
  31 #
  32 GLIB_MAJOR_VERSION=1
  33 GLIB_MINOR_VERSION=3
  34 GLIB_MICRO_VERSION=2
  35 GLIB_INTERFACE_AGE=0
  36 GLIB_BINARY_AGE=0
  37 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
  38 ])dnl
  39
  40 AC_SUBST(GLIB_MAJOR_VERSION)
  41 AC_SUBST(GLIB_MINOR_VERSION)
  42 AC_SUBST(GLIB_MICRO_VERSION)
  43 AC_SUBST(GLIB_VERSION)
  44 AC_SUBST(GLIB_INTERFACE_AGE)
  45 AC_SUBST(GLIB_BINARY_AGE)
  46
  47 # libtool versioning
  48 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
  49 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
  50 LT_REVISION=$GLIB_INTERFACE_AGE
  51 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
  52 AC_SUBST(LT_RELEASE)
  53 AC_SUBST(LT_CURRENT)
  54 AC_SUBST(LT_REVISION)
  55 AC_SUBST(LT_AGE)
  56
  57 VERSION=$GLIB_VERSION
  58 PACKAGE=glib
  59
  60 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  61
  62 # Specify a configuration file
  63 AM_CONFIG_HEADER(config.h)
  64
  65 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION,
  66                    [Define to the GLIB major version])
  67 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION,
  68                    [Define to the GLIB minor version])
  69 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION,
  70                    [Define to the GLIB micro version])
  71 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE,
  72                    [Define to the GLIB interface age])
  73 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE,
  74                    [Define to the GLIB binary age])
  75
  76 dnl Initialize maintainer mode
  77 AM_MAINTAINER_MODE
  78
  79 AC_CANONICAL_HOST
  80
  81 AC_MSG_CHECKING(for the BeOS)
  82 case $host in
  83   *-*-beos*)
  84     glib_native_beos="yes"
  85     ;;
  86   *)
  87     glib_native_beos="no"
  88     ;;
  89 esac
  90 AC_MSG_RESULT([$glib_native_beos])
  91
  92 dnl
  93
  94 GLIB_AC_DIVERT_BEFORE_HELP([
  95 # figure debugging default, prior to $ac_help setup
  96 case $GLIB_MINOR_VERSION in
  97 *[[13579]]) debug_default=yes ;;
  98 *)          debug_default=minimum ;;
  99 esac[]dnl
 100 ])
 101
 102 dnl declare --enable-* args and collect ac_help strings
 103 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
 104 AC_ARG_ENABLE(msg-prefix, [  --enable-msg-prefix     turn on program name and PID prefixing of messages and warnings],,enable_msg_prefix=no)
 105 AC_ARG_ENABLE(gc_friendly, [  --enable-gc-friendly    turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
 106 AC_ARG_ENABLE(mem_pools, [  --disable-mem-pools     disable all glib memory pools],,disable_mem_pools=no)
 107 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
 108                     , enable_ansi=no)
 109 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
 110                           ([=no] will override --with-threads)],,enable_threads=yes)
 111 AC_ARG_ENABLE(rebuilds, [  --disable-rebuilds      disable all source autogeneration rules],,enable_rebuilds=yes)
 112
 113 if test "x$enable_threads" != "xyes"; then
 114   enable_threads=no
 115 fi
 116
 117 if test "x$enable_debug" = "xyes"; then
 118   test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
 119   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 120 else
 121   if test "x$enable_debug" = "xno"; then
 122     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 123   fi
 124 fi
 125
 126 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}",
 127         [Whether glib was compiled with debugging enabled])
 128
 129 AC_MSG_CHECKING(whether to enable garbage collector friendliness)
 130 if test "x$enable_gc_friendly" = "xyes"; then
 131   AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
 132   AC_SUBST(ENABLE_GC_FRIENDLY)
 133   AC_MSG_RESULT(yes)
 134 else
 135   AC_MSG_RESULT(no)
 136 fi
 137
 138 AC_MSG_CHECKING(whether to disable memory pools)
 139 if test "x$disable_mem_pools" = "xno"; then
 140   AC_MSG_RESULT(no)
 141 else
 142   AC_DEFINE(DISABLE_MEM_POOLS, 1, [Whether to disable memory pools])
 143   AC_SUBST(DISABLE_MEM_POOLS)
 144   AC_MSG_RESULT(yes)
 145 fi
 146
 147 if test "x$enable_msg_prefix" = "xyes"; then
 148   AC_DEFINE_UNQUOTED(G_ENABLE_MSG_PREFIX, 1,
 149                      [Enable prefixing of error messages with program names])
 150 fi
 151
 152 # Checks for programs.
 153 AC_PROG_CC
 154 AM_PROG_CC_STDC
 155 AC_PROG_INSTALL
 156
 157 # define a MAINT-like variable REBUILD which is set if Perl
 158 # and awk are found, so autogenerated sources can be rebuilt
 159 AC_PROG_AWK
 160 AC_CHECK_PROGS(PERL, perl5 perl)
 161 # We would like indent, but don't require it.
 162 AC_CHECK_PROG(INDENT, indent, indent)
 163 REBUILD=\#
 164 if test "x$enable_rebuilds" = "xyes" && \
 165      test -n "$PERL" && \
 166      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 167      test -n "$AWK" ; then
 168   REBUILD=
 169 fi
 170 AC_SUBST(REBUILD)
 171
 172 dnl Initialize libtool
 173 AM_PROG_LIBTOOL
 174
 175 if test "x$GCC" = "xyes"; then
 176   case " $CFLAGS " in
 177   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 178   *) CFLAGS="$CFLAGS -Wall" ;;
 179   esac
 180
 181   if test "x$enable_ansi" = "xyes"; then
 182     case " $CFLAGS " in
 183     *[[\ \      ]]-ansi[[\ \    ]]*) ;;
 184     *) CFLAGS="$CFLAGS -ansi" ;;
 185     esac
 186
 187     case " $CFLAGS " in
 188     *[[\ \      ]]-pedantic[[\ \        ]]*) ;;
 189     *) CFLAGS="$CFLAGS -pedantic" ;;
 190     esac
 191   fi
 192 fi
 193
 194 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 195 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 196 glib_save_LIBS=$LIBS
 197 LIBS="$LIBS -lm"
 198 AC_TRY_RUN([#include <math.h>
 199              int main (void) { return (log(1) != log(1.)); }],
 200      AC_MSG_RESULT(none needed),
 201      glib_save_CFLAGS=$CFLAGS
 202      CFLAGS="$CFLAGS -std1"
 203      AC_TRY_RUN([#include <math.h>
 204                  int main (void) { return (log(1) != log(1.)); }],
 205          AC_MSG_RESULT(-std1),
 206          AC_MSG_RESULT()
 207          CFLAGS=$glib_save_CFLAGS
 208          AC_MSG_WARN(
 209                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 210      )
 211 )
 212 LIBS=$glib_save_LIBS
 213
 214 dnl NeXTStep cc seems to need this
 215 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 216 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 217   AC_MSG_RESULT(none needed),
 218   glib_save_CFLAGS=$CFLAGS
 219   CFLAGS="$CFLAGS -posix"
 220   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 221     AC_MSG_RESULT(-posix),
 222     AC_MSG_RESULT()
 223     CFLAGS=$glib_save_CFLAGS
 224     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 225
 226 # Checks for header files.
 227 AC_HEADER_STDC
 228
 229 # Checks for library functions.
 230 AC_FUNC_VPRINTF
 231
 232 AC_FUNC_ALLOCA
 233
 234 AC_CHECK_FUNCS(atexit on_exit)
 235
 236 AC_CHECK_SIZEOF(char)
 237 AC_CHECK_SIZEOF(short)
 238 AC_CHECK_SIZEOF(long)
 239 AC_CHECK_SIZEOF(int)
 240 AC_CHECK_SIZEOF(void *)
 241 AC_CHECK_SIZEOF(long long)
 242
 243 if test x$ac_cv_sizeof_long_long = x8; then
 244         # long long is a 64 bit integer.
 245         AC_MSG_CHECKING(for format to printf and scanf a gint64)
 246         AC_CACHE_VAL(glib_cv_long_long_format,[
 247                 for format in ll q; do
 248                   AC_TRY_RUN([#include <stdio.h>
 249                         int main()
 250                         {
 251                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 252                           char buffer[1000];
 253                           sprintf (buffer, "%${format}u", a);
 254                           sscanf (buffer, "%${format}u", &b);
 255                           exit (b!=a);
 256                         }
 257                         ],
 258                         glib_cv_long_long_format=${format}
 259                         break)
 260                 done])
 261         if test -n "$glib_cv_long_long_format"; then
 262           AC_MSG_RESULT(%${glib_cv_long_long_format}i)
 263         else
 264           AC_MSG_RESULT(none)
 265         fi
 266 fi
 267
 268 dnl long doubles were not used, and a portability problem
 269 dnl AC_C_LONG_DOUBLE
 270 AC_C_CONST
 271
 272 dnl ok, here we try to check whether the systems prototypes for
 273 dnl malloc and friends actually match the prototypes provided
 274 dnl by gmem.h (keep in sync). i currently only know how to check
 275 dnl this reliably with gcc (-Werror), improvements for other
 276 dnl compilers are apprechiated.
 277 SANE_MALLOC_PROTOS=no
 278 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 279 glib_save_CFLAGS=$CFLAGS
 280 if test "x$GCC" = "xyes"; then
 281   CFLAGS="$CFLAGS -Werror"
 282   AC_TRY_COMPILE([#include <stdlib.h>], [
 283     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 284     void* (*my_malloc_p)  (size_t)         = malloc;
 285     void  (*my_free_p)    (void*)          = free;
 286     void* (*my_realloc_p) (void*, size_t)  = realloc;
 287     my_calloc_p = 0;
 288     my_malloc_p = 0;
 289     my_free_p = 0;
 290     my_realloc_p = 0;
 291   ],
 292     AC_DEFINE(SANE_MALLOC_PROTOS)
 293     SANE_MALLOC_PROTOS=yes)
 294 fi
 295 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 296 CFLAGS=$glib_save_CFLAGS
 297
 298
 299 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 300 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 301 dnl actually supported.
 302 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 303         AC_TRY_RUN([
 304         __inline int foo () { return 0; }
 305         int main () { return foo (); }
 306         ],
 307         glib_cv_has__inline=yes
 308         ,
 309         glib_cv_has__inline=no
 310         ,)
 311 ])
 312 case x$glib_cv_has__inline in
 313 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 314 esac
 315 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 316         AC_TRY_RUN([
 317         __inline__ int foo () { return 0; }
 318         int main () { return foo (); }
 319         ],
 320         glib_cv_has__inline__=yes
 321         ,
 322         glib_cv_has__inline__=no
 323         ,)
 324 ])
 325 case x$glib_cv_has__inline__ in
 326 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 327 esac
 328 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 329         AC_TRY_RUN([
 330         inline int foo () { return 0; }
 331         int main () { return foo (); }
 332         ],
 333         glib_cv_hasinline=yes
 334         ,
 335         glib_cv_hasinline=no
 336         ,)
 337 ])
 338 case x$glib_cv_hasinline in
 339 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 340 esac
 341
 342 # check for bytesex stuff
 343 AC_C_BIGENDIAN
 344
 345 # check for header files
 346 AC_CHECK_HEADERS([float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h])
 347 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
 348
 349 AC_MSG_CHECKING(whether make is GNU Make)
 350 STRIP_BEGIN=
 351 STRIP_END=
 352 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
 353         STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 354         STRIP_END=')'
 355         AC_MSG_RESULT(yes)
 356 else
 357         AC_MSG_RESULT(no)
 358 fi
 359 STRIP_DUMMY=
 360 AC_SUBST(STRIP_DUMMY)
 361 AC_SUBST(STRIP_BEGIN)
 362 AC_SUBST(STRIP_END)
 363
 364 # check additional type sizes
 365 size_includes=["
 366 #include <stdarg.h>
 367 #include <stdio.h>
 368 #include <ctype.h>
 369 #include <string.h>
 370 "]
 371 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 372   size_includes=["$size_includes
 373 #include <stdint.h>
 374 "]
 375 fi
 376 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 377   size_includes=["$size_includes
 378 #include <unistd.h>
 379 "]
 380 fi
 381 GLIB_SIZEOF([$size_includes], size_t, size_t)
 382 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 383 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 384
 385 # Check for some functions
 386 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf strcasecmp strncasecmp poll getcwd)
 387
 388 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 389 # The check is borrowed from the PERL Configure script.
 390 if test "$ac_cv_func_memmove" != "yes"; then
 391   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 392     glib_cv_working_bcopy,[AC_TRY_RUN([
 393       int main() {
 394         char buf[128], abc[128], *b;
 395         int len, off, align;
 396         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 397         for (align = 7; align >= 0; align--) {
 398           for (len = 36; len; len--) {
 399             b = buf+align; bcopy(abc, b, len);
 400             for (off = 1; off <= len; off++) {
 401               bcopy(b, b+off, len); bcopy(b+off, b, len);
 402                 if (bcmp(b, abc, len)) return(1);
 403             }
 404           }
 405         }
 406         return(0);
 407       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 408   if test "$glib_cv_working_bcopy" = "yes"; then
 409     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
 410   fi
 411 fi
 412
 413 # Check for sys_errlist
 414 AC_MSG_CHECKING(for sys_errlist)
 415 AC_TRY_LINK(, [
 416 extern char *sys_errlist[];
 417 extern int sys_nerr;
 418 sys_errlist[sys_nerr-1][0] = 0;
 419 ], glib_ok=yes, glib_ok=no)
 420 AC_MSG_RESULT($glib_ok)
 421 if test $glib_ok = no; then
 422     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
 423 fi
 424
 425 # Check for sys_siglist
 426 AC_MSG_CHECKING(for sys_siglist)
 427 AC_TRY_LINK(, [
 428 extern char *sys_siglist[];
 429 exit (sys_siglist[0]);
 430 ], glib_ok=yes, glib_ok=no)
 431 AC_MSG_RESULT($glib_ok)
 432 if test $glib_ok = no; then
 433     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
 434 fi
 435
 436 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 437 AC_MSG_CHECKING(for sys_siglist declaration)
 438 AC_TRY_COMPILE([#include <signal.h>], [
 439 strlen (sys_siglist[0]);
 440 ], glib_ok=yes, glib_ok=no)
 441 AC_MSG_RESULT($glib_ok)
 442 if test $glib_ok = no; then
 443     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
 444 fi
 445
 446 # Check if <sys/select.h> needs to be included for fd_set
 447 AC_MSG_CHECKING([for fd_set])
 448 AC_TRY_COMPILE([#include <sys/types.h>],
 449         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 450 if test $gtk_ok = yes; then
 451     AC_MSG_RESULT([yes, found in sys/types.h])
 452 else
 453     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
 454     if test $gtk_ok = yes; then
 455         # *** FIXME: give it a different name
 456         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
 457         AC_MSG_RESULT([yes, found in sys/select.h])
 458     else
 459         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
 460         AC_MSG_RESULT(no)
 461     fi
 462 fi
 463
 464 dnl *** check for sane realloc() ***
 465 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
 466         AC_TRY_RUN([
 467         #include <stdlib.h>
 468         int main() {
 469           return realloc (0, sizeof (int)) == 0;
 470         }],
 471         [glib_cv_sane_realloc=yes],
 472         [glib_cv_sane_realloc=no],
 473         [])
 474 ])
 475 if test x$glib_cv_sane_realloc = xyes; then
 476   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
 477 fi
 478
 479 dnl Check for nl_langinfo and CODESET
 480
 481 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 482 AC_TRY_COMPILE([#include <langinfo.h>],
 483         [char *codeset = nl_langinfo (CODESET);],
 484    AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
 485    have_codeset=yes,
 486    have_codeset=no)
 487 AC_MSG_RESULT($have_codeset)
 488
 489
 490 dnl ****************************************
 491 dnl *** strlcpy/strlcat                  ***
 492 dnl ****************************************
 493 # Check for strlcpy
 494 AC_MSG_CHECKING(for strlcpy/strlcat)
 495 AC_TRY_LINK([#include <stdlib.h>
 496 #include <string.h>], [
 497 char *p = malloc(10);
 498 (void) strlcpy(p, "hi", 10);
 499 (void) strlcat(p, "bye", 10);
 500 ], glib_ok=yes, glib_ok=no)
 501 AC_MSG_RESULT($glib_ok)
 502 if test $glib_ok = yes; then
 503     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
 504 fi
 505
 506
 507 dnl **********************
 508 dnl *** va_copy checks ***
 509 dnl **********************
 510 dnl we currently check for all three va_copy possibilities, so we get
 511 dnl all results in config.log for bug reports.
 512 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
 513         AC_TRY_RUN([
 514         #include <stdarg.h>
 515         void f (int i, ...) {
 516         va_list args1, args2;
 517         va_start (args1, i);
 518         va_copy (args2, args1);
 519         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 520           exit (1);
 521         va_end (args1); va_end (args2);
 522         }
 523         int main() {
 524           f (0, 42);
 525           return 0;
 526         }],
 527         [glib_cv_va_copy=yes],
 528         [glib_cv_va_copy=no],
 529         [])
 530 ])
 531 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
 532         AC_TRY_RUN([
 533         #include <stdarg.h>
 534         void f (int i, ...) {
 535         va_list args1, args2;
 536         va_start (args1, i);
 537         __va_copy (args2, args1);
 538         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 539           exit (1);
 540         va_end (args1); va_end (args2);
 541         }
 542         int main() {
 543           f (0, 42);
 544           return 0;
 545         }],
 546         [glib_cv___va_copy=yes],
 547         [glib_cv___va_copy=no],
 548         [])
 549 ])
 550
 551 if test "x$glib_cv_va_copy" = "xyes"; then
 552   g_va_copy_func=va_copy
 553 else if test "x$glib_cv___va_copy" = "xyes"; then
 554   g_va_copy_func=__va_copy
 555 fi
 556 fi
 557
 558 if test -n "$g_va_copy_func"; then
 559   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
 560 fi
 561
 562 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
 563         AC_TRY_RUN([
 564         #include <stdarg.h>
 565         void f (int i, ...) {
 566         va_list args1, args2;
 567         va_start (args1, i);
 568         args2 = args1;
 569         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 570           exit (1);
 571         va_end (args1); va_end (args2);
 572         }
 573         int main() {
 574           f (0, 42);
 575           return 0;
 576         }],
 577         [glib_cv_va_val_copy=yes],
 578         [glib_cv_va_val_copy=no],
 579         [])
 580 ])
 581
 582 if test "x$glib_cv_va_val_copy" = "xno"; then
 583   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
 584 fi
 585
 586 dnl ***********************
 587 dnl *** g_module checks ***
 588 dnl ***********************
 589 G_MODULE_LIBS=
 590 G_MODULE_LIBS_EXTRA=
 591 G_MODULE_PLUGIN_LIBS=
 592 G_MODULE_LDFLAGS=
 593 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 594 G_MODULE_NEED_USCORE=0
 595 G_MODULE_HAVE_DLERROR=0
 596 dnl *** dlopen() and dlsym() in system libraries
 597 if test -z "$G_MODULE_IMPL"; then
 598         AC_CHECK_FUNC(dlopen,
 599                       [AC_CHECK_FUNC(dlsym,
 600                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 601                       [])
 602 fi
 603 dnl *** load_image (BeOS)
 604 if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
 605   AC_CHECK_LIB(root, load_image,
 606       [G_MODULE_LIBS="-lbe -lroot -lglib"
 607       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 608       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 609       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
 610       [])
 611 fi
 612 # *** dlopen() and dlsym() in libdl
 613 if test -z "$G_MODULE_IMPL"; then
 614         AC_CHECK_LIB(dl, dlopen,
 615                      [AC_CHECK_LIB(dl, dlsym,
 616                                    [G_MODULE_LIBS=-ldl
 617                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 618                      [])
 619 fi
 620 dnl *** shl_load() in libdld (HP-UX)
 621 if test -z "$G_MODULE_IMPL"; then
 622         AC_MSG_CHECKING(how to export all symbols)
 623         SAVED_LDFLAGS=$LDFLAGS
 624         LDFLAGS="$LDFLAGS -Wl,-E"
 625         AC_TRY_LINK(,[ return 0; ],
 626                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 627                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 628                 AC_TRY_LINK(,[ return 0; ],
 629                         [G_MODULE_LDFLAGS="-bexpall"],
 630                         [G_MODULE_LDFLAGS="none"])
 631         ])
 632         LDFLAGS=$SAVED_LDFLAGS
 633         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 634         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 635                 G_MODULE_LDFLAGS=
 636         fi
 637         AC_CHECK_LIB(dld, shl_load,
 638                 [G_MODULE_LIBS=-ldld
 639                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
 640                 [])
 641 fi
 642 dnl *** additional checks for G_MODULE_IMPL_DL
 643 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 644         case "$host_os" in
 645           linux*)
 646             G_MODULE_LDFLAGS='-rdynamic'
 647             ;;
 648         esac
 649         LIBS_orig="$LIBS"
 650         LDFLAGS_orig="$LDFLAGS"
 651         LIBS="$LIBS $G_MODULE_LIBS"
 652         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 653 dnl *** check whether we need preceeding underscores
 654         AC_CACHE_CHECK([for preceeding underscore in symbols],
 655                 glib_cv_uscore,[
 656                 AC_TRY_RUN([
 657                 #include <dlfcn.h>
 658                 int glib_underscore_test (void) { return 42; }
 659                 int main() {
 660                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 661                   handle = dlopen ((void*)0, 0);
 662                   if (handle) {
 663                     f1 = dlsym (handle, "glib_underscore_test");
 664                     f2 = dlsym (handle, "_glib_underscore_test");
 665                   } return (!f2 || f1);
 666                 }],
 667                         [glib_cv_uscore=yes],
 668                         [glib_cv_uscore=no],
 669                         [])
 670                 rm -f plugin.c plugin.o plugin.lo
 671         ])
 672         if test "x$glib_cv_uscore" = "xyes"; then
 673                 G_MODULE_NEED_USCORE=1
 674         else
 675                 G_MODULE_NEED_USCORE=0
 676         fi
 677
 678         LDFLAGS="$LDFLAGS_orig"
 679 dnl *** check for having dlerror()
 680         AC_CHECK_FUNC(dlerror,
 681                 [G_MODULE_HAVE_DLERROR=1],
 682                 [G_MODULE_HAVE_DLERROR=0])
 683         LIBS="$LIBS_orig"
 684 fi
 685 dnl *** done, have e got an implementation?
 686 if test -z "$G_MODULE_IMPL"; then
 687         G_MODULE_IMPL=0
 688 fi
 689
 690 AC_MSG_CHECKING(for the suffix of shared libraries)
 691 case "$host_os" in
 692   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
 693     glib_gmodule_suffix='sl'
 694     ;;
 695   cygwin* | mingw*)
 696     glib_gmodule_suffix='dll'
 697     ;;
 698   *)
 699     glib_gmodule_suffix='so'
 700     ;;
 701 esac
 702 AC_MSG_RESULT(.$glib_gmodule_suffix)
 703
 704 AC_SUBST(G_MODULE_IMPL)
 705 AC_SUBST(G_MODULE_LIBS)
 706 AC_SUBST(G_MODULE_LIBS_EXTRA)
 707 AC_SUBST(G_MODULE_PLUGIN_LIBS)
 708 AC_SUBST(G_MODULE_LDFLAGS)
 709 AC_SUBST(G_MODULE_HAVE_DLERROR)
 710 AC_SUBST(G_MODULE_NEED_USCORE)
 711 AC_SUBST(GLIB_DEBUG_FLAGS)
 712
 713
 714 dnl ***********************
 715 dnl *** g_thread checks ***
 716 dnl ***********************
 717
 718 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
 719         if test "x$with_threads" = x; then
 720                 want_threads=yes
 721         else
 722                 want_threads=$with_threads
 723         fi,
 724         want_threads=yes)
 725 if test "x$enable_threads" = "xno"; then
 726         want_threads=no
 727 fi
 728 if test "x$want_threads" = "xnone"; then
 729         want_threads=no
 730 fi
 731
 732 dnl error and warning message
 733 dnl *************************
 734
 735 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
 736                 computer. GLib will not have a default thread implementation."
 737
 738 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
 739                 platform (normaly it's "_REENTRANT"). I'll not use any flag on
 740                 compilation now, but then your programs might not work.
 741                 Please provide information on how it is done on your system."
 742
 743 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
 744                 "
 745
 746 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
 747                 provide information on your thread implementation.
 748                 You can also run 'configure --disable-threads'
 749                 to compile without thread support."
 750
 751 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
 752                 functions will not be MT-safe during their first call because
 753                 there is no working 'getpwuid_r' on your system."
 754
 755 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
 756                 because there is no 'localtime_r' on your system."
 757
 758 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
 759                 crude surrogate will be used. If you happen to know a
 760                 yield function for your system, please inform the GLib
 761                 developers."
 762
 763 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
 764                 threads on your system. Thus threads can only have the default
 765                 priority. If you happen to know these main/max
 766                 priorities, please inform the GLib developers."
 767
 768
 769 dnl determination of thread implementation
 770 dnl ***************************************
 771
 772 have_threads=none
 773 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
 774         case $host in
 775                 *-*-solaris*)
 776                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
 777                 ;;
 778         esac
 779 fi
 780 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
 781                                 || test "x$want_threads" = xdce; then
 782         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
 783         # -U_OSF_SOURCE is for Digital UNIX 4.0d
 784         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
 785         glib_save_CPPFLAGS="$CPPFLAGS"
 786         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 787         if test "x$have_threads" = xnone; then
 788                 AC_TRY_COMPILE([#include <pthread.h>],
 789                         [pthread_attr_t attr; pthread_attr_init(&attr);],
 790                         have_threads=posix)
 791         fi
 792         if test "x$have_threads" = xnone; then
 793                 AC_TRY_COMPILE([#include <pthread.h>],
 794                         [pthread_attr_t attr; pthread_attr_create(&attr);],
 795                         have_threads=posix)
 796         fi
 797         CPPFLAGS="$glib_save_CPPFLAGS"
 798 fi
 799
 800 AC_MSG_CHECKING(for thread implementation)
 801
 802 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
 803         AC_MSG_RESULT(none available)
 804         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
 805 else
 806         AC_MSG_RESULT($have_threads)
 807 fi
 808
 809
 810 dnl determination of G_THREAD_CFLAGS
 811 dnl ********************************
 812
 813 G_THREAD_LIBS=
 814 G_THREAD_LIBS_EXTRA=
 815 G_THREAD_CFLAGS=
 816
 817 if test x"$have_threads" != xnone; then
 818
 819     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
 820
 821     case $host in
 822         *-aix*)
 823                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 824                 if test x"$GCC" = xyes; then
 825                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
 826                 fi
 827                 ;;
 828         *-freebsd2.2*)
 829                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 830
 831                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
 832                 # -mthreads flag.
 833                 ;;
 834         *-sysv5uw7*)  # UnixWare 7
 835                 if test "$GCC" != "yes"; then
 836                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
 837                 else
 838                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
 839                 fi
 840                 ;;
 841         *-dg-dgux*)  # DG/UX
 842                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
 843     esac
 844
 845     # if we are not finding the ctime_r function, then we probably are
 846     # not using the proper multithread flag
 847
 848     glib_save_CPPFLAGS="$CPPFLAGS"
 849     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
 850
 851     AC_TRY_COMPILE([#include <time.h>],
 852         [time_t t; char b[30]; ctime_r (&t, b);], ,
 853             [AC_TRY_COMPILE([#include <time.h>],
 854                 [time_t t; char b[30]; ctime_r (&t, b, 30);], ,
 855                         AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
 856
 857     CPPFLAGS="$glib_save_CPPFLAGS"
 858
 859     AC_MSG_CHECKING(thread related cflags)
 860     AC_MSG_RESULT($G_THREAD_CFLAGS)
 861     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
 862 fi
 863
 864 dnl determination of G_THREAD_LIBS
 865 dnl ******************************
 866
 867 mutex_has_default=no
 868 case $have_threads in
 869         posix|dce)
 870            glib_save_CPPFLAGS="$CPPFLAGS"
 871            CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 872            G_THREAD_LIBS=error
 873            glib_save_LIBS="$LIBS"
 874            case $host in
 875              *-sysv5uw7*) # UnixWare 7
 876                 if test "$GCC" != "yes"; then
 877                         G_THREAD_LIBS="-Kthread"
 878                 else
 879                         G_THREAD_LIBS="-pthread"
 880                 fi
 881                 ;;
 882              *)
 883                 for thread_lib in "" pthread pthreads c_r thread dce; do
 884                         if test x"$thread_lib" = x; then
 885                                 add_thread_lib=""
 886                                 IN=""
 887                         else
 888                                 add_thread_lib="-l$thread_lib"
 889                                 IN=" in -l$thread_lib"
 890                         fi
 891                         if test x"$have_threads" = xposix; then
 892                                 defattr=0
 893                         else
 894                                 defattr=pthread_attr_default
 895                         fi
 896
 897                         LIBS="$glib_save_LIBS $add_thread_lib"
 898
 899                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
 900                         AC_TRY_RUN([#include <pthread.h>
 901                                 int check_me = 0;
 902                                 void* func(void* data) {check_me = 42;}
 903                                 main()
 904                                 { pthread_t t;
 905                                   void *ret;
 906                                   pthread_create (&t, $defattr, func, 0);
 907                                   pthread_join (t, &ret);
 908                                   exit (check_me != 42);
 909                                 }],
 910                                 [AC_MSG_RESULT(yes)
 911                                 G_THREAD_LIBS="$add_thread_lib"
 912                                 break],
 913                                 [AC_MSG_RESULT(no)])
 914                 done
 915                 if test "x$G_THREAD_LIBS" = xerror; then
 916                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
 917                 fi
 918                 for thread_lib in "" rt rte; do
 919                         if test x"$thread_lib" = x; then
 920                                 add_thread_lib=""
 921                                 IN=""
 922                         else
 923                                 add_thread_lib="-l$thread_lib"
 924                                 IN=" in -l$thread_lib"
 925                         fi
 926                         LIBS="$glib_save_LIBS $add_thread_lib"
 927
 928                         AC_MSG_CHECKING(for sched_get_priority_min$IN)
 929                         AC_TRY_RUN([#include <sched.h>
 930                                 #include <errno.h>
 931                                 int main() {
 932                                 errno = 0;
 933                                 return sched_get_priority_min(SCHED_OTHER)==-1
 934                                         && errno != 0;
 935                                 }],
 936                                 [AC_MSG_RESULT(yes)
 937                                 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
 938                                 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
 939                                 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
 940                                 break],
 941                                 [AC_MSG_RESULT(no)])
 942                 done
 943                 LIBS="$glib_save_LIBS"
 944                 ;;
 945            esac
 946            mutex_has_default=yes
 947            mutex_default_type='pthread_mutex_t'
 948            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
 949            mutex_header_file='pthread.h'
 950            if test "x$have_threads" = "xposix"; then
 951              g_threads_impl="POSIX"
 952            else
 953              g_threads_impl="DCE"
 954              have_threads="posix"
 955            fi
 956            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
 957            CPPFLAGS="$glib_save_CPPFLAGS"
 958            ;;
 959         solaris)
 960            G_THREAD_LIBS=error
 961            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
 962            mutex_has_default=yes
 963            mutex_default_type='mutex_t'
 964            mutex_default_init="DEFAULTMUTEX"
 965            mutex_header_file='thread.h'
 966            g_threads_impl="SOLARIS"
 967            ;;
 968         none)
 969            g_threads_impl="NONE"
 970            ;;
 971         *)
 972            g_threads_impl="NONE"
 973            G_THREAD_LIBS=error
 974            ;;
 975 esac
 976
 977 if test "x$G_THREAD_LIBS" = xerror; then
 978         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
 979 fi
 980
 981 case $host in
 982   *-*-beos*)
 983     G_THREAD_LIBS="-lbe -lroot -lglib "
 984     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 985     ;;
 986   *)
 987     ;;
 988 esac
 989
 990 AC_MSG_CHECKING(thread related libraries)
 991 AC_MSG_RESULT($G_THREAD_LIBS)
 992
 993 dnl check for mt safe function variants and some posix functions
 994 dnl ************************************************************
 995
 996 if test x"$have_threads" != xnone; then
 997         glib_save_LIBS="$LIBS"
 998         # we are not doing the following for now, as this might require glib
 999         # to always be linked with the thread libs on some platforms.
1000         # LIBS="$LIBS $G_THREAD_LIBS"
1001         AC_CHECK_FUNCS(localtime_r)
1002         if test "$ac_cv_header_pwd_h" = "yes"; then
1003                 AC_CACHE_CHECK([for posix getpwuid_r],
1004                         ac_cv_func_posix_getpwuid_r,
1005                         [AC_TRY_RUN([#include <errno.h>
1006                                 #include <pwd.h>
1007                                 int main () { char buffer[10000];
1008                                 struct passwd pwd, *pwptr = &pwd;
1009                                 int error;
1010                                 errno = 0;
1011                                 error = getpwuid_r (0, &pwd, buffer,
1012                                         sizeof (buffer), &pwptr);
1013                                 return (error < 0 && errno == ENOSYS)
1014                                         || error == ENOSYS; }],
1015                                 [ac_cv_func_posix_getpwuid_r=yes],
1016                                 [ac_cv_func_posix_getpwuid_r=no])])
1017                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1018                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1019                                 [Have POSIX function getpwuid_r])
1020                 else
1021                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1022                                 ac_cv_func_nonposix_getpwuid_r,
1023                                 [AC_TRY_COMPILE([#include <pwd.h>],
1024                                         [char buffer[10000];
1025                                         struct passwd pwd;
1026                                         getpwuid_r (0, &pwd, buffer,
1027                                                         sizeof (buffer));],
1028                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1029                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1030                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1031                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1032                                         [Have non-POSIX function getpwuid_r])
1033                         fi
1034                 fi
1035         fi
1036         LIBS="$LIBS $G_THREAD_LIBS"
1037         if test x"$have_threads" = xposix; then
1038                 glib_save_CPPFLAGS="$CPPFLAGS"
1039                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1040                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1041                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, core_system_thread)
1042                 # This is not AC_CHECK_FUNC to also work with function
1043                 # name mangling in header files.
1044                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1045                 AC_TRY_LINK([#include <pthread.h>],
1046                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1047                         [AC_MSG_RESULT(yes)
1048                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1049                                   [Have function pthread_attr_setstacksize])],
1050                         [AC_MSG_RESULT(no)])
1051                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1052                 if test x"$posix_priority_min" = xnone; then
1053                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1054                                 PX_PRIO_MIN],,[
1055                                 posix_priority_min=PX_PRIO_MIN
1056                                 posix_priority_max=PX_PRIO_MAX])
1057                 fi
1058                 if test x"$posix_priority_min" = xnone; then
1059                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1060                                 PRI_OTHER_MIN],,[
1061                                 posix_priority_min=PRI_OTHER_MIN
1062                                 posix_priority_max=PRI_OTHER_MAX])
1063                 fi
1064                 if test x"$posix_priority_min" = x; then
1065                         AC_MSG_RESULT(none found)
1066                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1067                         posix_priority_min=-1
1068                         posix_priority_max=-1
1069                 else
1070                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1071                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1072                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1073                 fi
1074                 posix_yield_func=none
1075                 AC_MSG_CHECKING(for posix yield function)
1076                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1077                                                         thr_yield; do
1078                         AC_TRY_LINK([#include <pthread.h>],
1079                                 [$yield_func()],
1080                                 [posix_yield_func="$yield_func"
1081                                 break])
1082                 done
1083                 if test x"$posix_yield_func" = xnone; then
1084                         AC_MSG_RESULT(none found)
1085                         AC_MSG_WARN($POSIX_NO_YIELD)
1086                         posix_yield_func="g_usleep(1000)"
1087                 else
1088                         AC_MSG_RESULT($posix_yield_func)
1089                         posix_yield_func="$posix_yield_func()"
1090                 fi
1091                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1092                 CPPFLAGS="$glib_save_CPPFLAGS"
1093
1094                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1095                 glib_system_thread_size_growth=0
1096                 AC_TRY_RUN([#include <pthread.h>
1097                         #include <sys/types.h>
1098                         #include <unistd.h>
1099                         pid_t other_pid = 0;
1100
1101                         void* func(void* data) {other_pid = getpid();}
1102                         main()
1103                         { pthread_t t;
1104                           void *ret;
1105                           pthread_create (&t, $defattr, func, NULL);
1106                           pthread_join (t, &ret);
1107                           exit (getpid()==other_pid ||
1108                                 $posix_priority_min != $posix_priority_max);
1109                         }],
1110                         [AC_MSG_RESULT(yes),
1111                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1112                           glib_system_thread_size_growth=$ac_cv_sizeof_long
1113                         ],
1114                         [AC_MSG_RESULT(no)])
1115                 dnl make sure both glib_cv_sizeof_system_thread and GLIB_SIZEOF_SYSTEM_THREAD are setup
1116                 glib_cv_sizeof_system_thread=`expr $glib_cv_sizeof_core_system_thread + $glib_system_thread_size_growth`
1117                 AC_DEFINE_UNQUOTED(GLIB_SIZEOF_SYSTEM_THREAD, $glib_cv_sizeof_system_thread)
1118         else # solaris threads
1119                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1120         fi
1121
1122         LIBS="$glib_save_LIBS"
1123
1124         # now spit out all the warnings.
1125         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1126            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1127                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1128         fi
1129         if test "$ac_cv_func_localtime_r" != "yes"; then
1130                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1131         fi
1132 else
1133         # If no thread implementation exists, we will provide enough
1134         # space for a pointer
1135         GLIB_SIZEOF(, void*, system_thread)
1136 fi
1137
1138 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1139                    [Source file containing theread implementation])
1140 AC_SUBST(G_THREAD_CFLAGS)
1141 AC_SUBST(G_THREAD_LIBS)
1142 AC_SUBST(G_THREAD_LIBS_EXTRA)
1143
1144 dnl **********************************************
1145 dnl *** GDefaultMutex setup and initialization ***
1146 dnl **********************************************
1147 dnl
1148 dnl if mutex_has_default = yes, we also got
1149 dnl mutex_default_type, mutex_default_init and mutex_header_file
1150 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1151         glib_save_CPPFLAGS="$CPPFLAGS"
1152         glib_save_LIBS="$LIBS"
1153         LIBS="$LIBS $G_THREAD_LIBS"
1154         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1155         GLIB_SIZEOF([#include <$mutex_header_file>],
1156                     $mutex_default_type,
1157                     gmutex,
1158                     )
1159         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1160                            $mutex_default_type,
1161                            gmutex,
1162                            $glib_cv_sizeof_gmutex,
1163                            $mutex_default_init)
1164         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1165                 mutex_has_default=no
1166         fi
1167         CPPFLAGS="$glib_save_CPPFLAGS"
1168         LIBS="$glib_save_LIBS"
1169         ,
1170 )
1171
1172
1173 dnl ****************************************
1174 dnl *** GLib POLL* compatibility defines ***
1175 dnl ****************************************
1176 GLIB_SYSDEFS(
1177 [#include <sys/types.h>
1178 #include <sys/poll.h>],
1179         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1180         glibconfig-sysdefs.h,
1181         =)
1182
1183 dnl ***********************
1184 dnl *** Tests for iconv ***
1185 dnl ***********************
1186
1187 AC_ARG_WITH(libiconv, [ --with-libiconv     Use the libiconv library ],,with_libiconv=maybe)
1188
1189 found_iconv=no
1190
1191 if test "x$with_libiconv" != "xyes" ; then
1192    #
1193    # Check in the C library
1194    #
1195    AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes)
1196 fi
1197
1198 if test "x$with_libiconv" != "xno" ; then
1199    #
1200    # Check for libiconv
1201    #
1202    AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=yes; found_iconv=yes)
1203 fi
1204
1205 if test "x$found_iconv" = "xno" ; then
1206    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
1207 fi
1208
1209 if test "x$with_libiconv" = "xyes" ; then
1210   ICONV_LIBS="-liconv"
1211   AC_DEFINE(USE_LIBICONV)
1212 fi
1213 AC_SUBST(ICONV_LIBS)
1214
1215 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1216 dnl since we need it for g_iconv()
1217
1218 AC_MSG_CHECKING([for EILSEQ])
1219 AC_TRY_COMPILE([
1220 #include <errno.h>
1221 ],
1222 [
1223 int error = EILSEQ;
1224 ], have_eilseq=yes, have_eilseq=no);
1225 AC_MSG_RESULT($have_eilseq)
1226
1227 dnl **************************
1228 dnl *** Checks for gtk-doc ***
1229 dnl **************************
1230
1231 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH path to installed docs ])
1232
1233 if test "x$with_html_dir" = "x" ; then
1234   HTML_DIR='${datadir}/gtk-doc/html'
1235 else
1236   HTML_DIR=$with_html_dir
1237 fi
1238
1239 AC_SUBST(HTML_DIR)
1240
1241
1242 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1243 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1244 AC_SUBST(HAVE_GTK_DOC)
1245
1246 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1247 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1248
1249 dnl Let people disable the gtk-doc stuff.
1250 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc  Use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)
1251
1252 if test x$enable_gtk_doc = xauto ; then
1253   if test x$GTKDOC = xtrue ; then
1254     enable_gtk_doc=yes
1255   else
1256     enable_gtk_doc=no
1257   fi
1258 fi
1259
1260 dnl NOTE: We need to use a separate automake conditional for this
1261 dnl       to make this work with the tarballs.
1262 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1263
1264 dnl ******************************
1265 dnl *** output the whole stuff ***
1266 dnl ******************************
1267
1268 AC_OUTPUT_COMMANDS([
1269
1270 ## Generate `glibconfig.h' in two cases
1271 ## 1. `config.status' is run either explicitly, or via configure.
1272 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1273 ##     config.h
1274 ## 2. CONFIG_OTHER is set explicitly
1275 ##
1276 ## Case 1 is difficult.  We know that `automake' sets one of
1277 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1278 ## only when AM_CONFIG_HEADER is set, however.
1279
1280 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1281   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1282   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1283 fi
1284 case "$CONFIG_OTHER" in
1285 *glibconfig.h*)
1286         echo creating glibconfig.h
1287         outfile=glibconfig.h-tmp
1288         cat > $outfile <<\_______EOF
1289 /* glibconfig.h
1290  *
1291  * This is a generated file.  Please modify 'configure.in'
1292  */
1293
1294 #ifndef __G_LIBCONFIG_H__
1295 #define __G_LIBCONFIG_H__
1296
1297 #include <gmacros.h>
1298
1299 _______EOF
1300
1301         if test x$glib_limits_h = xyes; then
1302           echo '#include <limits.h>' >> $outfile
1303         fi
1304         if test x$glib_float_h = xyes; then
1305           echo '#include <float.h>' >> $outfile
1306         fi
1307         if test x$glib_values_h = xyes; then
1308           echo '#include <values.h>' >> $outfile
1309         fi
1310         if test "$glib_header_alloca_h" = "yes"; then
1311           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1312         fi
1313         if test x$glib_sys_poll_h = xyes; then
1314           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1315         fi
1316
1317         cat >> $outfile <<_______EOF
1318
1319 G_BEGIN_DECLS
1320
1321 #define G_MINFLOAT      $glib_mf
1322 #define G_MAXFLOAT      $glib_Mf
1323 #define G_MINDOUBLE     $glib_md
1324 #define G_MAXDOUBLE     $glib_Md
1325 #define G_MINSHORT      $glib_ms
1326 #define G_MAXSHORT      $glib_Ms
1327 #define G_MAXUSHORT     $glib_Mus
1328 #define G_MININT        $glib_mi
1329 #define G_MAXINT        $glib_Mi
1330 #define G_MAXUINT       $glib_Mui
1331 #define G_MINLONG       $glib_ml
1332 #define G_MAXLONG       $glib_Ml
1333 #define G_MAXULONG      $glib_Mul
1334
1335 _______EOF
1336
1337
1338         ### this should always be true in a modern C/C++ compiler
1339         cat >>$outfile <<_______EOF
1340 typedef signed char gint8;
1341 typedef unsigned char guint8;
1342 _______EOF
1343
1344
1345         if test -n "$gint16"; then
1346           cat >>$outfile <<_______EOF
1347 typedef signed $gint16 gint16;
1348 typedef unsigned $gint16 guint16;
1349 #define G_GINT16_FORMAT $gint16_format
1350 #define G_GUINT16_FORMAT $guint16_format
1351 _______EOF
1352         fi
1353
1354
1355         if test -n "$gint32"; then
1356           cat >>$outfile <<_______EOF
1357 typedef signed $gint32 gint32;
1358 typedef unsigned $gint32 guint32;
1359 #define G_GINT32_FORMAT $gint32_format
1360 #define G_GUINT32_FORMAT $guint32_format
1361 _______EOF
1362         fi
1363
1364
1365         if test -n "$gint64"; then
1366           cat >>$outfile <<_______EOF
1367 #define G_HAVE_GINT64 1
1368
1369 ${glib_extension}typedef signed $gint64 gint64;
1370 ${glib_extension}typedef unsigned $gint64 guint64;
1371
1372 #define G_GINT64_CONSTANT(val)  $gint64_constant
1373 _______EOF
1374                 if test -n "$gint64_format"; then
1375           cat >>$outfile <<_______EOF
1376 #define G_GINT64_FORMAT $gint64_format
1377 #define G_GUINT64_FORMAT $guint64_format
1378 _______EOF
1379                 fi
1380         fi
1381
1382         cat >>$outfile <<_______EOF
1383
1384 #define GLIB_SIZEOF_VOID_P $glib_void_p
1385 #define GLIB_SIZEOF_LONG   $glib_long
1386
1387 _______EOF
1388
1389         case x$glib_size_t in
1390         x2) echo "typedef gint16  gssize;" >> $outfile
1391             echo "typedef guint16 gsize;"  >> $outfile
1392             ;;
1393         x4) echo "typedef gint32  gssize;" >> $outfile
1394             echo "typedef guint32 gsize;"  >> $outfile
1395             ;;
1396         x8) echo "typedef gint64  gssize;" >> $outfile
1397             echo "typedef guint64 gsize;"  >> $outfile
1398             ;;
1399         *)  echo "#error size of size_t is unknown" >> $outfile
1400             ;;
1401         esac
1402
1403         if test -z "$glib_unknown_void_p"; then
1404           cat >>$outfile <<_______EOF
1405
1406 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1407 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1408
1409 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1410 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1411 _______EOF
1412         else
1413           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1414         fi
1415
1416
1417
1418         cat >>$outfile <<_______EOF
1419 $glib_atexit
1420 $glib_memmove
1421 $glib_defines
1422 $glib_os
1423
1424 $glib_vacopy
1425
1426 #ifdef  __cplusplus
1427 #define G_HAVE_INLINE   1
1428 #else   /* !__cplusplus */
1429 $glib_inline
1430 #endif  /* !__cplusplus */
1431 _______EOF
1432
1433         echo >>$outfile
1434         if test x$g_have_eilseq = xno; then
1435                 cat >>$outfile <<_______EOF
1436 #ifndef EILSEQ
1437 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1438  * The correspondence between this and the corresponding definition
1439  * in libiconv is essential.
1440  */
1441 #  define EILSEQ ENOENT
1442 #endif
1443 _______EOF
1444
1445         fi
1446
1447         echo >>$outfile
1448         if test x$g_mutex_has_default = xyes; then
1449                 cat >>$outfile <<_______EOF
1450 $g_enable_threads_def G_THREADS_ENABLED
1451 #define G_THREADS_IMPL_$g_threads_impl_def
1452 typedef struct _GStaticMutex GStaticMutex;
1453 struct _GStaticMutex
1454 {
1455   struct _GMutex *runtime_mutex;
1456   struct {
1457     union {
1458       char   pad[$g_mutex_sizeof];
1459       double dummy_double;
1460       void  *dummy_pointer;
1461       long   dummy_long;
1462     } mutex;
1463     void *debug_info;
1464   } static_mutex;
1465 };
1466 #define G_STATIC_MUTEX_INIT     { NULL, { { { $g_mutex_contents} }, NULL } }
1467 #define g_static_mutex_get_mutex(mutex) \
1468   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1469    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1470 _______EOF
1471         else
1472                 cat >>$outfile <<_______EOF
1473 $g_enable_threads_def G_THREADS_ENABLED
1474 #define G_THREADS_IMPL_$g_threads_impl_def
1475 typedef struct _GMutex* GStaticMutex;
1476 #define G_STATIC_MUTEX_INIT NULL
1477 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1478 _______EOF
1479         fi
1480
1481         cat >>$outfile <<_______EOF
1482 /* This represents a system thread as used by the implementation. An
1483  * alien implementaion, as loaded by g_thread_init can only count on
1484  * "sizeof (gpointer)" bytes to store their info. We however need more
1485  * for some of our native implementations. */
1486 typedef union _GSystemThread GSystemThread;
1487 union _GSystemThread
1488 {
1489   char   data[$g_system_thread_sizeof];
1490   double dummy_double;
1491   void  *dummy_pointer;
1492   long   dummy_long;
1493 };
1494 _______EOF
1495
1496         echo >>$outfile
1497         g_bit_sizes="16 32"
1498         if test -n "$gint64"; then
1499           g_bit_sizes="$g_bit_sizes 64"
1500         fi
1501         for bits in $g_bit_sizes; do
1502           cat >>$outfile <<_______EOF
1503 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1504 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1505 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1506 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1507 _______EOF
1508         done
1509
1510         cat >>$outfile <<_______EOF
1511 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1512 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1513 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1514 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1515 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1516 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1517 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1518 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1519 #define G_BYTE_ORDER $g_byte_order
1520
1521 _______EOF
1522
1523         if test -r glibconfig-sysdefs.h; then
1524           cat glibconfig-sysdefs.h >>$outfile
1525         fi
1526
1527         cat >>$outfile <<_______EOF
1528
1529 #define G_MODULE_SUFFIX "$g_module_suffix"
1530
1531 G_END_DECLS
1532
1533 #endif /* GLIBCONFIG_H */
1534 _______EOF
1535
1536
1537         if cmp -s $outfile glibconfig.h; then
1538           echo glibconfig.h is unchanged
1539           rm -f $outfile
1540         else
1541           mv $outfile glibconfig.h
1542         fi ;;
1543 esac
1544 ],[
1545
1546 # Note that if two cases are the same, case goes with the first one.
1547 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1548 # on variable expansion in case labels.  Look at the generated config.status
1549 # for a hint.
1550
1551 glib_header_alloca_h="$ac_cv_header_alloca_h"
1552
1553 case xyes in
1554 x$ac_cv_header_float_h)
1555   glib_float_h=yes
1556   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1557   glib_md=DBL_MIN glib_Md=DBL_MAX
1558   ;;
1559 x$ac_cv_header_values_h)
1560   glib_values_h=yes
1561   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1562   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1563   ;;
1564 esac
1565
1566 case xyes in
1567 x$ac_cv_header_limits_h)
1568   glib_limits_h=yes
1569   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1570   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1571   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1572   ;;
1573 x$ac_cv_header_values_h)
1574   glib_values_h=yes
1575   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1576   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1577   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1578   ;;
1579 esac
1580
1581 if test x$ac_cv_header_sys_poll_h = xyes ; then
1582   glib_sys_poll_h=yes
1583 fi
1584
1585 case 2 in
1586 $ac_cv_sizeof_short)
1587   gint16=short
1588   gint16_format='"hi"'
1589   guint16_format='"hu"'
1590   ;;
1591 $ac_cv_sizeof_int)
1592   gint16=int
1593   gint16_format='"i"'
1594   guint16_format='"u"'
1595   ;;
1596 esac
1597 case 4 in
1598 $ac_cv_sizeof_short)
1599   gint32=short
1600   gint32_format='"hi"'
1601   guint32_format='"hu"'
1602   ;;
1603 $ac_cv_sizeof_int)
1604   gint32=int
1605   gint32_format='"i"'
1606   guint32_format='"u"'
1607   ;;
1608 $ac_cv_sizeof_long)
1609   gint32=long
1610   gint32_format='"li"'
1611   guint32_format='"lu"'
1612   ;;
1613 esac
1614 case 8 in
1615 $ac_cv_sizeof_int)
1616   gint64=int
1617   gint64_format='"i"'
1618   guint64_format='"u"'
1619   glib_extension=
1620   gint64_constant='(val)'
1621   ;;
1622 $ac_cv_sizeof_long)
1623   gint64=long
1624   gint64_format='"li"'
1625   guint64_format='"lu"'
1626   glib_extension=
1627   gint64_constant='(val##L)'
1628   ;;
1629 $ac_cv_sizeof_long_long)
1630   gint64='long long'
1631   if test -n "$glib_cv_long_long_format"; then
1632     gint64_format='"'$glib_cv_long_long_format'i"'
1633     guint64_format='"'$glib_cv_long_long_format'u"'
1634   fi
1635   glib_extension='G_GNUC_EXTENSION '
1636   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1637   ;;
1638 esac
1639 glib_size_t=$glib_cv_sizeof_size_t
1640 glib_void_p=$ac_cv_sizeof_long
1641 glib_long=$ac_cv_sizeof_void_p
1642
1643 gintbits=`expr $ac_cv_sizeof_int \* 8`
1644 glongbits=`expr $ac_cv_sizeof_long \* 8`
1645
1646
1647 case $ac_cv_sizeof_void_p in
1648 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
1649 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
1650 *)                      glib_unknown_void_p=yes ;;
1651 esac
1652
1653
1654 case xyes in
1655 x$ac_cv_func_atexit)
1656   glib_atexit="
1657 #ifdef NeXT /* @#%@! NeXTStep */
1658 # define g_ATEXIT(proc) (!atexit (proc))
1659 #else
1660 # define g_ATEXIT(proc) (atexit (proc))
1661 #endif"
1662   ;;
1663 x$ac_cv_func_on_exit)
1664   glib_atexit="
1665 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
1666   ;;
1667 esac
1668
1669 case xyes in
1670 x$ac_cv_func_memmove)
1671   glib_memmove='
1672 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
1673   ;;
1674 x$glib_cv_working_bcopy)
1675   glib_memmove="
1676 /* memmove isn't available, but bcopy can copy overlapping memory regions */
1677 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
1678   ;;
1679 *)
1680   glib_memmove="
1681 /* memmove isn't found and bcopy can't copy overlapping memory regions,
1682  * so we have to roll our own copy routine. */
1683 void g_memmove (void* dest, const void * src, unsigned long len);"
1684   ;;
1685 esac
1686
1687 glib_defines="
1688 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
1689 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
1690 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
1691 "
1692
1693 case xyes in
1694 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
1695 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
1696 *)                      glib_vacopy=''
1697 esac
1698
1699 if test x$glib_cv_va_val_copy = xno; then
1700   glib_vacopy="\$glib_vacopy
1701 #define G_VA_COPY_AS_ARRAY 1"
1702 fi
1703
1704 if test x$glib_cv_hasinline = xyes; then
1705     glib_inline='#define G_HAVE_INLINE 1'
1706 fi
1707 if test x$glib_cv_has__inline = xyes; then
1708     glib_inline="\$glib_inline
1709 #define G_HAVE___INLINE 1"
1710 fi
1711 if test x$glib_cv_has__inline__ = xyes; then
1712     glib_inline="\$glib_inline
1713 #define G_HAVE___INLINE__ 1"
1714 fi
1715
1716 case xyes in
1717 x$ac_cv_c_bigendian)
1718   g_byte_order=G_BIG_ENDIAN
1719   g_bs_native=BE
1720   g_bs_alien=LE
1721   ;;
1722 *)
1723   g_byte_order=G_LITTLE_ENDIAN
1724   g_bs_native=LE
1725   g_bs_alien=BE
1726   ;;
1727 esac
1728
1729 g_have_eilseq=$have_eilseq
1730
1731 case x$have_threads in
1732 xnone)  g_enable_threads_def="#undef";;
1733 *)      g_enable_threads_def="#define";;
1734 esac
1735
1736 g_threads_impl_def=$g_threads_impl
1737
1738 g_mutex_has_default="$mutex_has_default"
1739 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
1740 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
1741 g_mutex_contents="$glib_cv_byte_contents_gmutex"
1742
1743 g_module_suffix="$glib_gmodule_suffix"
1744
1745 case $host in
1746   *-*-beos*)
1747     glib_os="#define G_OS_BEOS"
1748     ;;
1749   *-*-cygwin*)
1750     glib_os="#define G_OS_UNIX
1751 #define G_WITH_CYGWIN"
1752 v    ;;
1753   *)
1754     glib_os="#define G_OS_UNIX"
1755     ;;
1756 esac
1757 ])
1758
1759 AC_OUTPUT([
1760 glib-2.0.pc
1761 gmodule-2.0.pc
1762 gthread-2.0.pc
1763 gobject-2.0.pc
1764 glib.spec
1765 Makefile
1766 build/Makefile
1767 build/win32/Makefile
1768 gmodule/gmoduleconf.h
1769 gmodule/Makefile
1770 gobject/Makefile
1771 gthread/Makefile
1772 docs/Makefile
1773 docs/glib-config.1
1774 docs/reference/Makefile
1775 docs/reference/glib/Makefile
1776 docs/reference/gobject/Makefile
1777 tests/Makefile
1778 ],[case "$CONFIG_FILES" in
1779 *glib-config-2.0*)chmod +x glib-config-2.0;;
1780 esac
1781 echo ""
1782 echo " *** IMPORTANT *** "
1783 echo ""
1784 echo "This is a development version of GLib.  You should be using a stable"
1785 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
1786 echo "version you just configured is meant for developers of GLib only:"
1787 echo ""
1788 echo "  * You should not base stable software on this version of GLib."
1789 echo "  * GNOME developers should use a stable version of GLib."
1790 echo ""
1791 echo "If you install this version of GLib, we strongly recommend that you"
1792 echo "install it in a different prefix than GLib 1.2.  Use --prefix as an"
1793 echo "argument to configure to do this.  Otherwise, you will not be able to"
1794 echo "do development with GLib 1.2 any longer."
1795 echo ""
1796 echo " *** You should be using GLib 1.2 instead. ***"
1797 ])