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