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