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