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