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 be bg ca cs de el es eu fr gl hi ja ko ms nl nn no pl pt pt_BR ro ru sk sl sq 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 if test x"$glib_native_win32" = xyes; then
 919   dnl No use for this on Win32
 920   G_MODULE_LDFLAGS=
 921 else
 922   G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
 923 fi
 924 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 925 G_MODULE_NEED_USCORE=0
 926 G_MODULE_BROKEN_RTLD_GLOBAL=0
 927 G_MODULE_HAVE_DLERROR=0
 928 dnl *** force native WIN32 shared lib loader
 929 if test -z "$G_MODULE_IMPL"; then
 930   case "$host" in
 931   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
 932   esac
 933 fi
 934 dnl *** dlopen() and dlsym() in system libraries
 935 if test -z "$G_MODULE_IMPL"; then
 936         AC_CHECK_FUNC(dlopen,
 937                       [AC_CHECK_FUNC(dlsym,
 938                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 939                       [])
 940 fi
 941 dnl *** load_image (BeOS)
 942 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
 943   AC_CHECK_LIB(root, load_image,
 944       [G_MODULE_LIBS="-lbe -lroot -lglib"
 945       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 946       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 947       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
 948       [])
 949 fi
 950 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
 951 if test -z "$G_MODULE_IMPL"; then
 952         AC_CHECK_FUNC(NSLinkModule,
 953                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
 954                        G_MODULE_NEED_USCORE=1],
 955                       [])
 956 fi
 957 dnl *** dlopen() and dlsym() in libdl
 958 if test -z "$G_MODULE_IMPL"; then
 959         AC_CHECK_LIB(dl, dlopen,
 960                      [AC_CHECK_LIB(dl, dlsym,
 961                                    [G_MODULE_LIBS=-ldl
 962                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 963                      [])
 964 fi
 965 dnl *** shl_load() in libdld (HP-UX)
 966 if test -z "$G_MODULE_IMPL"; then
 967         AC_CHECK_LIB(dld, shl_load,
 968                 [G_MODULE_LIBS=-ldld
 969                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
 970                 [])
 971 fi
 972 dnl *** additional checks for G_MODULE_IMPL_DL
 973 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 974         LIBS_orig="$LIBS"
 975         LDFLAGS_orig="$LDFLAGS"
 976         LIBS="$LIBS $G_MODULE_LIBS"
 977         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 978 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
 979         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
 980                 glib_cv_rtldglobal_broken,[
 981                 AC_TRY_RUN([
 982                 #include <dlfcn.h>
 983                 #ifndef RTLD_GLOBAL
 984                 #define RTLD_GLOBAL 0
 985                 #endif
 986                 #ifndef RTLD_LAZY
 987                 #define RTLD_LAZY 0
 988                 #endif
 989                 int pthread_create;
 990                 int main () {
 991                 void *handle, *global, *local;
 992                 global = &pthread_create;
 993                 handle = dlopen ("libpthread.so", RTLD_GLOBAL | RTLD_LAZY);
 994                 if (!handle) return 0;
 995                 local = dlsym (handle, "pthread_create");
 996                 return global == local;
 997                 }],
 998                         [glib_cv_rtldglobal_broken=no],
 999                         [glib_cv_rtldglobal_broken=yes],
1000                         [])
1001                 rm -f plugin.c plugin.o plugin.lo
1002         ])
1003         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1004                 G_MODULE_BROKEN_RTLD_GLOBAL=1
1005         else
1006                 G_MODULE_BROKEN_RTLD_GLOBAL=0
1007         fi
1008 dnl *** check whether we need preceeding underscores
1009         AC_CACHE_CHECK([for preceeding underscore in symbols],
1010                 glib_cv_uscore,[
1011                 AC_TRY_RUN([
1012                 #include <dlfcn.h>
1013                 int glib_underscore_test (void) { return 42; }
1014                 int main() {
1015                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
1016                   handle = dlopen ((void*)0, 0);
1017                   if (handle) {
1018                     f1 = dlsym (handle, "glib_underscore_test");
1019                     f2 = dlsym (handle, "_glib_underscore_test");
1020                   } return (!f2 || f1);
1021                 }],
1022                         [glib_cv_uscore=yes],
1023                         [glib_cv_uscore=no],
1024                         [])
1025                 rm -f plugin.c plugin.$ac_objext plugin.lo
1026         ])
1027         if test "x$glib_cv_uscore" = "xyes"; then
1028                 G_MODULE_NEED_USCORE=1
1029         else
1030                 G_MODULE_NEED_USCORE=0
1031         fi
1032
1033         LDFLAGS="$LDFLAGS_orig"
1034 dnl *** check for having dlerror()
1035         AC_CHECK_FUNC(dlerror,
1036                 [G_MODULE_HAVE_DLERROR=1],
1037                 [G_MODULE_HAVE_DLERROR=0])
1038         LIBS="$LIBS_orig"
1039 fi
1040 dnl *** done, have we got an implementation?
1041 if test -z "$G_MODULE_IMPL"; then
1042         G_MODULE_IMPL=0
1043         G_MODULE_SUPPORTED=false
1044 else
1045         G_MODULE_SUPPORTED=true
1046 fi
1047
1048 AC_MSG_CHECKING(for the suffix of shared libraries)
1049 case "$host_os" in
1050   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
1051     glib_gmodule_suffix='sl'
1052     ;;
1053   cygwin* | mingw*)
1054     glib_gmodule_suffix='dll'
1055     ;;
1056   *)
1057     glib_gmodule_suffix='so'
1058     ;;
1059 esac
1060 AC_MSG_RESULT(.$glib_gmodule_suffix)
1061
1062 AC_SUBST(G_MODULE_SUPPORTED)
1063 AC_SUBST(G_MODULE_IMPL)
1064 AC_SUBST(G_MODULE_LIBS)
1065 AC_SUBST(G_MODULE_LIBS_EXTRA)
1066 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1067 AC_SUBST(G_MODULE_LDFLAGS)
1068 AC_SUBST(G_MODULE_HAVE_DLERROR)
1069 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1070 AC_SUBST(G_MODULE_NEED_USCORE)
1071 AC_SUBST(GLIB_DEBUG_FLAGS)
1072
1073 dnl **********************
1074 dnl *** g_spawn checks ***
1075 dnl **********************
1076
1077 AC_MSG_CHECKING(for gspawn implementation)
1078 case "$host" in
1079   *-*-mingw*)
1080     GSPAWN=gspawn-win32.lo
1081     ;;
1082   *)
1083     GSPAWN=gspawn.lo
1084     ;;
1085 esac
1086 AC_MSG_RESULT($GSPAWN)
1087 AC_SUBST(GSPAWN)
1088
1089 dnl *************************
1090 dnl *** GIOChannel checks ***
1091 dnl *************************
1092
1093 AC_MSG_CHECKING(for GIOChannel implementation)
1094 case "$host" in
1095   *-*-mingw*)
1096     GIO=giowin32.lo
1097     ;;
1098   *)
1099     GIO=giounix.lo
1100     ;;
1101 esac
1102 AC_MSG_RESULT($GIO)
1103 AC_SUBST(GIO)
1104
1105 dnl ****************************************
1106 dnl *** platform dependent source checks ***
1107 dnl ****************************************
1108
1109 AC_MSG_CHECKING(for platform-dependent source)
1110 case "$host" in
1111   *-*-cygwin*|*-*-mingw*)
1112     PLATFORMDEP=gwin32.lo
1113     ;;
1114   *)
1115     PLATFORMDEP=
1116     ;;
1117 esac
1118 AC_MSG_RESULT($PLATFORMDEP)
1119 AC_SUBST(PLATFORMDEP)
1120
1121 AC_MSG_CHECKING([whether to compile timeloop])
1122 case "$host" in
1123   *-*-cygwin*|*-*-mingw*)
1124     enable_timeloop=no
1125     ;;
1126   *)
1127     enable_timeloop=yes
1128     ;;
1129 esac
1130 AC_MSG_RESULT($enable_timeloop)
1131 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1132
1133 AC_MSG_CHECKING([if building for some Win32 platform])
1134 case "$host" in
1135   *-*-mingw*|*-*-cygwin*)
1136     platform_win32=yes
1137     ;;
1138   *)
1139     platform_win32=no
1140     ;;
1141 esac
1142 AC_MSG_RESULT($platform_win32)
1143 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1144
1145 dnl ***********************
1146 dnl *** g_thread checks ***
1147 dnl ***********************
1148
1149 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris/win32] specify a thread implementation to use],
1150         if test "x$with_threads" = x; then
1151                 want_threads=yes
1152         else
1153                 want_threads=$with_threads
1154         fi,
1155         want_threads=yes)
1156 if test "x$enable_threads" = "xno"; then
1157         want_threads=no
1158 fi
1159
1160 dnl error and warning message
1161 dnl *************************
1162
1163 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1164                 computer. GLib will not have a default thread implementation."
1165
1166 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1167                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1168                 compilation now, but then your programs might not work.
1169                 Please provide information on how it is done on your system."
1170
1171 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1172                 "
1173
1174 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1175                 provide information on your thread implementation.
1176                 You can also run 'configure --disable-threads'
1177                 to compile without thread support."
1178
1179 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1180                 functions will not be MT-safe during their first call because
1181                 there is no working 'getpwuid_r' on your system."
1182
1183 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1184                 because there is no 'localtime_r' on your system."
1185
1186 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1187                 crude surrogate will be used. If you happen to know a
1188                 yield function for your system, please inform the GLib
1189                 developers."
1190
1191 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1192                 threads on your system. Thus threads can only have the default
1193                 priority. If you happen to know these main/max
1194                 priorities, please inform the GLib developers."
1195
1196 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1197                 linking threaded applications. As GLib cannot do that
1198                 automatically, you will get an linkg error everytime you are
1199                 not using the right compiler. In that case you have to relink
1200                 with the right compiler. Ususally just '_r' is appended
1201                 to the compiler name."
1202
1203 dnl determination of thread implementation
1204 dnl ***************************************
1205
1206 # have_threads=no   means no thread support
1207 # have_threads=none means no default thread implementation
1208
1209 have_threads=no
1210 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1211         case $host in
1212                 *-*-solaris*)
1213                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1214                 ;;
1215         esac
1216 fi
1217 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1218                                 || test "x$want_threads" = xdce; then
1219         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1220         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1221         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1222         glib_save_CPPFLAGS="$CPPFLAGS"
1223         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1224         if test "x$have_threads" = xno; then
1225                 AC_TRY_COMPILE([#include <pthread.h>],
1226                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1227                         have_threads=posix)
1228         fi
1229         if test "x$have_threads" = xno; then
1230                 AC_TRY_COMPILE([#include <pthread.h>],
1231                         [pthread_mutex_t m;
1232                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1233                         have_threads=dce)
1234         fi
1235         CPPFLAGS="$glib_save_CPPFLAGS"
1236 fi
1237 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1238         case $host in
1239                 *-*-mingw*)
1240                 have_threads=win32
1241                 ;;
1242         esac
1243 fi
1244 if test "x$want_threads" = xnone; then
1245         have_threads=none
1246 fi
1247
1248 AC_MSG_CHECKING(for thread implementation)
1249
1250 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1251         AC_MSG_RESULT(none available)
1252         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1253 else
1254         AC_MSG_RESULT($have_threads)
1255 fi
1256
1257
1258 dnl determination of G_THREAD_CFLAGS
1259 dnl ********************************
1260
1261 G_THREAD_LIBS=
1262 G_THREAD_LIBS_EXTRA=
1263 G_THREAD_CFLAGS=
1264
1265 if test x"$have_threads" != xno; then
1266
1267   if test x"$have_threads" = xposix; then
1268     # First we test for posix, whether -pthread or -pthreads do the trick as
1269     # both CPPFLAG and LIBS.
1270     # One of them does for most gcc versions and some other platforms/compilers
1271     # too and could be considered as the canonical way to go.
1272     for flag in pthread pthreads; do
1273       glib_save_CFLAGS="$CFLAGS"
1274       CFLAGS="$CFLAGS -$flag"
1275       AC_TRY_RUN([#include <pthread.h>
1276                   int check_me = 0;
1277                   void* func(void* data) {return check_me = 42;}
1278                   main()
1279                   { pthread_t t;
1280                     void *ret;
1281                     pthread_create (&t, 0, func, 0);
1282                     pthread_join (t, &ret);
1283                     exit (check_me != 42 || ret != 42);
1284                    }],
1285                    [G_THREAD_CFLAGS=-$flag
1286                     G_THREAD_LIBS=-$flag])
1287       CFLAGS="$glib_save_CFLAGS"
1288     done
1289   fi
1290
1291   if test x"$G_THREAD_CFLAGS" = x; then
1292
1293     # The canonical -pthread[s] does not work. Try something different.
1294
1295     case $host in
1296         *-aix*)
1297                 if test x"$GCC" = xyes; then
1298                         # GCC 3.0 and above needs -pthread.
1299                         # Should be coverd by the case above.
1300                         # GCC 2.x and below needs -mthreads
1301                         G_THREAD_CFLAGS="-mthreads"
1302                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1303                 else
1304                         # We are probably using the aix compiler. Normaly a
1305                         # program would have to be compiled with the _r variant
1306                         # of the corresponding compiler, but we as GLib cannot
1307                         # do that: but the good news is that for compiling the
1308                         # only difference is the added -D_THREAD_SAFE compile
1309                         # option. This is according to the "C for AIX User's
1310                         # Guide".
1311                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1312                 fi
1313                 ;;
1314         *-dg-dgux*)  # DG/UX
1315                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1316                 ;;
1317         *-osf*)
1318                 # So we are using dce threads. posix threads are already
1319                 # catched above.
1320                 G_THREAD_CFLAGS="-threads"
1321                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1322                 ;;
1323         *-solaris*)
1324                 if test x"$GCC" = xyes; then
1325                    # We are using solaris threads. posix threads are
1326                    # already catched above.
1327                         G_THREAD_CFLAGS="-threads"
1328                 else
1329                         G_THREAD_CFLAGS="-mt"
1330                 fi
1331                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1332                 ;;
1333         *-sysv5uw7*) # UnixWare 7
1334                 # We are not using gcc with -pthread. Catched above.
1335                 G_THREAD_CFLAGS="-Kthread"
1336                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1337                 ;;
1338         *)
1339                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1340                 ;;
1341     esac
1342
1343   fi
1344
1345     # if we are not finding the localtime_r function, then we probably are
1346     # not using the proper multithread flag
1347
1348     glib_save_CPPFLAGS="$CPPFLAGS"
1349     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1350
1351     # First we test, whether localtime_r is declared in time.h
1352     # directly. Then we test whether a macro localtime_r exists, in
1353     # which case localtime_r in the test program is replaced and thus
1354     # if we still find localtime_r in the output, it is not defined as
1355     # a macro.
1356
1357     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1358       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1359                                                            localtime_r(a,b)],
1360                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1361
1362     CPPFLAGS="$glib_save_CPPFLAGS"
1363
1364     AC_MSG_CHECKING(thread related cflags)
1365     AC_MSG_RESULT($G_THREAD_CFLAGS)
1366     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1367 fi
1368
1369 dnl determination of G_THREAD_LIBS
1370 dnl ******************************
1371
1372 mutex_has_default=no
1373 case $have_threads in
1374         posix|dce)
1375           if test x"$G_THREAD_LIBS" = x; then
1376             case $host in
1377               *-aix*)
1378                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1379                 # probably using the aix compiler.
1380                 AC_MSG_WARN($AIX_COMPILE_INFO)
1381                 ;;
1382               *)
1383                 glib_save_CPPFLAGS="$CPPFLAGS"
1384                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1385                 G_THREAD_LIBS=error
1386                 glib_save_LIBS="$LIBS"
1387                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1388                         if test x"$thread_lib" = x; then
1389                                 add_thread_lib=""
1390                                 IN=""
1391                         else
1392                                 add_thread_lib="-l$thread_lib"
1393                                 IN=" in -l$thread_lib"
1394                         fi
1395                         if test x"$have_threads" = xposix; then
1396                                 defattr=0
1397                         else
1398                                 defattr=pthread_attr_default
1399                         fi
1400
1401                         LIBS="$glib_save_LIBS $add_thread_lib"
1402
1403                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1404                         AC_TRY_RUN([#include <pthread.h>
1405                                 int check_me = 0;
1406                                 void* func(void* data) {check_me = 42;}
1407                                 main()
1408                                 { pthread_t t;
1409                                   void *ret;
1410                                   pthread_create (&t, $defattr, func, 0);
1411                                   pthread_join (t, &ret);
1412                                   exit (check_me != 42);
1413                                 }],
1414                                 [AC_MSG_RESULT(yes)
1415                                 G_THREAD_LIBS="$add_thread_lib"
1416                                 break],
1417                                 [AC_MSG_RESULT(no)])
1418                 done
1419                 if test "x$G_THREAD_LIBS" = xerror; then
1420                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1421                 fi
1422                 LIBS="$glib_save_LIBS"
1423                 ;;
1424             esac
1425           fi
1426
1427           glib_save_LIBS="$LIBS"
1428           for thread_lib in "" rt rte; do
1429             if test x"$thread_lib" = x; then
1430               add_thread_lib=""
1431               IN=""
1432             else
1433               add_thread_lib="-l$thread_lib"
1434               IN=" in -l$thread_lib"
1435             fi
1436             LIBS="$glib_save_LIBS $add_thread_lib"
1437
1438             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1439             AC_TRY_RUN([#include <sched.h>
1440                         #include <errno.h>
1441                         int main() {
1442                           errno = 0;
1443                           return sched_get_priority_min(SCHED_OTHER)==-1
1444                                 && errno != 0;}],
1445                         [AC_MSG_RESULT(yes)
1446                          G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1447                          posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1448                          posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1449                          break],
1450                         [AC_MSG_RESULT(no)])
1451           done
1452           LIBS="$glib_save_LIBS"
1453           mutex_has_default=yes
1454           mutex_default_type='pthread_mutex_t'
1455           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1456           mutex_header_file='pthread.h'
1457           if test "x$have_threads" = "xposix"; then
1458             g_threads_impl="POSIX"
1459           else
1460             g_threads_impl="DCE"
1461             have_threads="posix"
1462           fi
1463           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1464           CPPFLAGS="$glib_save_CPPFLAGS"
1465           ;;
1466         solaris)
1467            mutex_has_default=yes
1468            mutex_default_type='mutex_t'
1469            mutex_default_init="DEFAULTMUTEX"
1470            mutex_header_file='thread.h'
1471            g_threads_impl="SOLARIS"
1472            ;;
1473         win32)
1474            g_threads_impl="WIN32"
1475            ;;
1476         none|no)
1477            g_threads_impl="NONE"
1478            ;;
1479         *)
1480            g_threads_impl="NONE"
1481            G_THREAD_LIBS=error
1482            ;;
1483 esac
1484
1485 if test "x$G_THREAD_LIBS" = xerror; then
1486         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1487 fi
1488
1489 case $host in
1490   *-*-beos*)
1491     G_THREAD_LIBS="-lbe -lroot -lglib "
1492     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1493     ;;
1494   *)
1495     ;;
1496 esac
1497
1498 AC_MSG_CHECKING(thread related libraries)
1499 AC_MSG_RESULT($G_THREAD_LIBS)
1500
1501 dnl check for mt safe function variants and some posix functions
1502 dnl ************************************************************
1503
1504 if test x"$have_threads" != xno; then
1505         glib_save_LIBS="$LIBS"
1506         # we are not doing the following for now, as this might require glib
1507         # to always be linked with the thread libs on some platforms.
1508         # LIBS="$LIBS $G_THREAD_LIBS"
1509         AC_CHECK_FUNCS(localtime_r)
1510         if test "$ac_cv_header_pwd_h" = "yes"; then
1511                 AC_CACHE_CHECK([for posix getpwuid_r],
1512                         ac_cv_func_posix_getpwuid_r,
1513                         [AC_TRY_RUN([#include <errno.h>
1514                                 #include <pwd.h>
1515                                 int main () { char buffer[10000];
1516                                 struct passwd pwd, *pwptr = &pwd;
1517                                 int error;
1518                                 errno = 0;
1519                                 error = getpwuid_r (0, &pwd, buffer,
1520                                         sizeof (buffer), &pwptr);
1521                                 return (error < 0 && errno == ENOSYS)
1522                                         || error == ENOSYS; }],
1523                                 [ac_cv_func_posix_getpwuid_r=yes],
1524                                 [ac_cv_func_posix_getpwuid_r=no])])
1525                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1526                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1527                                 [Have POSIX function getpwuid_r])
1528                 else
1529                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1530                                 ac_cv_func_nonposix_getpwuid_r,
1531                                 [AC_TRY_LINK([#include <pwd.h>],
1532                                         [char buffer[10000];
1533                                         struct passwd pwd;
1534                                         getpwuid_r (0, &pwd, buffer,
1535                                                         sizeof (buffer));],
1536                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1537                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1538                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1539                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1540                                         [Have non-POSIX function getpwuid_r])
1541                         fi
1542                 fi
1543         fi
1544         LIBS="$LIBS $G_THREAD_LIBS"
1545         if test x"$have_threads" = xposix; then
1546                 glib_save_CPPFLAGS="$CPPFLAGS"
1547                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1548                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1549                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1550                 # This is not AC_CHECK_FUNC to also work with function
1551                 # name mangling in header files.
1552                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1553                 AC_TRY_LINK([#include <pthread.h>],
1554                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1555                         [AC_MSG_RESULT(yes)
1556                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1557                                   [Have function pthread_attr_setstacksize])],
1558                         [AC_MSG_RESULT(no)])
1559                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1560                 if test x"$posix_priority_min" = x; then
1561                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1562                                 PX_PRIO_MIN],,[
1563                                 posix_priority_min=PX_PRIO_MIN
1564                                 posix_priority_max=PX_PRIO_MAX])
1565                 fi
1566                 if test x"$posix_priority_min" = x; then
1567                         # AIX
1568                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1569                                 PTHREAD_PRIO_MIN],,[
1570                                 posix_priority_min=PTHREAD_PRIO_MIN
1571                                 posix_priority_max=PTHREAD_PRIO_MIN])
1572                 fi
1573                 if test x"$posix_priority_min" = x; then
1574                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1575                                 PRI_OTHER_MIN],,[
1576                                 posix_priority_min=PRI_OTHER_MIN
1577                                 posix_priority_max=PRI_OTHER_MAX])
1578                 fi
1579                 if test x"$posix_priority_min" = x; then
1580                         AC_MSG_RESULT(none found)
1581                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1582                         posix_priority_min=-1
1583                         posix_priority_max=-1
1584                 else
1585                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1586                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1587                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1588                 fi
1589                 posix_yield_func=none
1590                 AC_MSG_CHECKING(for posix yield function)
1591                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1592                                                         thr_yield; do
1593                         AC_TRY_LINK([#include <pthread.h>],
1594                                 [$yield_func()],
1595                                 [posix_yield_func="$yield_func"
1596                                 break])
1597                 done
1598                 if test x"$posix_yield_func" = xnone; then
1599                         AC_MSG_RESULT(none found)
1600                         AC_MSG_WARN($POSIX_NO_YIELD)
1601                         posix_yield_func="g_usleep(1000)"
1602                 else
1603                         AC_MSG_RESULT($posix_yield_func)
1604                         posix_yield_func="$posix_yield_func()"
1605                 fi
1606                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1607                 CPPFLAGS="$glib_save_CPPFLAGS"
1608
1609                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1610                 AC_TRY_RUN([#include <pthread.h>
1611                         #include <sys/types.h>
1612                         #include <unistd.h>
1613                         pid_t other_pid = 0;
1614
1615                         void* func(void* data) {other_pid = getpid();}
1616                         main()
1617                         { pthread_t t;
1618                           void *ret;
1619                           pthread_create (&t, $defattr, func, NULL);
1620                           pthread_join (t, &ret);
1621                           exit (getpid()==other_pid ||
1622                                 $posix_priority_min != $posix_priority_max);
1623                         }],
1624                         [AC_MSG_RESULT(yes)
1625                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1626                         ],
1627                         [AC_MSG_RESULT(no)])
1628         elif test x"$have_threads" = xwin32; then
1629                 # It's a pointer to a private struct
1630                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1631         elif test x"$have_threads" = xsolaris; then
1632                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1633         fi
1634
1635         LIBS="$glib_save_LIBS"
1636
1637         # now spit out all the warnings.
1638         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1639            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1640                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1641         fi
1642         if test "$ac_cv_func_localtime_r" != "yes"; then
1643                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1644         fi
1645 fi
1646
1647 if test x"$glib_cv_sizeof_system_thread" = x; then
1648    # use a pointer as a fallback.
1649    GLIB_SIZEOF(,void *, system_thread)
1650 fi
1651
1652 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1653                    [Source file containing theread implementation])
1654 AC_SUBST(G_THREAD_CFLAGS)
1655 AC_SUBST(G_THREAD_LIBS)
1656 AC_SUBST(G_THREAD_LIBS_EXTRA)
1657
1658 dnl **********************************************
1659 dnl *** GDefaultMutex setup and initialization ***
1660 dnl **********************************************
1661 dnl
1662 dnl if mutex_has_default = yes, we also got
1663 dnl mutex_default_type, mutex_default_init and mutex_header_file
1664 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1665         glib_save_CPPFLAGS="$CPPFLAGS"
1666         glib_save_LIBS="$LIBS"
1667         LIBS="$LIBS $G_THREAD_LIBS"
1668         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1669         GLIB_SIZEOF([#include <$mutex_header_file>],
1670                     $mutex_default_type,
1671                     gmutex,
1672                     )
1673         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1674                            $mutex_default_type,
1675                            gmutex,
1676                            $glib_cv_sizeof_gmutex,
1677                            $mutex_default_init)
1678         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1679                 mutex_has_default=no
1680         fi
1681         CPPFLAGS="$glib_save_CPPFLAGS"
1682         LIBS="$glib_save_LIBS"
1683         ,
1684 )
1685
1686
1687 dnl ****************************************
1688 dnl *** GLib POLL* compatibility defines ***
1689 dnl ****************************************
1690 GLIB_SYSDEFS(
1691 [#include <sys/types.h>
1692 #include <sys/poll.h>],
1693         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1694         glibconfig-sysdefs.h,
1695         =)
1696
1697 dnl **********************
1698 dnl *** Win32 API libs ***
1699 dnl **********************
1700
1701 case $host in
1702   *-*-cygwin*)
1703         G_LIBS_EXTRA="-luser32 -lkernel32"
1704     ;;
1705   *-*-mingw*)
1706         G_LIBS_EXTRA="-lwsock32"
1707     ;;
1708   *)
1709         G_LIBS_EXTRA=""
1710     ;;
1711 esac
1712 AC_SUBST(G_LIBS_EXTRA)
1713
1714 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1715 dnl since we need it for g_iconv()
1716
1717 AC_MSG_CHECKING([for EILSEQ])
1718 AC_TRY_COMPILE([
1719 #include <errno.h>
1720 ],
1721 [
1722 int error = EILSEQ;
1723 ], have_eilseq=yes, have_eilseq=no);
1724 AC_MSG_RESULT($have_eilseq)
1725
1726 dnl ******************************************************************
1727 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1728 dnl ******************************************************************
1729
1730 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1731
1732 if test $cross_compiling = yes; then
1733   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1734   if test x$GLIB_GENMARSHAL = xno; then
1735     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1736   fi
1737 fi
1738
1739 dnl **************************
1740 dnl *** Checks for gtk-doc ***
1741 dnl **************************
1742
1743 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1744
1745 if test "x$with_html_dir" = "x" ; then
1746   HTML_DIR='${datadir}/gtk-doc/html'
1747 else
1748   HTML_DIR=$with_html_dir
1749 fi
1750
1751 AC_SUBST(HTML_DIR)
1752
1753 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1754
1755 gtk_doc_min_version=0.6
1756 if $GTKDOC ; then
1757     gtk_doc_version=`gtkdoc-mkdb --version`
1758     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1759     if perl <<EOF ; then
1760       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1761             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1762 EOF
1763       AC_MSG_RESULT(yes)
1764    else
1765       AC_MSG_RESULT(no)
1766       GTKDOC=false
1767    fi
1768 fi
1769
1770 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1771 AC_SUBST(HAVE_GTK_DOC)
1772
1773 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1774 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1775
1776 dnl Let people disable the gtk-doc stuff.
1777 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no)
1778
1779 if test x$enable_gtk_doc = xyes ; then
1780   if test x$GTKDOC = xtrue ; then
1781     enable_gtk_doc=yes
1782   else
1783     enable_gtk_doc=no
1784   fi
1785 fi
1786
1787 dnl NOTE: We need to use a separate automake conditional for this
1788 dnl       to make this work with the tarballs.
1789 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1790
1791 dnl ******************************
1792 dnl *** output the whole stuff ***
1793 dnl ******************************
1794
1795 AC_OUTPUT_COMMANDS([
1796
1797 ## Generate `glibconfig.h' in two cases
1798 ## 1. `config.status' is run either explicitly, or via configure.
1799 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1800 ##     config.h
1801 ## 2. CONFIG_OTHER is set explicitly
1802 ##
1803 ## Case 1 is difficult.  We know that `automake' sets one of
1804 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1805 ## only when AM_CONFIG_HEADER is set, however.
1806
1807 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1808   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1809   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1810 fi
1811 case "$CONFIG_OTHER" in
1812 *glibconfig.h*)
1813         echo creating glibconfig.h
1814         outfile=glibconfig.h-tmp
1815         cat > $outfile <<\_______EOF
1816 /* glibconfig.h
1817  *
1818  * This is a generated file.  Please modify 'configure.in'
1819  */
1820
1821 #ifndef __G_LIBCONFIG_H__
1822 #define __G_LIBCONFIG_H__
1823
1824 #include <glib/gmacros.h>
1825
1826 _______EOF
1827
1828         if test x$glib_limits_h = xyes; then
1829           echo '#include <limits.h>' >> $outfile
1830         fi
1831         if test x$glib_float_h = xyes; then
1832           echo '#include <float.h>' >> $outfile
1833         fi
1834         if test x$glib_values_h = xyes; then
1835           echo '#include <values.h>' >> $outfile
1836         fi
1837         if test "$glib_header_alloca_h" = "yes"; then
1838           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1839         fi
1840         if test x$glib_sys_poll_h = xyes; then
1841           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1842         fi
1843
1844         cat >> $outfile <<_______EOF
1845
1846 G_BEGIN_DECLS
1847
1848 #define G_MINFLOAT      $glib_mf
1849 #define G_MAXFLOAT      $glib_Mf
1850 #define G_MINDOUBLE     $glib_md
1851 #define G_MAXDOUBLE     $glib_Md
1852 #define G_MINSHORT      $glib_ms
1853 #define G_MAXSHORT      $glib_Ms
1854 #define G_MAXUSHORT     $glib_Mus
1855 #define G_MININT        $glib_mi
1856 #define G_MAXINT        $glib_Mi
1857 #define G_MAXUINT       $glib_Mui
1858 #define G_MINLONG       $glib_ml
1859 #define G_MAXLONG       $glib_Ml
1860 #define G_MAXULONG      $glib_Mul
1861
1862 #define G_MININT64      ((gint64)  0x8000000000000000)
1863 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1864 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1865
1866 _______EOF
1867
1868
1869         ### this should always be true in a modern C/C++ compiler
1870         cat >>$outfile <<_______EOF
1871 typedef signed char gint8;
1872 typedef unsigned char guint8;
1873 _______EOF
1874
1875
1876         if test -n "$gint16"; then
1877           cat >>$outfile <<_______EOF
1878 typedef signed $gint16 gint16;
1879 typedef unsigned $gint16 guint16;
1880 #define G_GINT16_FORMAT $gint16_format
1881 #define G_GUINT16_FORMAT $guint16_format
1882 _______EOF
1883         fi
1884
1885
1886         if test -n "$gint32"; then
1887           cat >>$outfile <<_______EOF
1888 typedef signed $gint32 gint32;
1889 typedef unsigned $gint32 guint32;
1890 #define G_GINT32_FORMAT $gint32_format
1891 #define G_GUINT32_FORMAT $guint32_format
1892 _______EOF
1893         fi
1894
1895         cat >>$outfile <<_______EOF
1896 #define G_HAVE_GINT64 1          /* deprecated, always true */
1897
1898 ${glib_extension}typedef signed $gint64 gint64;
1899 ${glib_extension}typedef unsigned $gint64 guint64;
1900
1901 #define G_GINT64_CONSTANT(val)  $gint64_constant
1902 _______EOF
1903
1904         if test x$gint64_format != x ; then
1905           cat >>$outfile <<_______EOF
1906 #define G_GINT64_FORMAT $gint64_format
1907 #define G_GUINT64_FORMAT $guint64_format
1908 _______EOF
1909         else
1910           cat >>$outfile <<_______EOF
1911 #undef G_GINT64_FORMAT
1912 #undef G_GUINT64_FORMAT
1913 _______EOF
1914         fi
1915
1916         cat >>$outfile <<_______EOF
1917
1918 #define GLIB_SIZEOF_VOID_P $glib_void_p
1919 #define GLIB_SIZEOF_LONG   $glib_long
1920 #define GLIB_SIZEOF_SIZE_T $glib_size_t
1921
1922 _______EOF
1923
1924 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
1925 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
1926
1927         if test -z "$glib_unknown_void_p"; then
1928           cat >>$outfile <<_______EOF
1929
1930 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1931 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1932
1933 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1934 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1935 _______EOF
1936         else
1937           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1938         fi
1939
1940
1941
1942         cat >>$outfile <<_______EOF
1943 $glib_atexit
1944 $glib_memmove
1945 $glib_defines
1946 $glib_os
1947
1948 $glib_vacopy
1949
1950 #ifdef  __cplusplus
1951 #define G_HAVE_INLINE   1
1952 #else   /* !__cplusplus */
1953 $glib_inline
1954 #endif  /* !__cplusplus */
1955
1956 _______EOF
1957
1958         if test x$g_have_iso_c_varargs = xyes ; then
1959                 cat >>$outfile <<_______EOF
1960 #ifndef __cplusplus
1961 # define G_HAVE_ISO_VARARGS 1
1962 #endif
1963 _______EOF
1964         fi
1965         if test x$g_have_iso_cxx_varargs = xyes ; then
1966                 cat >>$outfile <<_______EOF
1967 #ifdef __cplusplus
1968 # define G_HAVE_ISO_VARARGS 1
1969 #endif
1970 _______EOF
1971         fi
1972         if test x$g_have_gnuc_varargs = xyes ; then
1973                 cat >>$outfile <<_______EOF
1974
1975 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
1976  * is passed ISO vararg support is turned off, and there is no work
1977  * around to turn it on, so we unconditionally turn it off.
1978  */
1979 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
1980 #  undef G_HAVE_ISO_VARARGS
1981 #endif
1982
1983 #define G_HAVE_GNUC_VARARGS 1
1984 _______EOF
1985         fi
1986
1987         case x$g_stack_grows in
1988         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
1989         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
1990         esac
1991
1992
1993         echo >>$outfile
1994         if test x$g_have_eilseq = xno; then
1995                 cat >>$outfile <<_______EOF
1996 #ifndef EILSEQ
1997 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1998  * The correspondence between this and the corresponding definition
1999  * in libiconv is essential.
2000  */
2001 #  define EILSEQ ENOENT
2002 #endif
2003 _______EOF
2004
2005         fi
2006
2007         echo >>$outfile
2008         if test x$g_mutex_has_default = xyes; then
2009                 cat >>$outfile <<_______EOF
2010 $g_enable_threads_def G_THREADS_ENABLED
2011 #define G_THREADS_IMPL_$g_threads_impl_def
2012 typedef struct _GStaticMutex GStaticMutex;
2013 struct _GStaticMutex
2014 {
2015   struct _GMutex *runtime_mutex;
2016   union {
2017     char   pad[$g_mutex_sizeof];
2018     double dummy_double;
2019     void  *dummy_pointer;
2020     long   dummy_long;
2021   } static_mutex;
2022 };
2023 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2024 #define g_static_mutex_get_mutex(mutex) \
2025   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
2026    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
2027 _______EOF
2028         else
2029                 cat >>$outfile <<_______EOF
2030 $g_enable_threads_def G_THREADS_ENABLED
2031 #define G_THREADS_IMPL_$g_threads_impl_def
2032 typedef struct _GMutex* GStaticMutex;
2033 #define G_STATIC_MUTEX_INIT NULL
2034 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
2035 _______EOF
2036         fi
2037
2038         cat >>$outfile <<_______EOF
2039 /* This represents a system thread as used by the implementation. An
2040  * alien implementaion, as loaded by g_thread_init can only count on
2041  * "sizeof (gpointer)" bytes to store their info. We however need more
2042  * for some of our native implementations. */
2043 typedef union _GSystemThread GSystemThread;
2044 union _GSystemThread
2045 {
2046   char   data[$g_system_thread_sizeof];
2047   double dummy_double;
2048   void  *dummy_pointer;
2049   long   dummy_long;
2050 };
2051 _______EOF
2052
2053         echo >>$outfile
2054         g_bit_sizes="16 32 64"
2055         for bits in $g_bit_sizes; do
2056           cat >>$outfile <<_______EOF
2057 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2058 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2059 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2060 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2061 _______EOF
2062         done
2063
2064         cat >>$outfile <<_______EOF
2065 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2066 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2067 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2068 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2069 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2070 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2071 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2072 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2073 #define G_BYTE_ORDER $g_byte_order
2074
2075 _______EOF
2076
2077         if test -r glibconfig-sysdefs.h; then
2078           cat glibconfig-sysdefs.h >>$outfile
2079         fi
2080
2081         cat >>$outfile <<_______EOF
2082
2083 #define G_MODULE_SUFFIX "$g_module_suffix"
2084
2085 G_END_DECLS
2086
2087 #endif /* GLIBCONFIG_H */
2088 _______EOF
2089
2090
2091         if cmp -s $outfile glibconfig.h; then
2092           echo glibconfig.h is unchanged
2093           rm -f $outfile
2094         else
2095           mv $outfile glibconfig.h
2096         fi ;;
2097 esac
2098 ],[
2099
2100 # Note that if two cases are the same, case goes with the first one.
2101 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2102 # on variable expansion in case labels.  Look at the generated config.status
2103 # for a hint.
2104
2105 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2106   glib_header_alloca_h="$ac_cv_working_alloca_h"
2107 else
2108   glib_header_alloca_h="$ac_cv_header_alloca_h"
2109 fi
2110
2111 case xyes in
2112 x$ac_cv_header_float_h)
2113   glib_float_h=yes
2114   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2115   glib_md=DBL_MIN glib_Md=DBL_MAX
2116   ;;
2117 x$ac_cv_header_values_h)
2118   glib_values_h=yes
2119   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2120   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2121   ;;
2122 esac
2123
2124 case xyes in
2125 x$ac_cv_header_limits_h)
2126   glib_limits_h=yes
2127   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2128   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2129   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2130   ;;
2131 x$ac_cv_header_values_h)
2132   glib_values_h=yes
2133   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2134   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2135   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2136   ;;
2137 esac
2138
2139 if test x$ac_cv_header_sys_poll_h = xyes ; then
2140   glib_sys_poll_h=yes
2141 fi
2142
2143 case 2 in
2144 $ac_cv_sizeof_short)
2145   gint16=short
2146   gint16_format='"hi"'
2147   guint16_format='"hu"'
2148   ;;
2149 $ac_cv_sizeof_int)
2150   gint16=int
2151   gint16_format='"i"'
2152   guint16_format='"u"'
2153   ;;
2154 esac
2155 case 4 in
2156 $ac_cv_sizeof_short)
2157   gint32=short
2158   gint32_format='"hi"'
2159   guint32_format='"hu"'
2160   ;;
2161 $ac_cv_sizeof_int)
2162   gint32=int
2163   gint32_format='"i"'
2164   guint32_format='"u"'
2165   ;;
2166 $ac_cv_sizeof_long)
2167   gint32=long
2168   gint32_format='"li"'
2169   guint32_format='"lu"'
2170   ;;
2171 esac
2172 case 8 in
2173 $ac_cv_sizeof_int)
2174   gint64=int
2175   gint64_format='"i"'
2176   guint64_format='"u"'
2177   glib_extension=
2178   gint64_constant='(val)'
2179   ;;
2180 $ac_cv_sizeof_long)
2181   gint64=long
2182   gint64_format='"li"'
2183   guint64_format='"lu"'
2184   glib_extension=
2185   gint64_constant='(val##L)'
2186   ;;
2187 $ac_cv_sizeof_long_long)
2188   gint64='long long'
2189   if test -n "$glib_cv_long_long_format"; then
2190     gint64_format='"'$glib_cv_long_long_format'i"'
2191     guint64_format='"'$glib_cv_long_long_format'u"'
2192   fi
2193   glib_extension='G_GNUC_EXTENSION '
2194   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2195   ;;
2196 $ac_cv_sizeof___int64)
2197   gint64='__int64'
2198   if test -n "$glib_cv_long_long_format"; then
2199     gint64_format='"'$glib_cv_long_long_format'i"'
2200     guint64_format='"'$glib_cv_long_long_format'u"'
2201   fi
2202   glib_extension=
2203   gint64_constant='(val##i64)'
2204   ;;
2205 esac
2206 glib_size_t=$glib_cv_sizeof_size_t
2207 glib_size_type_define=$glib_size_type
2208 glib_void_p=$ac_cv_sizeof_long
2209 glib_long=$ac_cv_sizeof_void_p
2210
2211 gintbits=`expr $ac_cv_sizeof_int \* 8`
2212 glongbits=`expr $ac_cv_sizeof_long \* 8`
2213
2214
2215 case $ac_cv_sizeof_void_p in
2216 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2217 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2218 *)                      glib_unknown_void_p=yes ;;
2219 esac
2220
2221
2222 case xyes in
2223 x$ac_cv_func_atexit)
2224   glib_atexit="
2225 #ifdef NeXT /* @#%@! NeXTStep */
2226 # define g_ATEXIT(proc) (!atexit (proc))
2227 #else
2228 # define g_ATEXIT(proc) (atexit (proc))
2229 #endif"
2230   ;;
2231 x$ac_cv_func_on_exit)
2232   glib_atexit="
2233 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2234   ;;
2235 esac
2236
2237 case xyes in
2238 x$ac_cv_func_memmove)
2239   glib_memmove='
2240 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2241   ;;
2242 x$glib_cv_working_bcopy)
2243   glib_memmove="
2244 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2245 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2246   ;;
2247 *)
2248   glib_memmove="
2249 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2250  * so we have to roll our own copy routine. */
2251 void g_memmove (void* dest, const void * src, unsigned long len);"
2252   ;;
2253 esac
2254
2255 glib_defines="
2256 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2257 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2258 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2259 "
2260
2261 case xyes in
2262 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2263 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2264 *)                      glib_vacopy=''
2265 esac
2266
2267 if test x$glib_cv_va_val_copy = xno; then
2268   glib_vacopy="\$glib_vacopy
2269 #define G_VA_COPY_AS_ARRAY 1"
2270 fi
2271
2272 if test x$glib_cv_hasinline = xyes; then
2273     glib_inline='#define G_HAVE_INLINE 1'
2274 fi
2275 if test x$glib_cv_has__inline = xyes; then
2276     glib_inline="\$glib_inline
2277 #define G_HAVE___INLINE 1"
2278 fi
2279 if test x$glib_cv_has__inline__ = xyes; then
2280     glib_inline="\$glib_inline
2281 #define G_HAVE___INLINE__ 1"
2282 fi
2283
2284 g_have_gnuc_varargs=$g_have_gnuc_varargs
2285 g_have_iso_c_varargs=$g_have_iso_c_varargs
2286 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2287
2288 case xyes in
2289 x$ac_cv_c_bigendian)
2290   g_byte_order=G_BIG_ENDIAN
2291   g_bs_native=BE
2292   g_bs_alien=LE
2293   ;;
2294 *)
2295   g_byte_order=G_LITTLE_ENDIAN
2296   g_bs_native=LE
2297   g_bs_alien=BE
2298   ;;
2299 esac
2300
2301 g_stack_grows=$glib_cv_stack_grows
2302
2303 g_have_eilseq=$have_eilseq
2304
2305 case x$have_threads in
2306 xno)    g_enable_threads_def="#undef";;
2307 *)      g_enable_threads_def="#define";;
2308 esac
2309
2310 g_threads_impl_def=$g_threads_impl
2311
2312 g_mutex_has_default="$mutex_has_default"
2313 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2314 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2315 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2316
2317 g_module_suffix="$glib_gmodule_suffix"
2318
2319 case $host in
2320   *-*-beos*)
2321     glib_os="#define G_OS_BEOS"
2322     ;;
2323   *-*-cygwin*)
2324     glib_os="#define G_OS_UNIX
2325 #define G_PLATFORM_WIN32
2326 #define G_WITH_CYGWIN"
2327     ;;
2328   *-*-mingw*)
2329     glib_os="#define G_OS_WIN32
2330 #define G_PLATFORM_WIN32"
2331     ;;
2332   *)
2333     glib_os="#define G_OS_UNIX"
2334     ;;
2335 esac
2336 ])
2337
2338 AC_OUTPUT([
2339 glib-2.0.pc
2340 glib-2.0-uninstalled.pc
2341 gmodule-2.0.pc
2342 gmodule-2.0-uninstalled.pc
2343 gthread-2.0.pc
2344 gthread-2.0-uninstalled.pc
2345 gobject-2.0.pc
2346 gobject-2.0-uninstalled.pc
2347 glib.spec
2348 glib-zip
2349 glib-gettextize
2350 Makefile
2351 build/Makefile
2352 build/win32/Makefile
2353 build/win32/dirent/Makefile
2354 glib/Makefile
2355 glib/libcharset/Makefile
2356 gmodule/gmoduleconf.h
2357 gmodule/Makefile
2358 gobject/Makefile
2359 gobject/glib-mkenums
2360 gthread/Makefile
2361 po/Makefile.in
2362 docs/Makefile
2363 docs/reference/Makefile
2364 docs/reference/glib/Makefile
2365 docs/reference/gobject/Makefile
2366 tests/Makefile
2367 m4macros/Makefile
2368 ])