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