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