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