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