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