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