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 if test x"$have_threads" != xno; then
1288
1289   if test x"$have_threads" = xposix; then
1290     # First we test for posix, whether -pthread or -pthreads do the trick as
1291     # both CPPFLAG and LIBS.
1292     # One of them does for most gcc versions and some other platforms/compilers
1293     # too and could be considered as the canonical way to go.
1294     for flag in pthread pthreads; do
1295       glib_save_CFLAGS="$CFLAGS"
1296       CFLAGS="$CFLAGS -$flag"
1297       AC_TRY_RUN(glib_thread_test,
1298                  glib_flag_works=yes,
1299                  glib_flag_works=no,
1300                  AC_LINK_IFELSE(glib_thread_test,
1301                                 glib_flag_works=yes,
1302                                 glib_flag_works=no))
1303       CFLAGS="$glib_save_CFLAGS"
1304       if test $glib_flag_works = yes ; then
1305          G_THREAD_CFLAGS=-$flag
1306          G_THREAD_LIBS=-$flag
1307       fi
1308     done
1309   fi
1310
1311   if test x"$G_THREAD_CFLAGS" = x; then
1312
1313     # The canonical -pthread[s] does not work. Try something different.
1314
1315     case $host in
1316         *-aix*)
1317                 if test x"$GCC" = xyes; then
1318                         # GCC 3.0 and above needs -pthread.
1319                         # Should be coverd by the case above.
1320                         # GCC 2.x and below needs -mthreads
1321                         G_THREAD_CFLAGS="-mthreads"
1322                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1323                 else
1324                         # We are probably using the aix compiler. Normaly a
1325                         # program would have to be compiled with the _r variant
1326                         # of the corresponding compiler, but we as GLib cannot
1327                         # do that: but the good news is that for compiling the
1328                         # only difference is the added -D_THREAD_SAFE compile
1329                         # option. This is according to the "C for AIX User's
1330                         # Guide".
1331                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1332                 fi
1333                 ;;
1334         *-dg-dgux*)  # DG/UX
1335                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1336                 ;;
1337         *-osf*)
1338                 # So we are using dce threads. posix threads are already
1339                 # catched above.
1340                 G_THREAD_CFLAGS="-threads"
1341                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1342                 ;;
1343         *-solaris*)
1344                 if test x"$GCC" = xyes; then
1345                    # We are using solaris threads. posix threads are
1346                    # already catched above.
1347                         G_THREAD_CFLAGS="-threads"
1348                 else
1349                         G_THREAD_CFLAGS="-mt"
1350                 fi
1351                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1352                 ;;
1353         *-sysv5uw7*) # UnixWare 7
1354                 # We are not using gcc with -pthread. Catched above.
1355                 G_THREAD_CFLAGS="-Kthread"
1356                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1357                 ;;
1358         *)
1359                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1360                 ;;
1361     esac
1362
1363   fi
1364
1365     # if we are not finding the localtime_r function, then we probably are
1366     # not using the proper multithread flag
1367
1368     glib_save_CPPFLAGS="$CPPFLAGS"
1369     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1370
1371     # First we test, whether localtime_r is declared in time.h
1372     # directly. Then we test whether a macro localtime_r exists, in
1373     # which case localtime_r in the test program is replaced and thus
1374     # if we still find localtime_r in the output, it is not defined as
1375     # a macro.
1376
1377     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1378       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1379                                                            localtime_r(a,b)],
1380                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1381
1382     CPPFLAGS="$glib_save_CPPFLAGS"
1383
1384     AC_MSG_CHECKING(thread related cflags)
1385     AC_MSG_RESULT($G_THREAD_CFLAGS)
1386     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1387 fi
1388
1389 dnl determination of G_THREAD_LIBS
1390 dnl ******************************
1391
1392 mutex_has_default=no
1393 case $have_threads in
1394         posix|dce)
1395           glib_save_CPPFLAGS="$CPPFLAGS"
1396           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1397           if test x"$G_THREAD_LIBS" = x; then
1398             case $host in
1399               *-aix*)
1400                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1401                 # probably using the aix compiler.
1402                 AC_MSG_WARN($AIX_COMPILE_INFO)
1403                 ;;
1404               *)
1405                 G_THREAD_LIBS=error
1406                 glib_save_LIBS="$LIBS"
1407                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1408                         if test x"$thread_lib" = x; then
1409                                 add_thread_lib=""
1410                                 IN=""
1411                         else
1412                                 add_thread_lib="-l$thread_lib"
1413                                 IN=" in -l$thread_lib"
1414                         fi
1415                         if test x"$have_threads" = xposix; then
1416                                 defattr=0
1417                         else
1418                                 defattr=pthread_attr_default
1419                         fi
1420
1421                         LIBS="$glib_save_LIBS $add_thread_lib"
1422
1423                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1424                         AC_TRY_RUN(glib_thread_test,
1425                                 [AC_MSG_RESULT(yes)
1426                                 G_THREAD_LIBS="$add_thread_lib"
1427                                 break],
1428                                 [AC_MSG_RESULT(no)])
1429                 done
1430                 if test "x$G_THREAD_LIBS" = xerror; then
1431                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1432                 fi
1433                 LIBS="$glib_save_LIBS"
1434                 ;;
1435             esac
1436           fi
1437
1438           glib_save_LIBS="$LIBS"
1439           for thread_lib in "" rt rte; do
1440             if test x"$thread_lib" = x; then
1441               add_thread_lib=""
1442               IN=""
1443             else
1444               add_thread_lib="-l$thread_lib"
1445               IN=" in -l$thread_lib"
1446             fi
1447             LIBS="$glib_save_LIBS $add_thread_lib"
1448
1449             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1450             AC_TRY_RUN([
1451 #include <sched.h>
1452 #include <errno.h>
1453 int main() {
1454     errno = 0;
1455     return sched_get_priority_min(SCHED_OTHER)==-1
1456            && errno != 0;
1457 }                       ],
1458                         [AC_MSG_RESULT(yes)
1459                          G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1460                          posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1461                          posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1462                          break],
1463                         [AC_MSG_RESULT(no)])
1464           done
1465           LIBS="$glib_save_LIBS"
1466           mutex_has_default=yes
1467           mutex_default_type='pthread_mutex_t'
1468           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1469           mutex_header_file='pthread.h'
1470           if test "x$have_threads" = "xposix"; then
1471             g_threads_impl="POSIX"
1472           else
1473             g_threads_impl="DCE"
1474             have_threads="posix"
1475           fi
1476           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1477           CPPFLAGS="$glib_save_CPPFLAGS"
1478           ;;
1479         solaris)
1480            mutex_has_default=yes
1481            mutex_default_type='mutex_t'
1482            mutex_default_init="DEFAULTMUTEX"
1483            mutex_header_file='thread.h'
1484            g_threads_impl="SOLARIS"
1485            ;;
1486         win32)
1487            g_threads_impl="WIN32"
1488            ;;
1489         none|no)
1490            g_threads_impl="NONE"
1491            ;;
1492         *)
1493            g_threads_impl="NONE"
1494            G_THREAD_LIBS=error
1495            ;;
1496 esac
1497
1498 if test "x$G_THREAD_LIBS" = xerror; then
1499         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1500 fi
1501
1502 case $host in
1503   *-*-beos*)
1504     G_THREAD_LIBS="-lbe -lroot -lglib "
1505     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1506     ;;
1507   *)
1508     ;;
1509 esac
1510
1511 AC_MSG_CHECKING(thread related libraries)
1512 AC_MSG_RESULT($G_THREAD_LIBS)
1513
1514 dnl check for mt safe function variants and some posix functions
1515 dnl ************************************************************
1516
1517 if test x"$have_threads" != xno; then
1518         glib_save_LIBS="$LIBS"
1519         # we are not doing the following for now, as this might require glib
1520         # to always be linked with the thread libs on some platforms.
1521         # LIBS="$LIBS $G_THREAD_LIBS"
1522         AC_CHECK_FUNCS(localtime_r)
1523         if test "$ac_cv_header_pwd_h" = "yes"; then
1524                 AC_CACHE_CHECK([for posix getpwuid_r],
1525                         ac_cv_func_posix_getpwuid_r,
1526                         [AC_TRY_RUN([
1527 #include <errno.h>
1528 #include <pwd.h>
1529 int main () {
1530     char buffer[10000];
1531     struct passwd pwd, *pwptr = &pwd;
1532     int error;
1533     errno = 0;
1534     error = getpwuid_r (0, &pwd, buffer,
1535                         sizeof (buffer), &pwptr);
1536    return (error < 0 && errno == ENOSYS)
1537            || error == ENOSYS;
1538 }                               ],
1539                                 [ac_cv_func_posix_getpwuid_r=yes],
1540                                 [ac_cv_func_posix_getpwuid_r=no])])
1541                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1542                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1543                                 [Have POSIX function getpwuid_r])
1544                 else
1545                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1546                                 ac_cv_func_nonposix_getpwuid_r,
1547                                 [AC_TRY_LINK([#include <pwd.h>],
1548                                         [char buffer[10000];
1549                                         struct passwd pwd;
1550                                         getpwuid_r (0, &pwd, buffer,
1551                                                         sizeof (buffer));],
1552                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1553                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1554                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1555                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1556                                         [Have non-POSIX function getpwuid_r])
1557                         fi
1558                 fi
1559         fi
1560         LIBS="$LIBS $G_THREAD_LIBS"
1561         if test x"$have_threads" = xposix; then
1562                 glib_save_CPPFLAGS="$CPPFLAGS"
1563                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1564                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1565                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1566                 # This is not AC_CHECK_FUNC to also work with function
1567                 # name mangling in header files.
1568                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1569                 AC_TRY_LINK([#include <pthread.h>],
1570                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1571                         [AC_MSG_RESULT(yes)
1572                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1573                                   [Have function pthread_attr_setstacksize])],
1574                         [AC_MSG_RESULT(no)])
1575                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1576                 if test x"$posix_priority_min" = x; then
1577                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1578                                 PX_PRIO_MIN],,[
1579                                 posix_priority_min=PX_PRIO_MIN
1580                                 posix_priority_max=PX_PRIO_MAX])
1581                 fi
1582                 if test x"$posix_priority_min" = x; then
1583                         # AIX
1584                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1585                                 PTHREAD_PRIO_MIN],,[
1586                                 posix_priority_min=PTHREAD_PRIO_MIN
1587                                 posix_priority_max=PTHREAD_PRIO_MAX])
1588                 fi
1589                 if test x"$posix_priority_min" = x; then
1590                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1591                                 PRI_OTHER_MIN],,[
1592                                 posix_priority_min=PRI_OTHER_MIN
1593                                 posix_priority_max=PRI_OTHER_MAX])
1594                 fi
1595                 if test x"$posix_priority_min" = x; then
1596                         AC_MSG_RESULT(none found)
1597                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1598                         posix_priority_min=-1
1599                         posix_priority_max=-1
1600                 else
1601                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1602                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1603                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1604                 fi
1605                 posix_yield_func=none
1606                 AC_MSG_CHECKING(for posix yield function)
1607                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1608                                                         thr_yield; do
1609                         AC_TRY_LINK([#include <pthread.h>],
1610                                 [$yield_func()],
1611                                 [posix_yield_func="$yield_func"
1612                                 break])
1613                 done
1614                 if test x"$posix_yield_func" = xnone; then
1615                         AC_MSG_RESULT(none found)
1616                         AC_MSG_WARN($POSIX_NO_YIELD)
1617                         posix_yield_func="g_usleep(1000)"
1618                 else
1619                         AC_MSG_RESULT($posix_yield_func)
1620                         posix_yield_func="$posix_yield_func()"
1621                 fi
1622                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1623                 CPPFLAGS="$glib_save_CPPFLAGS"
1624
1625                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1626                 AC_TRY_RUN([
1627 #include <pthread.h>
1628 #include <sys/types.h>
1629 #include <unistd.h>
1630 pid_t other_pid = 0;
1631
1632 void* func(void* data) {other_pid = getpid();}
1633 main()
1634 { pthread_t t;
1635   void *ret;
1636   pthread_create (&t, 0, func, NULL);
1637   pthread_join (t, &ret);
1638   exit (getpid()==other_pid ||
1639         $posix_priority_min != $posix_priority_max);
1640 }                       ],
1641                         [AC_MSG_RESULT(yes)
1642                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1643                         ],
1644                         [AC_MSG_RESULT(no)])
1645         elif test x"$have_threads" = xwin32; then
1646                 # It's a pointer to a private struct
1647                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1648         elif test x"$have_threads" = xsolaris; then
1649                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1650         fi
1651
1652         LIBS="$glib_save_LIBS"
1653
1654         # now spit out all the warnings.
1655         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1656            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1657                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1658         fi
1659         if test "$ac_cv_func_localtime_r" != "yes"; then
1660                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1661         fi
1662 fi
1663
1664 if test x"$glib_cv_sizeof_system_thread" = x; then
1665    # use a pointer as a fallback.
1666    GLIB_SIZEOF(,void *, system_thread)
1667 fi
1668
1669 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1670                    [Source file containing theread implementation])
1671 AC_SUBST(G_THREAD_CFLAGS)
1672 AC_SUBST(G_THREAD_LIBS)
1673 AC_SUBST(G_THREAD_LIBS_EXTRA)
1674
1675 dnl **********************************************
1676 dnl *** GDefaultMutex setup and initialization ***
1677 dnl **********************************************
1678 dnl
1679 dnl if mutex_has_default = yes, we also got
1680 dnl mutex_default_type, mutex_default_init and mutex_header_file
1681 if test $mutex_has_default = yes ; then
1682         glib_save_CPPFLAGS="$CPPFLAGS"
1683         glib_save_LIBS="$LIBS"
1684         LIBS="$LIBS $G_THREAD_LIBS"
1685         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1686         GLIB_SIZEOF([#include <$mutex_header_file>],
1687                     $mutex_default_type,
1688                     gmutex)
1689         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1690                            $mutex_default_type,
1691                            gmutex,
1692                            $glib_cv_sizeof_gmutex,
1693                            $mutex_default_init)
1694         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1695                 mutex_has_default=no
1696         fi
1697         CPPFLAGS="$glib_save_CPPFLAGS"
1698         LIBS="$glib_save_LIBS"
1699 fi
1700
1701 dnl ****************************************
1702 dnl *** GLib POLL* compatibility defines ***
1703 dnl ****************************************
1704
1705 glib_poll_includes=["
1706 #include <sys/types.h>
1707 #include <sys/poll.h>
1708 "]
1709
1710 if test $ac_cv_header_sys_types_h = yes &&
1711    test $ac_cv_header_sys_poll_h = yes ; then
1712   glib_failed=false
1713   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1714   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1715   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1716   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1717   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1718   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1719   if $glib_failed ; then
1720     AC_MSG_ERROR([Could not determine values for POLL* constants])
1721   fi
1722 else
1723   glib_cv_value_POLLIN=1
1724   glib_cv_value_POLLOUT=4
1725   glib_cv_value_POLLPRI=2
1726   glib_cv_value_POLLERR=8
1727   glib_cv_value_POLLHUP=16
1728   glib_cv_value_POLLNVAL=32
1729 fi
1730
1731 dnl **********************
1732 dnl *** Win32 API libs ***
1733 dnl **********************
1734
1735 case $host in
1736   *-*-cygwin*)
1737         G_LIBS_EXTRA="-luser32 -lkernel32"
1738     ;;
1739   *-*-mingw*)
1740         G_LIBS_EXTRA="-lwsock32"
1741     ;;
1742   *)
1743         G_LIBS_EXTRA=""
1744     ;;
1745 esac
1746 AC_SUBST(G_LIBS_EXTRA)
1747
1748 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1749 dnl since we need it for g_iconv()
1750
1751 AC_MSG_CHECKING([for EILSEQ])
1752 AC_TRY_COMPILE([
1753 #include <errno.h>
1754 ],
1755 [
1756 int error = EILSEQ;
1757 ], have_eilseq=yes, have_eilseq=no);
1758 AC_MSG_RESULT($have_eilseq)
1759
1760 dnl ******************************************************************
1761 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1762 dnl ******************************************************************
1763
1764 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1765
1766 if test $cross_compiling = yes; then
1767   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1768   if test x$GLIB_GENMARSHAL = xno; then
1769     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1770   fi
1771 fi
1772
1773 dnl **************************
1774 dnl *** Checks for gtk-doc ***
1775 dnl **************************
1776
1777 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1778
1779 if test "x$with_html_dir" = "x" ; then
1780   HTML_DIR='${datadir}/gtk-doc/html'
1781 else
1782   HTML_DIR=$with_html_dir
1783 fi
1784
1785 AC_SUBST(HTML_DIR)
1786
1787 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1788
1789 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1790
1791 gtk_doc_min_version=0.10
1792 if $GTKDOC ; then
1793     gtk_doc_version=`gtkdoc-mkdb --version`
1794     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1795
1796     IFS="${IFS=         }"; gtk_save_IFS="$IFS"; IFS="."
1797     set $gtk_doc_version
1798     for min in $gtk_doc_min_version ; do
1799         cur=$1; shift
1800         if test -z $min ; then break; fi
1801         if test -z $cur ; then GTKDOC=false; break; fi
1802         if test $cur -gt $min ; then break ; fi
1803         if test $cur -lt $min ; then GTKDOC=false; break ; fi
1804     done
1805     IFS="$gtk_save_IFS"
1806
1807     if $GTKDOC ; then
1808       AC_MSG_RESULT(yes)
1809     else
1810       AC_MSG_RESULT(no)
1811     fi
1812 fi
1813
1814 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1815 AC_SUBST(HAVE_GTK_DOC)
1816
1817 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1818 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1819
1820 dnl Let people disable the gtk-doc stuff.
1821 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no)
1822
1823 if test x$enable_gtk_doc = xyes ; then
1824   if test x$GTKDOC = xtrue ; then
1825     enable_gtk_doc=yes
1826   else
1827     enable_gtk_doc=no
1828   fi
1829 fi
1830
1831 dnl NOTE: We need to use a separate automake conditional for this
1832 dnl       to make this work with the tarballs.
1833 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1834
1835 dnl ******************************
1836 dnl *** output the whole stuff ***
1837 dnl ******************************
1838
1839 AC_OUTPUT_COMMANDS([
1840
1841 ## Generate `glibconfig.h' in two cases
1842 ## 1. `config.status' is run either explicitly, or via configure.
1843 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1844 ##     config.h
1845 ## 2. CONFIG_OTHER is set explicitly
1846 ##
1847 ## Case 1 is difficult.  We know that `automake' sets one of
1848 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1849 ## only when AM_CONFIG_HEADER is set, however.
1850
1851 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1852   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1853   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1854 fi
1855 case "$CONFIG_OTHER" in
1856 *glibconfig.h*)
1857         echo creating glibconfig.h
1858         outfile=glibconfig.h-tmp
1859         cat > $outfile <<\_______EOF
1860 /* glibconfig.h
1861  *
1862  * This is a generated file.  Please modify 'configure.in'
1863  */
1864
1865 #ifndef __G_LIBCONFIG_H__
1866 #define __G_LIBCONFIG_H__
1867
1868 #include <glib/gmacros.h>
1869
1870 _______EOF
1871
1872         if test x$glib_limits_h = xyes; then
1873           echo '#include <limits.h>' >> $outfile
1874         fi
1875         if test x$glib_float_h = xyes; then
1876           echo '#include <float.h>' >> $outfile
1877         fi
1878         if test x$glib_values_h = xyes; then
1879           echo '#include <values.h>' >> $outfile
1880         fi
1881         if test "$glib_header_alloca_h" = "yes"; then
1882           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1883         fi
1884         if test x$glib_sys_poll_h = xyes; then
1885           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1886         fi
1887
1888         cat >> $outfile <<_______EOF
1889
1890 G_BEGIN_DECLS
1891
1892 #define G_MINFLOAT      $glib_mf
1893 #define G_MAXFLOAT      $glib_Mf
1894 #define G_MINDOUBLE     $glib_md
1895 #define G_MAXDOUBLE     $glib_Md
1896 #define G_MINSHORT      $glib_ms
1897 #define G_MAXSHORT      $glib_Ms
1898 #define G_MAXUSHORT     $glib_Mus
1899 #define G_MININT        $glib_mi
1900 #define G_MAXINT        $glib_Mi
1901 #define G_MAXUINT       $glib_Mui
1902 #define G_MINLONG       $glib_ml
1903 #define G_MAXLONG       $glib_Ml
1904 #define G_MAXULONG      $glib_Mul
1905
1906 #define G_MININT64      ((gint64)  0x8000000000000000)
1907 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1908 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1909
1910 _______EOF
1911
1912
1913         ### this should always be true in a modern C/C++ compiler
1914         cat >>$outfile <<_______EOF
1915 typedef signed char gint8;
1916 typedef unsigned char guint8;
1917 _______EOF
1918
1919
1920         if test -n "$gint16"; then
1921           cat >>$outfile <<_______EOF
1922 typedef signed $gint16 gint16;
1923 typedef unsigned $gint16 guint16;
1924 #define G_GINT16_FORMAT $gint16_format
1925 #define G_GUINT16_FORMAT $guint16_format
1926 _______EOF
1927         fi
1928
1929
1930         if test -n "$gint32"; then
1931           cat >>$outfile <<_______EOF
1932 typedef signed $gint32 gint32;
1933 typedef unsigned $gint32 guint32;
1934 #define G_GINT32_FORMAT $gint32_format
1935 #define G_GUINT32_FORMAT $guint32_format
1936 _______EOF
1937         fi
1938
1939         cat >>$outfile <<_______EOF
1940 #define G_HAVE_GINT64 1          /* deprecated, always true */
1941
1942 ${glib_extension}typedef signed $gint64 gint64;
1943 ${glib_extension}typedef unsigned $gint64 guint64;
1944
1945 #define G_GINT64_CONSTANT(val)  $gint64_constant
1946 _______EOF
1947
1948         if test x$gint64_format != x ; then
1949           cat >>$outfile <<_______EOF
1950 #define G_GINT64_FORMAT $gint64_format
1951 #define G_GUINT64_FORMAT $guint64_format
1952 _______EOF
1953         else
1954           cat >>$outfile <<_______EOF
1955 #undef G_GINT64_FORMAT
1956 #undef G_GUINT64_FORMAT
1957 _______EOF
1958         fi
1959
1960         cat >>$outfile <<_______EOF
1961
1962 #define GLIB_SIZEOF_VOID_P $glib_void_p
1963 #define GLIB_SIZEOF_LONG   $glib_long
1964 #define GLIB_SIZEOF_SIZE_T $glib_size_t
1965
1966 _______EOF
1967
1968 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
1969 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
1970
1971         if test -z "$glib_unknown_void_p"; then
1972           cat >>$outfile <<_______EOF
1973
1974 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1975 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1976
1977 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1978 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1979 _______EOF
1980         else
1981           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1982         fi
1983
1984
1985
1986         cat >>$outfile <<_______EOF
1987 $glib_atexit
1988 $glib_memmove
1989 $glib_defines
1990 $glib_os
1991
1992 $glib_vacopy
1993
1994 #ifdef  __cplusplus
1995 #define G_HAVE_INLINE   1
1996 #else   /* !__cplusplus */
1997 $glib_inline
1998 #endif  /* !__cplusplus */
1999
2000 _______EOF
2001
2002         if test x$g_have_iso_c_varargs = xyes ; then
2003                 cat >>$outfile <<_______EOF
2004 #ifndef __cplusplus
2005 # define G_HAVE_ISO_VARARGS 1
2006 #endif
2007 _______EOF
2008         fi
2009         if test x$g_have_iso_cxx_varargs = xyes ; then
2010                 cat >>$outfile <<_______EOF
2011 #ifdef __cplusplus
2012 # define G_HAVE_ISO_VARARGS 1
2013 #endif
2014 _______EOF
2015         fi
2016         if test x$g_have_gnuc_varargs = xyes ; then
2017                 cat >>$outfile <<_______EOF
2018
2019 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2020  * is passed ISO vararg support is turned off, and there is no work
2021  * around to turn it on, so we unconditionally turn it off.
2022  */
2023 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2024 #  undef G_HAVE_ISO_VARARGS
2025 #endif
2026
2027 #define G_HAVE_GNUC_VARARGS 1
2028 _______EOF
2029         fi
2030
2031         case x$g_stack_grows in
2032         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2033         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2034         esac
2035
2036
2037         echo >>$outfile
2038         if test x$g_have_eilseq = xno; then
2039                 cat >>$outfile <<_______EOF
2040 #ifndef EILSEQ
2041 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2042  * The correspondence between this and the corresponding definition
2043  * in libiconv is essential.
2044  */
2045 #  define EILSEQ ENOENT
2046 #endif
2047 _______EOF
2048
2049         fi
2050
2051         echo >>$outfile
2052         if test x$g_mutex_has_default = xyes; then
2053                 cat >>$outfile <<_______EOF
2054 $g_enable_threads_def G_THREADS_ENABLED
2055 #define G_THREADS_IMPL_$g_threads_impl_def
2056 typedef struct _GStaticMutex GStaticMutex;
2057 struct _GStaticMutex
2058 {
2059   struct _GMutex *runtime_mutex;
2060   union {
2061     char   pad[$g_mutex_sizeof];
2062     double dummy_double;
2063     void  *dummy_pointer;
2064     long   dummy_long;
2065   } static_mutex;
2066 };
2067 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2068 #define g_static_mutex_get_mutex(mutex) \
2069   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
2070    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
2071 _______EOF
2072         else
2073                 cat >>$outfile <<_______EOF
2074 $g_enable_threads_def G_THREADS_ENABLED
2075 #define G_THREADS_IMPL_$g_threads_impl_def
2076 typedef struct _GMutex* GStaticMutex;
2077 #define G_STATIC_MUTEX_INIT NULL
2078 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
2079 _______EOF
2080         fi
2081
2082         cat >>$outfile <<_______EOF
2083 /* This represents a system thread as used by the implementation. An
2084  * alien implementaion, as loaded by g_thread_init can only count on
2085  * "sizeof (gpointer)" bytes to store their info. We however need more
2086  * for some of our native implementations. */
2087 typedef union _GSystemThread GSystemThread;
2088 union _GSystemThread
2089 {
2090   char   data[$g_system_thread_sizeof];
2091   double dummy_double;
2092   void  *dummy_pointer;
2093   long   dummy_long;
2094 };
2095 _______EOF
2096
2097         echo >>$outfile
2098         g_bit_sizes="16 32 64"
2099         for bits in $g_bit_sizes; do
2100           cat >>$outfile <<_______EOF
2101 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2102 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2103 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2104 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2105 _______EOF
2106         done
2107
2108         cat >>$outfile <<_______EOF
2109 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2110 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2111 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2112 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2113 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2114 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2115 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2116 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2117 #define G_BYTE_ORDER $g_byte_order
2118
2119 #define GLIB_SYSDEF_POLLIN =$g_pollin
2120 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2121 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2122 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2123 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2124 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2125
2126 #define G_MODULE_SUFFIX "$g_module_suffix"
2127
2128 G_END_DECLS
2129
2130 #endif /* GLIBCONFIG_H */
2131 _______EOF
2132
2133
2134         if cmp -s $outfile glibconfig.h; then
2135           echo glibconfig.h is unchanged
2136           rm -f $outfile
2137         else
2138           mv $outfile glibconfig.h
2139         fi ;;
2140 esac
2141 ],[
2142
2143 # Note that if two cases are the same, case goes with the first one.
2144 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2145 # on variable expansion in case labels.  Look at the generated config.status
2146 # for a hint.
2147
2148 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2149   glib_header_alloca_h="$ac_cv_working_alloca_h"
2150 else
2151   glib_header_alloca_h="$ac_cv_header_alloca_h"
2152 fi
2153
2154 case xyes in
2155 x$ac_cv_header_float_h)
2156   glib_float_h=yes
2157   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2158   glib_md=DBL_MIN glib_Md=DBL_MAX
2159   ;;
2160 x$ac_cv_header_values_h)
2161   glib_values_h=yes
2162   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2163   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2164   ;;
2165 esac
2166
2167 case xyes in
2168 x$ac_cv_header_limits_h)
2169   glib_limits_h=yes
2170   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2171   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2172   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2173   ;;
2174 x$ac_cv_header_values_h)
2175   glib_values_h=yes
2176   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2177   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2178   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2179   ;;
2180 esac
2181
2182 if test x$ac_cv_header_sys_poll_h = xyes ; then
2183   glib_sys_poll_h=yes
2184 fi
2185
2186 case 2 in
2187 $ac_cv_sizeof_short)
2188   gint16=short
2189   gint16_format='"hi"'
2190   guint16_format='"hu"'
2191   ;;
2192 $ac_cv_sizeof_int)
2193   gint16=int
2194   gint16_format='"i"'
2195   guint16_format='"u"'
2196   ;;
2197 esac
2198 case 4 in
2199 $ac_cv_sizeof_short)
2200   gint32=short
2201   gint32_format='"hi"'
2202   guint32_format='"hu"'
2203   ;;
2204 $ac_cv_sizeof_int)
2205   gint32=int
2206   gint32_format='"i"'
2207   guint32_format='"u"'
2208   ;;
2209 $ac_cv_sizeof_long)
2210   gint32=long
2211   gint32_format='"li"'
2212   guint32_format='"lu"'
2213   ;;
2214 esac
2215 case 8 in
2216 $ac_cv_sizeof_int)
2217   gint64=int
2218   gint64_format='"i"'
2219   guint64_format='"u"'
2220   glib_extension=
2221   gint64_constant='(val)'
2222   ;;
2223 $ac_cv_sizeof_long)
2224   gint64=long
2225   gint64_format='"li"'
2226   guint64_format='"lu"'
2227   glib_extension=
2228   gint64_constant='(val##L)'
2229   ;;
2230 $ac_cv_sizeof_long_long)
2231   gint64='long long'
2232   if test -n "$glib_cv_long_long_format"; then
2233     gint64_format='"'$glib_cv_long_long_format'i"'
2234     guint64_format='"'$glib_cv_long_long_format'u"'
2235   fi
2236   glib_extension='G_GNUC_EXTENSION '
2237   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2238   ;;
2239 $ac_cv_sizeof___int64)
2240   gint64='__int64'
2241   if test -n "$glib_cv_long_long_format"; then
2242     gint64_format='"'$glib_cv_long_long_format'i"'
2243     guint64_format='"'$glib_cv_long_long_format'u"'
2244   fi
2245   glib_extension=
2246   gint64_constant='(val##i64)'
2247   ;;
2248 esac
2249 glib_size_t=$ac_cv_sizeof_size_t
2250 glib_size_type_define=$glib_size_type
2251 glib_void_p=$ac_cv_sizeof_long
2252 glib_long=$ac_cv_sizeof_void_p
2253
2254 gintbits=`expr $ac_cv_sizeof_int \* 8`
2255 glongbits=`expr $ac_cv_sizeof_long \* 8`
2256
2257
2258 case $ac_cv_sizeof_void_p in
2259 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2260 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2261 *)                      glib_unknown_void_p=yes ;;
2262 esac
2263
2264
2265 case xyes in
2266 x$ac_cv_func_atexit)
2267   glib_atexit="
2268 #ifdef NeXT /* @#%@! NeXTStep */
2269 # define g_ATEXIT(proc) (!atexit (proc))
2270 #else
2271 # define g_ATEXIT(proc) (atexit (proc))
2272 #endif"
2273   ;;
2274 x$ac_cv_func_on_exit)
2275   glib_atexit="
2276 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2277   ;;
2278 esac
2279
2280 case xyes in
2281 x$ac_cv_func_memmove)
2282   glib_memmove='
2283 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2284   ;;
2285 x$glib_cv_working_bcopy)
2286   glib_memmove="
2287 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2288 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2289   ;;
2290 *)
2291   glib_memmove="
2292 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2293  * so we have to roll our own copy routine. */
2294 void g_memmove (void* dest, const void * src, unsigned long len);"
2295   ;;
2296 esac
2297
2298 glib_defines="
2299 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2300 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2301 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2302 "
2303
2304 case xyes in
2305 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2306 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2307 *)                      glib_vacopy=''
2308 esac
2309
2310 if test x$glib_cv_va_val_copy = xno; then
2311   glib_vacopy="\$glib_vacopy
2312 #define G_VA_COPY_AS_ARRAY 1"
2313 fi
2314
2315 if test x$glib_cv_hasinline = xyes; then
2316     glib_inline='#define G_HAVE_INLINE 1'
2317 fi
2318 if test x$glib_cv_has__inline = xyes; then
2319     glib_inline="\$glib_inline
2320 #define G_HAVE___INLINE 1"
2321 fi
2322 if test x$glib_cv_has__inline__ = xyes; then
2323     glib_inline="\$glib_inline
2324 #define G_HAVE___INLINE__ 1"
2325 fi
2326
2327 g_have_gnuc_varargs=$g_have_gnuc_varargs
2328 g_have_iso_c_varargs=$g_have_iso_c_varargs
2329 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2330
2331 case xyes in
2332 x$ac_cv_c_bigendian)
2333   g_byte_order=G_BIG_ENDIAN
2334   g_bs_native=BE
2335   g_bs_alien=LE
2336   ;;
2337 *)
2338   g_byte_order=G_LITTLE_ENDIAN
2339   g_bs_native=LE
2340   g_bs_alien=BE
2341   ;;
2342 esac
2343
2344 g_pollin=$glib_cv_value_POLLIN
2345 g_pollout=$glib_cv_value_POLLOUT
2346 g_pollpri=$glib_cv_value_POLLPRI
2347 g_pollhup=$glib_cv_value_POLLHUP
2348 g_pollerr=$glib_cv_value_POLLERR
2349 g_pollnval=$glib_cv_value_POLLNVAL
2350
2351 g_stack_grows=$glib_cv_stack_grows
2352
2353 g_have_eilseq=$have_eilseq
2354
2355 case x$have_threads in
2356 xno)    g_enable_threads_def="#undef";;
2357 *)      g_enable_threads_def="#define";;
2358 esac
2359
2360 g_threads_impl_def=$g_threads_impl
2361
2362 g_mutex_has_default="$mutex_has_default"
2363 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2364 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2365 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2366
2367 g_module_suffix="$glib_gmodule_suffix"
2368
2369 case $host in
2370   *-*-beos*)
2371     glib_os="#define G_OS_BEOS"
2372     ;;
2373   *-*-cygwin*)
2374     glib_os="#define G_OS_UNIX
2375 #define G_PLATFORM_WIN32
2376 #define G_WITH_CYGWIN"
2377     ;;
2378   *-*-mingw*)
2379     glib_os="#define G_OS_WIN32
2380 #define G_PLATFORM_WIN32"
2381     ;;
2382   *)
2383     glib_os="#define G_OS_UNIX"
2384     ;;
2385 esac
2386 ])
2387
2388 AC_OUTPUT([
2389 glib-2.0.pc
2390 glib-2.0-uninstalled.pc
2391 gmodule-2.0.pc
2392 gmodule-2.0-uninstalled.pc
2393 gthread-2.0.pc
2394 gthread-2.0-uninstalled.pc
2395 gobject-2.0.pc
2396 gobject-2.0-uninstalled.pc
2397 glib.spec
2398 glib-zip
2399 glib-gettextize
2400 Makefile
2401 build/Makefile
2402 build/win32/Makefile
2403 build/win32/dirent/Makefile
2404 glib/Makefile
2405 glib/libcharset/Makefile
2406 glib/trio/Makefile
2407 gmodule/gmoduleconf.h
2408 gmodule/Makefile
2409 gobject/Makefile
2410 gobject/glib-mkenums
2411 gthread/Makefile
2412 po/Makefile.in
2413 docs/Makefile
2414 docs/reference/Makefile
2415 docs/reference/glib/Makefile
2416 docs/reference/glib/version.xml
2417 docs/reference/gobject/Makefile
2418 docs/reference/gobject/version.xml
2419 tests/Makefile
2420 m4macros/Makefile
2421 ],[
2422 chmod 0755 glib-zip
2423 chmod 0755 glib-gettextize
2424 chmod 0755 gobject/glib-mkenums
2425 ])