configure.in

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