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