configure.in

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