configure.in

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