configure.in

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