configure.in

   1 # Process this file with autoconf to produce a configure script.
   2 # require autoconf 2.54
   3 AC_PREREQ(2.54)
   4
   5 dnl ***********************************
   6 dnl *** include special GLib macros ***
   7 dnl ***********************************
   8
   9 m4_define(glib_configure_in)
  10
  11 #
  12 # The following version number definitions apply to GLib, GModule, GObject
  13 # and GThread as a whole, so if changes occoured in any of them, they are all
  14 # treated with the same interface and binary age.
  15 #
  16 # Making releases:
  17 #   glib_micro_version += 1;
  18 #   glib_interface_age += 1;
  19 #   glib_binary_age += 1;
  20 # if any functions have been added, set glib_interface_age to 0.
  21 # if backwards compatibility has been broken,
  22 # set glib_binary_age _and_ glib_interface_age to 0.
  23 #
  24 m4_define([glib_major_version], [2])
  25 m4_define([glib_minor_version], [15])
  26 m4_define([glib_micro_version], [0])
  27 m4_define([glib_interface_age], [0])
  28 m4_define([glib_binary_age],
  29           [m4_eval(100 * glib_minor_version + glib_micro_version)])
  30 m4_define([glib_version],
  31           [glib_major_version.glib_minor_version.glib_micro_version])
  32
  33 # libtool version related macros
  34 m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
  35 m4_define([glib_lt_current],
  36           [m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
  37 m4_define([glib_lt_revision], [glib_interface_age])
  38 m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
  39 m4_define([glib_lt_current_minus_age],
  40           [m4_eval(glib_lt_current - glib_lt_age)])
  41
  42 # if the minor version number is odd, then we want debugging.  Otherwise
  43 # we only want minimal debugging support.
  44 m4_define([glib_debug_default],
  45           [m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
  46
  47
  48 AC_INIT(glib, [glib_version],
  49         [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
  50
  51 AC_CONFIG_SRCDIR([glib/glib.h])
  52
  53 # Save this value here, since automake will set cflags later
  54 cflags_set=${CFLAGS+set}
  55
  56 AM_INIT_AUTOMAKE([no-define])
  57
  58 # Specify a configuration file
  59 AM_CONFIG_HEADER([config.h])
  60
  61
  62 GLIB_MAJOR_VERSION=glib_major_version
  63 GLIB_MINOR_VERSION=glib_minor_version
  64 GLIB_MICRO_VERSION=glib_micro_version
  65 GLIB_INTERFACE_AGE=glib_interface_age
  66 GLIB_BINARY_AGE=glib_binary_age
  67 GLIB_VERSION=glib_version
  68
  69 AC_SUBST(GLIB_MAJOR_VERSION)
  70 AC_SUBST(GLIB_MINOR_VERSION)
  71 AC_SUBST(GLIB_MICRO_VERSION)
  72 AC_SUBST(GLIB_VERSION)
  73 AC_SUBST(GLIB_INTERFACE_AGE)
  74 AC_SUBST(GLIB_BINARY_AGE)
  75
  76 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
  77           [Define to the GLIB major version])
  78 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
  79           [Define to the GLIB minor version])
  80 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
  81           [Define to the GLIB micro version])
  82 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
  83           [Define to the GLIB interface age])
  84 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
  85           [Define to the GLIB binary age])
  86
  87 # libtool versioning
  88 LT_RELEASE=glib_lt_release
  89 LT_CURRENT=glib_lt_current
  90 LT_REVISION=glib_lt_revision
  91 LT_AGE=glib_lt_age
  92 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
  93 AC_SUBST(LT_RELEASE)
  94 AC_SUBST(LT_CURRENT)
  95 AC_SUBST(LT_REVISION)
  96 AC_SUBST(LT_AGE)
  97 AC_SUBST(LT_CURRENT_MINUS_AGE)
  98
  99 dnl Initialize maintainer mode
 100 AM_MAINTAINER_MODE
 101
 102 AC_CANONICAL_HOST
 103
 104 AC_MSG_CHECKING([for the BeOS])
 105 case $host in
 106   *-*-beos*)
 107     glib_native_beos="yes"
 108     ;;
 109   *)
 110     glib_native_beos="no"
 111     ;;
 112 esac
 113 AC_MSG_RESULT([$glib_native_beos])
 114
 115 dnl
 116
 117 AC_MSG_CHECKING([for Win32])
 118 case "$host" in
 119   *-*-mingw*)
 120     glib_native_win32=yes
 121     GLIB_DEF=glib.def
 122     GMODULE_DEF=gmodule.def
 123     GOBJECT_DEF=gobject.def
 124     GTHREAD_DEF=gthread.def
 125     TESTGMODULE_EXP=testgmodule.exp
 126     glib_pid_type='void *'
 127     ;;
 128   *)
 129     glib_native_win32=no
 130     GLIB_DEF=
 131     GMODULE_DEF=
 132     GOBJECT_DEF=
 133     GTHREAD_DEF=
 134     TESTGMODULE_EXP=
 135     glib_pid_type=int
 136     ;;
 137 esac
 138 case $host in
 139   *-*-linux*)
 140     glib_os_linux=yes
 141     ;;
 142 esac
 143
 144 AC_MSG_RESULT([$glib_native_win32])
 145
 146 glib_have_carbon=no
 147 AC_MSG_CHECKING([for Mac OS X Carbon support])
 148 AC_TRY_CPP([
 149 #include <Carbon/Carbon.h>
 150 #include <CoreServices/CoreServices.h>
 151 ], glib_have_carbon=yes)
 152
 153 AC_MSG_RESULT([$glib_have_carbon])
 154
 155 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
 156 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
 157 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
 158 AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
 159 AC_SUBST(GLIB_DEF)
 160 AC_SUBST(GMODULE_DEF)
 161 AC_SUBST(GOBJECT_DEF)
 162 AC_SUBST(GTHREAD_DEF)
 163 AC_SUBST(TESTGMODULE_EXP)
 164
 165 if test "$glib_native_win32" = "yes"; then
 166   AC_CHECK_TOOL(WINDRES, windres, no)
 167   if test "$WINDRES" = no; then
 168     AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
 169   fi
 170   AC_CHECK_TOOL(NM, nm, no)
 171   if test "$NM" = no; then
 172     AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
 173   fi
 174   AC_CHECK_TOOL(RANLIB, ranlib, :)
 175   AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
 176 fi
 177 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
 178
 179 if test "$glib_native_win32" != yes; then
 180     # libtool option to control which symbols are exported
 181     # right now, symbols starting with _ are not exported
 182     LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
 183 else
 184     # We currently use .def files on Windows
 185     LIBTOOL_EXPORT_OPTIONS=
 186 fi
 187 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
 188
 189 if test "x$glib_have_carbon" = "xyes"; then
 190   AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
 191   LDFLAGS="$LDFLAGS -framework Carbon"
 192 fi
 193
 194
 195 dnl declare --enable-* args and collect ac_help strings
 196 AC_ARG_ENABLE(debug,
 197               AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
 198                              [turn on debugging @<:@default=glib_debug_default@:>@]),,
 199               enable_debug=glib_debug_default)
 200
 201 AC_ARG_ENABLE(gc_friendly,
 202               [AC_HELP_STRING([--enable-gc-friendly],
 203                               [turn on garbage collector friendliness [default=no]])],,
 204               [enable_gc_friendly=no])
 205 AC_ARG_ENABLE(mem_pools,
 206               [AC_HELP_STRING([--disable-mem-pools],
 207                               [disable all glib memory pools])],,
 208               [disable_mem_pools=no])
 209 AC_ARG_ENABLE(threads,
 210               [AC_HELP_STRING([--enable-threads],
 211                               [turn on basic thread support [default=yes]
 212 ([=no] will override --with-threads)])],,
 213               [enable_threads=yes])
 214 AC_ARG_ENABLE(rebuilds,
 215               [AC_HELP_STRING([--disable-rebuilds],
 216                               [disable all source autogeneration rules])],,
 217               [enable_rebuilds=yes])
 218 AC_ARG_ENABLE(visibility,
 219               [AC_HELP_STRING([--disable-visibility],
 220                               [don't use ELF visibility attributes])],,
 221               [enable_visibility=yes])
 222
 223 if test "x$enable_threads" != "xyes"; then
 224   enable_threads=no
 225 fi
 226
 227 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
 228 if test "x$enable_gc_friendly" = "xyes"; then
 229   AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
 230   AC_MSG_RESULT([yes])
 231 else
 232   AC_MSG_RESULT([no])
 233 fi
 234
 235 AC_MSG_CHECKING([whether to disable memory pools])
 236 if test "x$disable_mem_pools" = "xno"; then
 237   AC_MSG_RESULT([no])
 238 else
 239   AC_DEFINE(DISABLE_MEM_POOLS, [1], [Whether to disable memory pools])
 240   AC_SUBST(DISABLE_MEM_POOLS)
 241   AC_MSG_RESULT([yes])
 242 fi
 243
 244 if test "$glib_native_win32" = "yes"; then
 245   if test x$enable_static = xyes -o x$enable_static = x; then
 246     AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
 247     enable_static=no
 248   fi
 249   if test x$enable_shared = xno; then
 250     AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
 251   fi
 252   enable_shared=yes
 253 fi
 254
 255 dnl Checks for programs.
 256 AC_PROG_CC
 257
 258 dnl Check for a working C++ compiler, but do not bail out, if none is found.
 259 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
 260 AC_LANG_SAVE
 261 AC_LANG_CPLUSPLUS
 262 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
 263 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
 264 AC_LANG_RESTORE
 265
 266 AM_PROG_CC_STDC
 267 AM_PROG_CC_C_O
 268 AC_PROG_INSTALL
 269
 270 AC_SYS_LARGEFILE
 271
 272 #
 273 # Find pkg-config
 274 #
 275 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
 276 if test x$PKG_CONFIG = xno ; then
 277   AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
 278 fi
 279
 280 if $PKG_CONFIG --atleast-pkgconfig-version 0.16 ; then
 281   :
 282 else
 283   AC_MSG_ERROR([*** pkg-config too old; version 0.16 or better required.])
 284 fi
 285
 286 if test "x$enable_debug" = "xyes"; then
 287   if test x$cflags_set != xset ; then
 288       case " $CFLAGS " in
 289       *[[\ \    ]]-g[[\ \       ]]*) ;;
 290       *) CFLAGS="$CFLAGS -g" ;;
 291       esac
 292   fi
 293
 294   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 295 else
 296   GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
 297
 298   if test "x$enable_debug" = "xno"; then
 299     GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 300   fi
 301 fi
 302
 303 if test "x$enable_visibility" = "xno"; then
 304   GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
 305 fi
 306
 307 # Ensure MSVC-compatible struct packing convention is used when
 308 # compiling for Win32 with gcc.
 309 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
 310 # gcc2 uses "-fnative-struct".
 311 if test x"$glib_native_win32" = xyes; then
 312   if test x"$GCC" = xyes; then
 313     msnative_struct=''
 314     AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
 315     if test -z "$ac_cv_prog_CC"; then
 316       our_gcc="$CC"
 317     else
 318       our_gcc="$ac_cv_prog_CC"
 319     fi
 320     case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
 321       2.)
 322         if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
 323           msnative_struct='-fnative-struct'
 324         fi
 325         ;;
 326       *)
 327         if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
 328           msnative_struct='-mms-bitfields'
 329         fi
 330         ;;
 331     esac
 332     if test x"$msnative_struct" = x ; then
 333       AC_MSG_RESULT([no way])
 334       AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
 335     else
 336       CFLAGS="$CFLAGS $msnative_struct"
 337       AC_MSG_RESULT([${msnative_struct}])
 338     fi
 339   fi
 340 fi
 341
 342 AC_EXEEXT
 343
 344 # define a MAINT-like variable REBUILD which is set if Perl
 345 # and awk are found, so autogenerated sources can be rebuilt
 346 AC_PROG_AWK
 347 AC_CHECK_PROGS(PERL, [perl5 perl])
 348 # We would like indent, but don't require it.
 349 AC_CHECK_PROG(INDENT, indent, indent)
 350 REBUILD=\#
 351 if test "x$enable_rebuilds" = "xyes" && \
 352      test -n "$PERL" && \
 353      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 354      test -n "$AWK" ; then
 355   REBUILD=
 356 fi
 357 AC_SUBST(REBUILD)
 358
 359 # Need full path to Perl for glib-mkenums
 360 #
 361 if test "x$PERL" != x ; then
 362   AC_PATH_PROG(PERL_PATH, [$PERL])
 363 fi
 364 if test "x$PERL_PATH" = x ; then
 365   PERL_PATH="/usr/bin/env perl"
 366 fi
 367 AC_SUBST(PERL_PATH)
 368
 369 # Need suitable python path for greport
 370 AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
 371
 372
 373 dnl ***********************
 374 dnl *** Tests for iconv ***
 375 dnl ***********************
 376 dnl
 377 dnl We do this before the gettext checks, to avoid distortion
 378
 379 AC_ARG_WITH(libiconv,
 380             [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
 381                             [use the libiconv library])],,
 382             [with_libiconv=maybe])
 383
 384 found_iconv=no
 385 case $with_libiconv in
 386   maybe)
 387     # Check in the C library first
 388     AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
 389     # Check if we have GNU libiconv
 390     if test $found_iconv = "no"; then
 391       AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
 392     fi
 393     # Check if we have a iconv in -liconv, possibly from vendor
 394     if test $found_iconv = "no"; then
 395       AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
 396     fi
 397     ;;
 398   no)
 399     AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
 400     ;;
 401   gnu|yes)
 402     AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
 403     ;;
 404   native)
 405     AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
 406     ;;
 407 esac
 408
 409 if test "x$found_iconv" = "xno" ; then
 410    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
 411 fi
 412
 413 jm_GLIBC21
 414 AC_ARG_ENABLE(iconv-cache,
 415               [AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
 416                               [cache iconv descriptors [default=auto]])],,
 417               [enable_iconv_cache=auto])
 418
 419 AC_MSG_CHECKING([Whether to cache iconv descriptors])
 420 case $enable_iconv_cache in
 421   auto)
 422     if test $ac_cv_gnu_library_2_1 = yes; then
 423       enable_iconv_cache=no
 424     else
 425       enable_iconv_cache=yes
 426     fi
 427   ;;
 428   yes|no)
 429   ;;
 430   *) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
 431   ;;
 432 esac
 433
 434 if test $enable_iconv_cache = yes; then
 435    AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
 436 fi
 437
 438 AC_MSG_RESULT($enable_iconv_cache)
 439
 440
 441 dnl
 442 dnl gettext support
 443 dnl
 444
 445 ALL_LINGUAS="am ar as az be be@latin bg bn bn_IN bs ca cs cy da de dz el en_CA en_GB eo es et eu fa fi fr ga gl gu he hi hr hu hy id is it ja ka kn ko ku lt lv mg mk ml mn ms nb ne nl nn oc or pa pl pt pt_BR ro ru rw sk sl sq sr sr@Latn sr@ije sv ta te th tl tr tt uk vi wa xh yi zh_CN zh_HK zh_TW"
 446 GLIB_GNU_GETTEXT
 447
 448 if test "$gt_cv_have_gettext" != "yes" ; then
 449   AC_MSG_ERROR([
 450 *** You must have either have gettext support in your C library, or use the
 451 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
 452 ])
 453 fi
 454
 455 LIBS="$INTLLIBS $LIBS"
 456
 457 GETTEXT_PACKAGE=glib20
 458 AC_SUBST(GETTEXT_PACKAGE)
 459 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
 460   [Define the gettext package to be used])
 461
 462 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
 463
 464 dnl
 465 dnl Now we are done with gettext checks, figure out ICONV_LIBS
 466 dnl
 467
 468 if test x$with_libiconv != xno ; then
 469   case " $INTLLIBS " in
 470   *[[\ \        ]]-liconv[[\ \  ]]*) ;;
 471   *) ICONV_LIBS="-liconv" ;;
 472   esac
 473 fi
 474 AC_SUBST(ICONV_LIBS)
 475
 476 case $with_libiconv in
 477   gnu)
 478     AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
 479     ;;
 480   native)
 481     AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
 482     ;;
 483 esac
 484
 485 dnl Initialize libtool
 486 AM_DISABLE_STATIC
 487 AC_LIBTOOL_WIN32_DLL
 488 AM_PROG_LIBTOOL
 489
 490 if test "x$GCC" = "xyes"; then
 491   case " $CFLAGS " in
 492   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 493   *) CFLAGS="$CFLAGS -Wall" ;;
 494   esac
 495 fi
 496
 497 dnl
 498 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 499 dnl
 500 if test $cross_compiling != yes ; then
 501     AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 502     glib_save_LIBS=$LIBS
 503     LIBS="$LIBS -lm"
 504     AC_TRY_RUN([#include <math.h>
 505                  int main (void) { return (log(1) != log(1.)); }],
 506          AC_MSG_RESULT(none needed),
 507          glib_save_CFLAGS=$CFLAGS
 508          CFLAGS="$CFLAGS -std1"
 509          AC_TRY_RUN([#include <math.h>
 510                      int main (void) { return (log(1) != log(1.)); }],
 511              AC_MSG_RESULT(-std1),
 512              AC_MSG_RESULT()
 513              CFLAGS=$glib_save_CFLAGS
 514              AC_MSG_WARN(
 515                     [No ANSI prototypes found in library. (-std1 didn't work.)])
 516          )
 517     )
 518     LIBS=$glib_save_LIBS
 519 fi
 520
 521 dnl NeXTStep cc seems to need this
 522 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 523 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 524   AC_MSG_RESULT(none needed),
 525   glib_save_CFLAGS=$CFLAGS
 526   CFLAGS="$CFLAGS -posix"
 527   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 528     AC_MSG_RESULT(-posix),
 529     AC_MSG_RESULT()
 530     CFLAGS=$glib_save_CFLAGS
 531     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 532
 533 # Checks for header files.
 534 AC_HEADER_STDC
 535
 536 # Checks for library functions.
 537 AC_FUNC_VPRINTF
 538 AC_FUNC_MMAP
 539 AC_FUNC_ALLOCA
 540 AC_CHECK_FUNCS(posix_memalign)
 541 AC_CHECK_FUNCS(memalign)
 542 AC_CHECK_FUNCS(valloc)
 543
 544 AC_CHECK_FUNCS(atexit on_exit)
 545
 546 AC_CHECK_FUNCS(timegm)
 547
 548 AC_CHECK_SIZEOF(char)
 549 AC_CHECK_SIZEOF(short)
 550 AC_CHECK_SIZEOF(long)
 551 AC_CHECK_SIZEOF(int)
 552 AC_CHECK_SIZEOF(void *)
 553 AC_CHECK_SIZEOF(long long)
 554 AC_CHECK_SIZEOF(__int64)
 555
 556 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
 557   :
 558 else
 559   AC_MSG_ERROR([
 560 *** GLib requires a 64 bit type. You might want to consider
 561 *** using the GNU C compiler.
 562 ])
 563 fi
 564
 565 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
 566         # long long is a 64 bit integer.
 567         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 568         AC_CACHE_VAL(glib_cv_long_long_format,[
 569                 for format in ll q I64; do
 570                   AC_TRY_RUN([#include <stdio.h>
 571                         int main()
 572                         {
 573                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 574                           char buffer[1000];
 575                           sprintf (buffer, "%${format}u", a);
 576                           sscanf (buffer, "%${format}u", &b);
 577                           exit (b!=a);
 578                         }
 579                         ],
 580                         [glib_cv_long_long_format=${format}
 581                         break],
 582                         [],[:])
 583                 done])
 584         if test -n "$glib_cv_long_long_format"; then
 585           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 586           AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
 587           if test x"$glib_cv_long_long_format" = xI64; then
 588             AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
 589           fi
 590         else
 591           AC_MSG_RESULT(none)
 592         fi
 593 elif test x$ac_cv_sizeof___int64 = x8; then
 594         # __int64 is a 64 bit integer.
 595         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 596         # We know this is MSVCRT.DLL, and what the formats are
 597         glib_cv_long_long_format=I64
 598         AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 599         AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
 600         AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
 601 fi
 602
 603 dnl long doubles were not used, and a portability problem
 604 dnl AC_C_LONG_DOUBLE
 605 AC_C_CONST
 606
 607 dnl ok, here we try to check whether the systems prototypes for
 608 dnl malloc and friends actually match the prototypes provided
 609 dnl by gmem.h (keep in sync). i currently only know how to check
 610 dnl this reliably with gcc (-Werror), improvements for other
 611 dnl compilers are apprechiated.
 612 SANE_MALLOC_PROTOS=no
 613 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 614 glib_save_CFLAGS=$CFLAGS
 615 if test "x$GCC" = "xyes"; then
 616   CFLAGS="$CFLAGS -Werror"
 617   AC_TRY_COMPILE([#include <stdlib.h>], [
 618     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 619     void* (*my_malloc_p)  (size_t)         = malloc;
 620     void  (*my_free_p)    (void*)          = free;
 621     void* (*my_realloc_p) (void*, size_t)  = realloc;
 622     my_calloc_p = 0;
 623     my_malloc_p = 0;
 624     my_free_p = 0;
 625     my_realloc_p = 0;
 626   ],
 627     AC_DEFINE(SANE_MALLOC_PROTOS, 1,
 628       [Define if you have correct malloc prototypes])
 629     SANE_MALLOC_PROTOS=yes)
 630 fi
 631 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 632 CFLAGS=$glib_save_CFLAGS
 633
 634 dnl
 635 dnl check in which direction the stack grows
 636 dnl
 637 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
 638         AC_TRY_RUN([
 639         volatile int *a = 0, *b = 0;
 640         void foo (void);
 641         int main () { volatile int y = 7; a = &y; foo (); return b > a; }
 642         void foo (void) { volatile int x = 5; b = &x; }
 643         ],
 644         glib_cv_stack_grows=no
 645         ,
 646         glib_cv_stack_grows=yes
 647         ,)
 648 ])
 649
 650 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 651 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 652 dnl actually supported.
 653 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 654         AC_COMPILE_IFELSE([
 655         __inline int foo () { return 0; }
 656         int main () { return foo (); }
 657         ],
 658         glib_cv_has__inline=yes
 659         ,
 660         glib_cv_has__inline=no
 661         ,)
 662 ])
 663 case x$glib_cv_has__inline in
 664 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 665 esac
 666 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 667         AC_COMPILE_IFELSE([
 668         __inline__ int foo () { return 0; }
 669         int main () { return foo (); }
 670         ],
 671         glib_cv_has__inline__=yes
 672         ,
 673         glib_cv_has__inline__=no
 674         ,)
 675 ])
 676 case x$glib_cv_has__inline__ in
 677 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 678 esac
 679 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 680         AC_COMPILE_IFELSE([
 681         #undef inline
 682         inline int foo () { return 0; }
 683         int main () { return foo (); }
 684         ],
 685         glib_cv_hasinline=yes
 686         ,
 687         glib_cv_hasinline=no
 688         ,)
 689 ])
 690 case x$glib_cv_hasinline in
 691 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 692 esac
 693
 694 # if we can use inline functions in headers
 695 AC_MSG_CHECKING(if inline functions in headers work)
 696 AC_LINK_IFELSE([
 697 #if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
 698 #  undef inline
 699 #  define inline __inline__
 700 #elif !defined (G_HAVE_INLINE)
 701 #  undef inline
 702 #  if defined (G_HAVE___INLINE__)
 703 #    define inline __inline__
 704 #  elif defined (G_HAVE___INLINE)
 705 #    define inline __inline
 706 #  endif
 707 #endif
 708
 709 int glib_test_func2 (int);
 710
 711 static inline int
 712 glib_test_func1 (void) {
 713   return glib_test_func2 (1);
 714 }
 715
 716 int
 717 main (void) {
 718   int i = 1;
 719 }],[g_can_inline=yes],[g_can_inline=no])
 720 AC_MSG_RESULT($g_can_inline)
 721
 722 dnl *** check for working do while(0) macros ***
 723 AC_CACHE_CHECK([for working do while(0) macros], g_support_dowhile_macros, [
 724         AC_TRY_COMPILE([],[
 725         #define STMT_START do
 726         #define STMT_END while(0)
 727         #define STMT_TEST STMT_START { i = 0; } STMT_END
 728         int main(void) { int i = 1; STMT_TEST; return i; }],
 729         [g_support_dowhile_macros=yes],
 730         [g_support_dowhile_macros=no],
 731         [g_support_dowhile_macros=yes])
 732 ])
 733 if test x$g_support_dowhile_macros = xyes; then
 734   AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
 735 fi
 736
 737 # check for flavours of varargs macros
 738 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
 739 AC_TRY_COMPILE([],[
 740 int a(int p1, int p2, int p3);
 741 #define call_a(...) a(1,__VA_ARGS__)
 742 call_a(2,3);
 743 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
 744 AC_MSG_RESULT($g_have_iso_c_varargs)
 745
 746 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
 747 if test "$CXX" = ""; then
 748 dnl No C++ compiler
 749   g_have_iso_cxx_varargs=no
 750 else
 751   AC_LANG_CPLUSPLUS
 752   AC_TRY_COMPILE([],[
 753 int a(int p1, int p2, int p3);
 754 #define call_a(...) a(1,__VA_ARGS__)
 755 call_a(2,3);
 756 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
 757   AC_LANG_C
 758 fi
 759 AC_MSG_RESULT($g_have_iso_cxx_varargs)
 760
 761 AC_MSG_CHECKING(for GNUC varargs macros)
 762 AC_TRY_COMPILE([],[
 763 int a(int p1, int p2, int p3);
 764 #define call_a(params...) a(1,params)
 765 call_a(2,3);
 766 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
 767 AC_MSG_RESULT($g_have_gnuc_varargs)
 768
 769 # check for GNUC visibility support
 770 AC_MSG_CHECKING(for GNUC visibility attribute)
 771 GLIB_CHECK_COMPILE_WARNINGS([
 772 void
 773 __attribute__ ((visibility ("hidden")))
 774      f_hidden (void)
 775 {
 776 }
 777 void
 778 __attribute__ ((visibility ("internal")))
 779      f_internal (void)
 780 {
 781 }
 782 void
 783 __attribute__ ((visibility ("protected")))
 784      f_protected (void)
 785 {
 786 }
 787 void
 788 __attribute__ ((visibility ("default")))
 789      f_default (void)
 790 {
 791 }
 792 int main (int argc, char **argv)
 793 {
 794         f_hidden();
 795         f_internal();
 796         f_protected();
 797         f_default();
 798         return 0;
 799 }
 800 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
 801 AC_MSG_RESULT($g_have_gnuc_visibility)
 802 AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
 803
 804 AC_MSG_CHECKING([whether using Sun Studio C compiler])
 805 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
 806 #else
 807 # include "error: this is not Sun Studio."
 808 #endif
 809 ]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
 810 AC_MSG_RESULT($g_have_sunstudio_visibility)
 811 AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
 812
 813 # check for bytesex stuff
 814 AC_C_BIGENDIAN
 815
 816 # check for header files
 817 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/resource.h])
 818 AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
 819 AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h sched.h malloc.h])
 820
 821 # Checks for libcharset
 822 jm_LANGINFO_CODESET
 823 jm_GLIBC21
 824 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
 825 AC_CHECK_FUNCS(setlocale)
 826
 827 # check additional type sizes
 828 AC_CHECK_SIZEOF(size_t)
 829
 830 dnl Try to figure out whether gsize, gssize should be long or int
 831 AC_MSG_CHECKING([for the appropriate definition for size_t])
 832
 833 case $ac_cv_sizeof_size_t in
 834   $ac_cv_sizeof_short)
 835       glib_size_type=short
 836       ;;
 837   $ac_cv_sizeof_int)
 838       glib_size_type=int
 839       ;;
 840   $ac_cv_sizeof_long)
 841       glib_size_type=long
 842       ;;
 843   *)  AC_MSG_ERROR([No type matching size_t in size])
 844       ;;
 845 esac
 846
 847 dnl If int/long are the same size, we see which one produces
 848 dnl warnings when used in the location as size_t. (This matters
 849 dnl on AIX with xlc)
 850 dnl
 851 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
 852    test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
 853   GLIB_CHECK_COMPILE_WARNINGS([
 854 #if defined(_AIX) && !defined(__GNUC__)
 855 #pragma options langlvl=stdc89
 856 #endif
 857 #include <stddef.h>
 858 int main ()
 859 {
 860   size_t s = 1;
 861   unsigned int *size_int = &s;
 862   return (int)*size_int;
 863 }
 864     ],glib_size_type=int,
 865       [GLIB_CHECK_COMPILE_WARNINGS([
 866 #if defined(_AIX) && !defined(__GNUC__)
 867 #pragma options langlvl=stdc89
 868 #endif
 869 #include <stddef.h>
 870 int main ()
 871 {
 872    size_t s = 1;
 873    unsigned long *size_long = &s;
 874    return (int)*size_long;
 875 }
 876         ],glib_size_type=long)])
 877 fi
 878
 879 AC_MSG_RESULT(unsigned $glib_size_type)
 880
 881 # Check for some functions
 882 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk)
 883 # Check for high-resolution sleep functions
 884 AC_CHECK_FUNCS(nanosleep nsleep)
 885
 886 AC_CHECK_HEADERS(crt_externs.h)
 887 AC_CHECK_FUNCS(_NSGetEnviron)
 888
 889 AC_FUNC_VSNPRINTF_C99
 890 AC_FUNC_PRINTF_UNIX98
 891
 892 #
 893 # Check whether to use an included printf
 894 #
 895
 896 AC_ARG_ENABLE(included-printf,
 897               [AC_HELP_STRING([--enable-included-printf],
 898                               [use included printf [default=auto]])],
 899               enable_included_printf="$enableval")
 900
 901 need_included_printf=no
 902 if test "x$enable_included_printf" = "xyes" ; then
 903   need_included_printf=yes
 904 fi
 905 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
 906   need_included_printf=yes
 907 fi
 908 if test "$ac_cv_func_printf_unix98" != "yes" ; then
 909   need_included_printf=yes
 910 fi
 911 if test "x$ac_cv_sizeof_long_long" = "x8" &&
 912    test -z "$glib_cv_long_long_format" ; then
 913   need_included_printf=yes
 914 fi
 915
 916 if test "x$enable_included_printf" = "xno" &&
 917    test "x$need_included_printf" = "xyes" ; then
 918   AC_MSG_ERROR([
 919 *** Your C library's printf doesn't appear to have the features that
 920 *** GLib needs, but you specified --enable-included-printf=no.])
 921 fi
 922
 923 enable_included_printf=$need_included_printf
 924
 925 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
 926 if test "$enable_included_printf" != "yes" ; then
 927   AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
 928 else
 929   if test -z "$glib_cv_long_long_format" ; then
 930     glib_cv_long_long_format="ll"
 931   fi
 932   AC_DEFINE(HAVE_VASPRINTF,1)
 933 fi
 934
 935 # Checks needed for gnulib vasnprintf
 936 bh_C_SIGNED
 937 jm_AC_TYPE_LONG_LONG
 938 gt_TYPE_LONGDOUBLE
 939 gt_TYPE_WCHAR_T
 940 gt_TYPE_WINT_T
 941 AC_TYPE_SIZE_T
 942 AC_CHECK_TYPES(ptrdiff_t)
 943 jm_AC_TYPE_INTMAX_T
 944 AC_CHECK_FUNCS([snprintf wcslen])
 945 AC_FUNC_SNPRINTF_C99
 946
 947 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 948 # The check is borrowed from the PERL Configure script.
 949 if test "$ac_cv_func_memmove" != "yes"; then
 950   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 951     glib_cv_working_bcopy,[AC_TRY_RUN([
 952       int main() {
 953         char buf[128], abc[128], *b;
 954         int len, off, align;
 955         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 956         for (align = 7; align >= 0; align--) {
 957           for (len = 36; len; len--) {
 958             b = buf+align; bcopy(abc, b, len);
 959             for (off = 1; off <= len; off++) {
 960               bcopy(b, b+off, len); bcopy(b+off, b, len);
 961                 if (bcmp(b, abc, len)) return(1);
 962             }
 963           }
 964         }
 965         return(0);
 966       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 967
 968   GLIB_ASSERT_SET(glib_cv_working_bcopy)
 969   if test "$glib_cv_working_bcopy" = "yes"; then
 970     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
 971   fi
 972 fi
 973
 974 # Check for sys_errlist
 975 AC_MSG_CHECKING(for sys_errlist)
 976 AC_TRY_LINK(, [
 977 extern char *sys_errlist[];
 978 extern int sys_nerr;
 979 sys_errlist[sys_nerr-1][0] = 0;
 980 ], glib_ok=yes, glib_ok=no)
 981 AC_MSG_RESULT($glib_ok)
 982 if test "$glib_ok" = "no"; then
 983     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
 984 fi
 985
 986 # Check for sys_siglist
 987 AC_MSG_CHECKING(for sys_siglist)
 988 AC_TRY_LINK(, [
 989 extern char *sys_siglist[];
 990 exit (sys_siglist[0]);
 991 ], glib_ok=yes, glib_ok=no)
 992 AC_MSG_RESULT($glib_ok)
 993 if test "$glib_ok" = "no"; then
 994     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
 995 fi
 996
 997 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 998 AC_MSG_CHECKING(for sys_siglist declaration)
 999 AC_TRY_COMPILE([#include <signal.h>], [
1000 strlen (sys_siglist[0]);
1001 ], glib_ok=yes, glib_ok=no)
1002 AC_MSG_RESULT($glib_ok)
1003 if test "$glib_ok" = "no"; then
1004     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1005 fi
1006
1007 # Check if <sys/select.h> needs to be included for fd_set
1008 AC_MSG_CHECKING([for fd_set])
1009 AC_TRY_COMPILE([#include <sys/types.h>],
1010         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1011 if test "$gtk_ok" = "yes"; then
1012     AC_MSG_RESULT([yes, found in sys/types.h])
1013 else
1014     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1015     if test "$gtk_ok" = "yes"; then
1016         # *** FIXME: give it a different name
1017         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1018         AC_MSG_RESULT([yes, found in sys/select.h])
1019     else
1020         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1021         AC_MSG_RESULT(no)
1022     fi
1023 fi
1024
1025 dnl *** check for sane realloc() ***
1026 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1027         AC_TRY_RUN([#include <stdlib.h>
1028         int main() {
1029           return realloc (0, sizeof (int)) == 0;
1030         }],
1031         [glib_cv_sane_realloc=yes],
1032         [glib_cv_sane_realloc=no],
1033         [glib_cv_sane_realloc=yes])
1034 ])
1035 if test x$glib_cv_sane_realloc = xyes; then
1036   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1037 fi
1038
1039 dnl Check for nl_langinfo and CODESET
1040 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1041         AC_TRY_COMPILE([#include <langinfo.h>],
1042                 [char *codeset = nl_langinfo (CODESET);],
1043                 [glib_cv_langinfo_codeset=yes],
1044                 [glib_cv_langinfo_codeset=no])])
1045 if test x$glib_cv_langinfo_codeset = xyes; then
1046   AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1047 fi
1048
1049 dnl ****************************************
1050 dnl *** posix_memalign                   ***
1051 dnl ****************************************
1052 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1053 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1054     glib_cv_compliant_posix_memalign=0
1055     if test "$ac_cv_func_posix_memalign" = "yes" ; then
1056         AC_TRY_RUN([
1057                 #define _XOPEN_SOURCE 600
1058                 #include <stdlib.h> /* posix_memalign() should be defined here */
1059                 /* some systems break if #include <malloc.h> used */
1060                 static void test_memalign (size_t boundary, size_t size) {
1061                     void *mem = 0;
1062                     if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1063                         exit (1);
1064                     else
1065                       free (mem);
1066                 }
1067                 int main() {
1068                     test_memalign (  128,   128 - 2 * sizeof (void*));
1069                     test_memalign (  256,   256 - 2 * sizeof (void*));
1070                     test_memalign (  512,   512 - 2 * sizeof (void*));
1071                     test_memalign ( 1024,  1024 - 2 * sizeof (void*));
1072                     test_memalign ( 2048,  2048 - 2 * sizeof (void*));
1073                     test_memalign ( 4096,  4096 - 2 * sizeof (void*));
1074                     test_memalign ( 8192,  8192 - 2 * sizeof (void*));
1075                     test_memalign (16384, 16384 - 2 * sizeof (void*));
1076                     test_memalign (32768, 32768 - 2 * sizeof (void*));
1077                     exit (0); /* success */
1078                 }
1079                 ],
1080             [glib_cv_compliant_posix_memalign=1], [], [:])
1081       :
1082     fi
1083     ])
1084 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1085     AC_MSG_RESULT(yes)
1086     AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1087 else
1088     AC_MSG_RESULT(no)
1089 fi
1090
1091
1092 dnl ****************************************
1093 dnl *** strlcpy/strlcat                  ***
1094 dnl ****************************************
1095 # Check for strlcpy
1096 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1097 AC_TRY_RUN([#include <stdlib.h>
1098 #include <string.h>
1099 int main() {
1100   char p[10];
1101   (void) strlcpy (p, "hi", 10);
1102   if (strlcat (p, "bye", 0) != 3)
1103     return 1;
1104   return 0;
1105 }], glib_cv_have_strlcpy=yes,
1106     glib_cv_have_strlcpy=no,
1107     glib_cv_have_strlcpy=no)])
1108 if test "$glib_cv_have_strlcpy" = "yes"; then
1109     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1110 fi
1111
1112
1113 dnl **********************
1114 dnl *** va_copy checks ***
1115 dnl **********************
1116 dnl we currently check for all three va_copy possibilities, so we get
1117 dnl all results in config.log for bug reports.
1118 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1119         AC_LINK_IFELSE([#include <stdarg.h>
1120 #include <stdlib.h>
1121         void f (int i, ...) {
1122         va_list args1, args2;
1123         va_start (args1, i);
1124         va_copy (args2, args1);
1125         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1126           exit (1);
1127         va_end (args1); va_end (args2);
1128         }
1129         int main() {
1130           f (0, 42);
1131           return 0;
1132         }],
1133         [glib_cv_va_copy=yes],
1134         [glib_cv_va_copy=no])
1135 ])
1136 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1137         AC_LINK_IFELSE([#include <stdarg.h>
1138 #include <stdlib.h>
1139         void f (int i, ...) {
1140         va_list args1, args2;
1141         va_start (args1, i);
1142         __va_copy (args2, args1);
1143         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1144           exit (1);
1145         va_end (args1); va_end (args2);
1146         }
1147         int main() {
1148           f (0, 42);
1149           return 0;
1150         }],
1151         [glib_cv___va_copy=yes],
1152         [glib_cv___va_copy=no])
1153 ])
1154
1155 if test "x$glib_cv_va_copy" = "xyes"; then
1156   g_va_copy_func=va_copy
1157 else if test "x$glib_cv___va_copy" = "xyes"; then
1158   g_va_copy_func=__va_copy
1159 fi
1160 fi
1161
1162 if test -n "$g_va_copy_func"; then
1163   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1164 fi
1165
1166 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1167         AC_TRY_RUN([#include <stdarg.h>
1168 #include <stdlib.h>
1169         void f (int i, ...) {
1170         va_list args1, args2;
1171         va_start (args1, i);
1172         args2 = args1;
1173         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1174           exit (1);
1175         va_end (args1); va_end (args2);
1176         }
1177         int main() {
1178           f (0, 42);
1179           return 0;
1180         }],
1181         [glib_cv_va_val_copy=yes],
1182         [glib_cv_va_val_copy=no],
1183         [glib_cv_va_val_copy=yes])
1184 ])
1185
1186 if test "x$glib_cv_va_val_copy" = "xno"; then
1187   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1188 fi
1189
1190 dnl ***********************
1191 dnl *** g_module checks ***
1192 dnl ***********************
1193 G_MODULE_LIBS=
1194 G_MODULE_LIBS_EXTRA=
1195 G_MODULE_PLUGIN_LIBS=
1196 if test x"$glib_native_win32" = xyes; then
1197   dnl No use for this on Win32
1198   G_MODULE_LDFLAGS=
1199 else
1200   export SED
1201   G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1202 fi
1203 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1204 G_MODULE_NEED_USCORE=0
1205 G_MODULE_BROKEN_RTLD_GLOBAL=0
1206 G_MODULE_HAVE_DLERROR=0
1207 dnl *** force native WIN32 shared lib loader
1208 if test -z "$G_MODULE_IMPL"; then
1209   case "$host" in
1210   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1211   esac
1212 fi
1213 dnl *** force native AIX library loader
1214 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1215 if test -z "$G_MODULE_IMPL"; then
1216   case "$host" in
1217   *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1218   esac
1219 fi
1220 dnl *** dlopen() and dlsym() in system libraries
1221 if test -z "$G_MODULE_IMPL"; then
1222         AC_CHECK_FUNC(dlopen,
1223                       [AC_CHECK_FUNC(dlsym,
1224                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1225                       [])
1226 fi
1227 dnl *** load_image (BeOS)
1228 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1229   AC_CHECK_LIB(root, load_image,
1230       [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1231       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1232       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1233       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1234       [])
1235 fi
1236 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1237 if test -z "$G_MODULE_IMPL"; then
1238         AC_CHECK_FUNC(NSLinkModule,
1239                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1240                        G_MODULE_NEED_USCORE=1],
1241                       [])
1242 fi
1243 dnl *** dlopen() and dlsym() in libdl
1244 if test -z "$G_MODULE_IMPL"; then
1245         AC_CHECK_LIB(dl, dlopen,
1246                      [AC_CHECK_LIB(dl, dlsym,
1247                                    [G_MODULE_LIBS=-ldl
1248                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1249                      [])
1250 fi
1251 dnl *** shl_load() in libdld (HP-UX)
1252 if test -z "$G_MODULE_IMPL"; then
1253         AC_CHECK_LIB(dld, shl_load,
1254                 [G_MODULE_LIBS=-ldld
1255                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1256                 [])
1257 fi
1258 dnl *** additional checks for G_MODULE_IMPL_DL
1259 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1260         LIBS_orig="$LIBS"
1261         LDFLAGS_orig="$LDFLAGS"
1262         LIBS="$G_MODULE_LIBS $LIBS"
1263         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1264 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1265         echo "void glib_plugin_test(void) { }" > plugin.c
1266         ${SHELL} ./libtool --mode=compile ${CC} -shared \
1267                 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1268         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1269                 glib_cv_rtldglobal_broken,[
1270                 AC_TRY_RUN([
1271 #include <dlfcn.h>
1272 #ifndef RTLD_GLOBAL
1273 #  define RTLD_GLOBAL 0
1274 #endif
1275 #ifndef RTLD_LAZY
1276 #  define RTLD_LAZY 0
1277 #endif
1278 int glib_plugin_test;
1279 int main () {
1280     void *handle, *global, *local;
1281     global = &glib_plugin_test;
1282     handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1283     if (!handle) return 0;
1284     local = dlsym (handle, "glib_plugin_test");
1285     return global == local;
1286 }                       ],
1287                         [glib_cv_rtldglobal_broken=no],
1288                         [glib_cv_rtldglobal_broken=yes],
1289                         [glib_cv_rtldglobal_broken=no])
1290                 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1291                 rmdir .libs 2>/dev/null
1292         ])
1293         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1294                 G_MODULE_BROKEN_RTLD_GLOBAL=1
1295         else
1296                 G_MODULE_BROKEN_RTLD_GLOBAL=0
1297         fi
1298 dnl *** check whether we need preceeding underscores
1299         AC_CACHE_CHECK([for preceeding underscore in symbols],
1300                 glib_cv_uscore,[
1301                 AC_TRY_RUN([#include <dlfcn.h>
1302                 int glib_underscore_test (void) { return 42; }
1303                 int main() {
1304                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
1305                   handle = dlopen ((void*)0, 0);
1306                   if (handle) {
1307                     f1 = dlsym (handle, "glib_underscore_test");
1308                     f2 = dlsym (handle, "_glib_underscore_test");
1309                   } return (!f2 || f1);
1310                 }],
1311                         [glib_cv_uscore=yes],
1312                         [glib_cv_uscore=no],
1313                         [])
1314                 rm -f plugin.c plugin.$ac_objext plugin.lo
1315         ])
1316         GLIB_ASSERT_SET(glib_cv_uscore)
1317         if test "x$glib_cv_uscore" = "xyes"; then
1318                 G_MODULE_NEED_USCORE=1
1319         else
1320                 G_MODULE_NEED_USCORE=0
1321         fi
1322
1323         LDFLAGS="$LDFLAGS_orig"
1324 dnl *** check for having dlerror()
1325         AC_CHECK_FUNC(dlerror,
1326                 [G_MODULE_HAVE_DLERROR=1],
1327                 [G_MODULE_HAVE_DLERROR=0])
1328         LIBS="$LIBS_orig"
1329 fi
1330 dnl *** done, have we got an implementation?
1331 if test -z "$G_MODULE_IMPL"; then
1332         G_MODULE_IMPL=0
1333         G_MODULE_SUPPORTED=false
1334 else
1335         G_MODULE_SUPPORTED=true
1336 fi
1337
1338 AC_MSG_CHECKING(for the suffix of shared libraries)
1339 export SED
1340 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1341 eval $shrext_cmds
1342 module=yes eval std_shrext=$shrext_cmds
1343 # chop the initial dot
1344 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1345 AC_MSG_RESULT(.$glib_gmodule_suffix)
1346 # any reason it may fail?
1347 if test "x$glib_gmodule_suffix" = x; then
1348         AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1349 fi
1350
1351 AC_SUBST(G_MODULE_SUPPORTED)
1352 AC_SUBST(G_MODULE_IMPL)
1353 AC_SUBST(G_MODULE_LIBS)
1354 AC_SUBST(G_MODULE_LIBS_EXTRA)
1355 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1356 AC_SUBST(G_MODULE_LDFLAGS)
1357 AC_SUBST(G_MODULE_HAVE_DLERROR)
1358 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1359 AC_SUBST(G_MODULE_NEED_USCORE)
1360 AC_SUBST(GLIB_DEBUG_FLAGS)
1361
1362 dnl **********************
1363 dnl *** g_spawn checks ***
1364 dnl **********************
1365
1366 AC_MSG_CHECKING(for gspawn implementation)
1367 case "$host" in
1368   *-*-mingw*)
1369     GSPAWN=gspawn-win32.lo
1370     ;;
1371   *)
1372     GSPAWN=gspawn.lo
1373     ;;
1374 esac
1375 AC_MSG_RESULT($GSPAWN)
1376 AC_SUBST(GSPAWN)
1377
1378 dnl *************************
1379 dnl *** GIOChannel checks ***
1380 dnl *************************
1381
1382 AC_MSG_CHECKING(for GIOChannel implementation)
1383 case "$host" in
1384   *-*-mingw*)
1385     GIO=giowin32.lo
1386     ;;
1387   *)
1388     GIO=giounix.lo
1389     ;;
1390 esac
1391 AC_MSG_RESULT($GIO)
1392 AC_SUBST(GIO)
1393
1394 dnl ****************************************
1395 dnl *** platform dependent source checks ***
1396 dnl ****************************************
1397
1398 AC_MSG_CHECKING(for platform-dependent source)
1399 case "$host" in
1400   *-*-cygwin*|*-*-mingw*)
1401     PLATFORMDEP=gwin32.lo
1402     ;;
1403   *)
1404     PLATFORMDEP=
1405     ;;
1406 esac
1407 AC_MSG_RESULT($PLATFORMDEP)
1408 AC_SUBST(PLATFORMDEP)
1409
1410 AC_MSG_CHECKING([whether to compile timeloop])
1411 case "$host" in
1412   *-*-cygwin*|*-*-mingw*|*-*-minix)
1413     enable_timeloop=no
1414     ;;
1415   *)
1416     enable_timeloop=yes
1417     ;;
1418 esac
1419 AC_MSG_RESULT($enable_timeloop)
1420 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1421
1422 AC_MSG_CHECKING([if building for some Win32 platform])
1423 case "$host" in
1424   *-*-mingw*|*-*-cygwin*)
1425     platform_win32=yes
1426     ;;
1427   *)
1428     platform_win32=no
1429     ;;
1430 esac
1431 AC_MSG_RESULT($platform_win32)
1432 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1433
1434 dnl ***********************
1435 dnl *** g_thread checks ***
1436 dnl ***********************
1437
1438 AC_ARG_WITH(threads,
1439            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1440                            [specify a thread implementation to use])],
1441            [if test "x$with_threads" = x; then
1442                 want_threads=yes
1443             else
1444                 want_threads=$with_threads
1445             fi],
1446            [want_threads=yes])
1447 if test "x$enable_threads" = "xno"; then
1448         want_threads=no
1449 fi
1450
1451 dnl error and warning message
1452 dnl *************************
1453
1454 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1455                 computer. GLib will not have a default thread implementation."
1456
1457 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1458                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1459                 compilation now, but then your programs might not work.
1460                 Please provide information on how it is done on your system."
1461
1462 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1463                 "
1464
1465 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1466                 provide information on your thread implementation.
1467                 You can also run 'configure --disable-threads'
1468                 to compile without thread support."
1469
1470 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1471                 functions will not be MT-safe during their first call because
1472                 there is no working 'getpwuid_r' on your system."
1473
1474 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1475                 because there is no 'localtime_r' on your system."
1476
1477 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1478                 crude surrogate will be used. If you happen to know a
1479                 yield function for your system, please inform the GLib
1480                 developers."
1481
1482 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1483                 threads on your system. Thus threads can only have the default
1484                 priority. If you happen to know these main/max
1485                 priorities, please inform the GLib developers."
1486
1487 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1488                 linking threaded applications. As GLib cannot do that
1489                 automatically, you will get an linkg error everytime you are
1490                 not using the right compiler. In that case you have to relink
1491                 with the right compiler. Ususally just '_r' is appended
1492                 to the compiler name."
1493
1494 dnl determination of thread implementation
1495 dnl ***************************************
1496
1497 # have_threads=no   means no thread support
1498 # have_threads=none means no default thread implementation
1499
1500 have_threads=no
1501 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1502                                 || test "x$want_threads" = xdce; then
1503         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1504         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1505         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1506         glib_save_CPPFLAGS="$CPPFLAGS"
1507         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1508         if test "x$have_threads" = xno; then
1509                 AC_TRY_COMPILE([#include <pthread.h>],
1510                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1511                         have_threads=posix)
1512         fi
1513         if test "x$have_threads" = xno; then
1514                 AC_TRY_COMPILE([#include <pthread.h>],
1515                         [pthread_mutex_t m;
1516                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1517                         have_threads=dce)
1518         fi
1519         # Tru64Unix requires -pthread to find pthread.h. See #103020
1520         CPPFLAGS="$CPPFLAGS -pthread"
1521         if test "x$have_threads" = xno; then
1522         AC_TRY_COMPILE([#include <pthread.h>],
1523                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1524                        have_threads=posix)
1525         fi
1526         CPPFLAGS="$glib_save_CPPFLAGS"
1527 fi
1528 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1529         case $host in
1530                 *-*-mingw*)
1531                 have_threads=win32
1532                 ;;
1533         esac
1534 fi
1535 if test "x$want_threads" = xnone; then
1536         have_threads=none
1537 fi
1538
1539 AC_MSG_CHECKING(for thread implementation)
1540
1541 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1542         AC_MSG_RESULT(none available)
1543         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1544 else
1545         AC_MSG_RESULT($have_threads)
1546 fi
1547
1548
1549 dnl determination of G_THREAD_CFLAGS
1550 dnl ********************************
1551
1552 G_THREAD_LIBS=
1553 G_THREAD_LIBS_EXTRA=
1554 G_THREAD_CFLAGS=
1555
1556 dnl
1557 dnl Test program for basic POSIX threads functionality
1558 dnl
1559 m4_define([glib_thread_test],[
1560 #include <pthread.h>
1561 int check_me = 0;
1562 void* func(void* data) {check_me = 42; return &check_me;}
1563 int main()
1564  { pthread_t t;
1565    void *ret;
1566    pthread_create (&t, $1, func, 0);
1567    pthread_join (t, &ret);
1568    return (check_me != 42 || ret != &check_me);
1569 }])
1570
1571 dnl
1572 dnl Test program for sched_get_priority_min()
1573 dnl
1574 m4_define([glib_sched_priority_test],[
1575 #include <sched.h>
1576 #include <errno.h>
1577 int main() {
1578     errno = 0;
1579     return sched_get_priority_min(SCHED_OTHER)==-1
1580            && errno != 0;
1581 }])
1582
1583 if test x"$have_threads" != xno; then
1584
1585   if test x"$have_threads" = xposix; then
1586     # First we test for posix, whether -pthread or -pthreads do the trick as
1587     # both CPPFLAG and LIBS.
1588     # One of them does for most gcc versions and some other platforms/compilers
1589     # too and could be considered as the canonical way to go.
1590     case $host in
1591       *-*-cygwin*|*-*-darwin*)
1592          # skip cygwin and darwin -pthread or -pthreads test
1593          ;;
1594       *-solaris*)
1595         # These compiler/linker flags work with both Sun Studio and gcc
1596         # Sun Studio expands -mt to -D_REENTRANT and -lthread
1597         # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1598         G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1599         G_THREAD_LIBS="-lpthread -lthread"
1600         ;;
1601       *)
1602         for flag in pthread pthreads mt; do
1603           glib_save_CFLAGS="$CFLAGS"
1604           CFLAGS="$CFLAGS -$flag"
1605           AC_TRY_RUN(glib_thread_test(0),
1606                      glib_flag_works=yes,
1607                      glib_flag_works=no,
1608                      [AC_LINK_IFELSE(glib_thread_test(0),
1609                                      glib_flag_works=yes,
1610                                      glib_flag_works=no)])
1611           CFLAGS="$glib_save_CFLAGS"
1612           if test $glib_flag_works = yes ; then
1613              G_THREAD_CFLAGS=-$flag
1614              G_THREAD_LIBS=-$flag
1615              break;
1616           fi
1617         done
1618          ;;
1619     esac
1620   fi
1621
1622   if test x"$G_THREAD_CFLAGS" = x; then
1623
1624     # The canonical -pthread[s] does not work. Try something different.
1625
1626     case $host in
1627         *-aix*)
1628                 if test x"$GCC" = xyes; then
1629                         # GCC 3.0 and above needs -pthread.
1630                         # Should be coverd by the case above.
1631                         # GCC 2.x and below needs -mthreads
1632                         G_THREAD_CFLAGS="-mthreads"
1633                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1634                 else
1635                         # We are probably using the aix compiler. Normaly a
1636                         # program would have to be compiled with the _r variant
1637                         # of the corresponding compiler, but we as GLib cannot
1638                         # do that: but the good news is that for compiling the
1639                         # only difference is the added -D_THREAD_SAFE compile
1640                         # option. This is according to the "C for AIX User's
1641                         # Guide".
1642                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1643                 fi
1644                 ;;
1645         *-dg-dgux*)  # DG/UX
1646                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1647                 ;;
1648         *-osf*)
1649                 # So we are using dce threads. posix threads are already
1650                 # catched above.
1651                 G_THREAD_CFLAGS="-threads"
1652                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1653                 ;;
1654         *-sysv5uw7*) # UnixWare 7
1655                 # We are not using gcc with -pthread. Catched above.
1656                 G_THREAD_CFLAGS="-Kthread"
1657                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1658                 ;;
1659         *-mingw*)
1660                 # No flag needed when using MSVCRT.DLL
1661                 G_THREAD_CFLAGS=""
1662                 ;;
1663         *)
1664                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1665                 ;;
1666     esac
1667
1668   fi
1669
1670     # if we are not finding the localtime_r function, then we probably are
1671     # not using the proper multithread flag
1672
1673     glib_save_CPPFLAGS="$CPPFLAGS"
1674     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1675
1676     # First we test, whether localtime_r is declared in time.h
1677     # directly. Then we test whether a macro localtime_r exists, in
1678     # which case localtime_r in the test program is replaced and thus
1679     # if we still find localtime_r in the output, it is not defined as
1680     # a macro.
1681
1682     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1683       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1684                                                            localtime_r(a,b)],
1685                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1686
1687     CPPFLAGS="$glib_save_CPPFLAGS"
1688
1689     AC_MSG_CHECKING(thread related cflags)
1690     AC_MSG_RESULT($G_THREAD_CFLAGS)
1691     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1692 fi
1693
1694 dnl determination of G_THREAD_LIBS
1695 dnl ******************************
1696
1697 mutex_has_default=no
1698 case $have_threads in
1699         posix|dce)
1700           glib_save_CPPFLAGS="$CPPFLAGS"
1701           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1702           if test x"$G_THREAD_LIBS" = x; then
1703             case $host in
1704               *-aix*)
1705                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1706                 # probably using the aix compiler.
1707                 AC_MSG_WARN($AIX_COMPILE_INFO)
1708                 ;;
1709               *)
1710                 G_THREAD_LIBS=error
1711                 glib_save_LIBS="$LIBS"
1712                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1713                         if test x"$thread_lib" = x; then
1714                                 add_thread_lib=""
1715                                 IN=""
1716                         else
1717                                 add_thread_lib="-l$thread_lib"
1718                                 IN=" in -l$thread_lib"
1719                         fi
1720                         if test x"$have_threads" = xposix; then
1721                                 defattr=0
1722                         else
1723                                 defattr=pthread_attr_default
1724                         fi
1725
1726                         LIBS="$add_thread_lib $glib_save_LIBS"
1727
1728                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1729                         AC_TRY_RUN(glib_thread_test($defattr),
1730                                    glib_result=yes,
1731                                    glib_result=no,
1732                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
1733                                                    glib_result=yes,
1734                                                    glib_result=no)])
1735                         AC_MSG_RESULT($glib_result)
1736
1737                         if test "$glib_result" = "yes" ; then
1738                           G_THREAD_LIBS="$add_thread_lib"
1739                           break
1740                         fi
1741                 done
1742                 if test "x$G_THREAD_LIBS" = xerror; then
1743                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1744                 fi
1745                 LIBS="$glib_save_LIBS"
1746                 ;;
1747             esac
1748           fi
1749
1750           glib_save_LIBS="$LIBS"
1751           for thread_lib in "" rt rte; do
1752             if test x"$thread_lib" = x; then
1753               add_thread_lib=""
1754               IN=""
1755             else
1756               add_thread_lib="-l$thread_lib"
1757               IN=" in -l$thread_lib"
1758             fi
1759             LIBS="$add_thread_lib $glib_save_LIBS"
1760
1761             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1762             AC_TRY_RUN(glib_sched_priority_test,
1763                        glib_result=yes,
1764                        glib_result=no,
1765                        [AC_LINK_IFELSE(glib_sched_priority_test,
1766                                        glib_result=yes,
1767                                        glib_result=no)])
1768             AC_MSG_RESULT($glib_result)
1769
1770             if test "$glib_result" = "yes" ; then
1771                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1772                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1773                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1774                break
1775             fi
1776           done
1777           LIBS="$glib_save_LIBS"
1778           mutex_has_default=yes
1779           mutex_default_type='pthread_mutex_t'
1780           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1781           mutex_header_file='pthread.h'
1782           if test "x$have_threads" = "xposix"; then
1783             g_threads_impl="POSIX"
1784           else
1785             g_threads_impl="DCE"
1786             have_threads="posix"
1787           fi
1788           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1789           CPPFLAGS="$glib_save_CPPFLAGS"
1790           ;;
1791         win32)
1792            g_threads_impl="WIN32"
1793            ;;
1794         none|no)
1795            g_threads_impl="NONE"
1796            ;;
1797         *)
1798            g_threads_impl="NONE"
1799            G_THREAD_LIBS=error
1800            ;;
1801 esac
1802
1803 if test "x$G_THREAD_LIBS" = xerror; then
1804         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1805 fi
1806
1807 case $host in
1808   *-*-beos*)
1809     G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
1810     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1811     ;;
1812   *)
1813     ;;
1814 esac
1815
1816 AC_MSG_CHECKING(thread related libraries)
1817 AC_MSG_RESULT($G_THREAD_LIBS)
1818
1819 dnl check for mt safe function variants and some posix functions
1820 dnl ************************************************************
1821
1822 if test x"$have_threads" != xno; then
1823         glib_save_LIBS="$LIBS"
1824         # we are not doing the following for now, as this might require glib
1825         # to always be linked with the thread libs on some platforms.
1826         # LIBS="$LIBS $G_THREAD_LIBS"
1827         AC_CHECK_FUNCS(localtime_r)
1828         if test "$ac_cv_header_pwd_h" = "yes"; then
1829                 AC_CACHE_CHECK([for posix getpwuid_r],
1830                         ac_cv_func_posix_getpwuid_r,
1831                         [AC_TRY_RUN([
1832 #include <errno.h>
1833 #include <pwd.h>
1834 int main () {
1835     char buffer[10000];
1836     struct passwd pwd, *pwptr = &pwd;
1837     int error;
1838     errno = 0;
1839     error = getpwuid_r (0, &pwd, buffer,
1840                         sizeof (buffer), &pwptr);
1841    return (error < 0 && errno == ENOSYS)
1842            || error == ENOSYS;
1843 }                               ],
1844                                 [ac_cv_func_posix_getpwuid_r=yes],
1845                                 [ac_cv_func_posix_getpwuid_r=no])])
1846                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1847                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1848                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1849                                 [Have POSIX function getpwuid_r])
1850                 else
1851                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1852                                 ac_cv_func_nonposix_getpwuid_r,
1853                                 [AC_TRY_LINK([#include <pwd.h>],
1854                                         [char buffer[10000];
1855                                         struct passwd pwd;
1856                                         getpwuid_r (0, &pwd, buffer,
1857                                                         sizeof (buffer));],
1858                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1859                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1860                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1861                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1862                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1863                                         [Have non-POSIX function getpwuid_r])
1864                         fi
1865                 fi
1866         fi
1867         LIBS="$G_THREAD_LIBS $LIBS"
1868         if test x"$have_threads" = xposix; then
1869                 glib_save_CPPFLAGS="$CPPFLAGS"
1870                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1871                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1872                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1873                 # This is not AC_CHECK_FUNC to also work with function
1874                 # name mangling in header files.
1875                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1876                 AC_TRY_LINK([#include <pthread.h>],
1877                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1878                         [AC_MSG_RESULT(yes)
1879                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1880                                   [Have function pthread_attr_setstacksize])],
1881                         [AC_MSG_RESULT(no)])
1882                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1883                 if test x"$posix_priority_min" = x; then
1884                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1885                                 PX_PRIO_MIN],,[
1886                                 posix_priority_min=PX_PRIO_MIN
1887                                 posix_priority_max=PX_PRIO_MAX])
1888                 fi
1889                 if test x"$posix_priority_min" = x; then
1890                         # AIX
1891                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1892                                 PTHREAD_PRIO_MIN],,[
1893                                 posix_priority_min=PTHREAD_PRIO_MIN
1894                                 posix_priority_max=PTHREAD_PRIO_MAX])
1895                 fi
1896                 if test x"$posix_priority_min" = x; then
1897                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1898                                 PRI_OTHER_MIN],,[
1899                                 posix_priority_min=PRI_OTHER_MIN
1900                                 posix_priority_max=PRI_OTHER_MAX])
1901                 fi
1902                 if test x"$posix_priority_min" = x; then
1903                         AC_MSG_RESULT(none found)
1904                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1905                         posix_priority_min=-1
1906                         posix_priority_max=-1
1907                 else
1908                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1909                         AC_MSG_CHECKING(for pthread_setschedparam)
1910                         AC_TRY_LINK([#include <pthread.h>],
1911                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1912                           [AC_MSG_RESULT(yes)
1913                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1914                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1915                           [AC_MSG_RESULT(no)
1916                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1917                 fi
1918                 posix_yield_func=none
1919                 AC_MSG_CHECKING(for posix yield function)
1920                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1921                                                         thr_yield; do
1922                         AC_TRY_LINK([#include <pthread.h>],
1923                                 [$yield_func()],
1924                                 [posix_yield_func="$yield_func"
1925                                 break])
1926                 done
1927                 if test x"$posix_yield_func" = xnone; then
1928                         AC_MSG_RESULT(none found)
1929                         AC_MSG_WARN($POSIX_NO_YIELD)
1930                         posix_yield_func="g_usleep(1000)"
1931                 else
1932                         AC_MSG_RESULT($posix_yield_func)
1933                         posix_yield_func="$posix_yield_func()"
1934                 fi
1935                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1936                 CPPFLAGS="$glib_save_CPPFLAGS"
1937
1938         elif test x"$have_threads" = xwin32; then
1939                 # It's a pointer to a private struct
1940                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1941         fi
1942
1943         LIBS="$glib_save_LIBS"
1944
1945         # now spit out all the warnings.
1946         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1947            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1948                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1949         fi
1950         if test "$ac_cv_func_localtime_r" != "yes"; then
1951                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1952         fi
1953 fi
1954
1955 if test x"$glib_cv_sizeof_system_thread" = x; then
1956    # use a pointer as a fallback.
1957    GLIB_SIZEOF(,void *, system_thread)
1958 fi
1959
1960 #
1961 # Hack to deal with:
1962 #
1963 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
1964 #     building shared libraries with linux.
1965 #  b) FreeBSD doesn't do this either.
1966 #
1967 case $host in
1968   *-*-freebsd*|*-*-linux*)
1969     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1970     ;;
1971   *)
1972     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
1973     ;;
1974 esac
1975
1976 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1977                    [Source file containing theread implementation])
1978 AC_SUBST(G_THREAD_CFLAGS)
1979 AC_SUBST(G_THREAD_LIBS)
1980 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1981 AC_SUBST(G_THREAD_LIBS_EXTRA)
1982
1983 dnl **********************************************
1984 dnl *** GDefaultMutex setup and initialization ***
1985 dnl **********************************************
1986 dnl
1987 dnl if mutex_has_default = yes, we also got
1988 dnl mutex_default_type, mutex_default_init and mutex_header_file
1989 if test $mutex_has_default = yes ; then
1990         glib_save_CPPFLAGS="$CPPFLAGS"
1991         glib_save_LIBS="$LIBS"
1992         LIBS="$G_THREAD_LIBS $LIBS"
1993         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1994         GLIB_SIZEOF([#include <$mutex_header_file>],
1995                     $mutex_default_type,
1996                     gmutex)
1997         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1998                            $mutex_default_type,
1999                            gmutex,
2000                            $glib_cv_sizeof_gmutex,
2001                            $mutex_default_init)
2002         if test x"$glib_cv_byte_contents_gmutex" = xno; then
2003                 mutex_has_default=no
2004         fi
2005         CPPFLAGS="$glib_save_CPPFLAGS"
2006         LIBS="$glib_save_LIBS"
2007 fi
2008
2009 AC_CHECK_FUNCS(clock_gettime, [], [
2010   AC_CHECK_LIB(rt, clock_gettime, [
2011     AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2012     G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2013     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2014   ])
2015 ])
2016
2017 AC_CACHE_CHECK(for monotonic clocks,
2018     glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2019 #include <time.h>
2020 #include <unistd.h>
2021 int main() {
2022 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2023         #error No monotonic clock
2024 #endif
2025         return 0;
2026 }
2027 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2028 if test "$glib_cv_monotonic_clock" = "yes"; then
2029   AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2030 fi
2031
2032
2033 dnl ********************************
2034 dnl *** g_atomic_* tests for gcc ***
2035 dnl ********************************
2036
2037 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2038
2039 if test x"$GCC" = xyes; then
2040   case $host_cpu in
2041     i386)
2042       AC_MSG_RESULT([none])
2043       glib_memory_barrier_needed=no
2044       ;;
2045     i?86)
2046       AC_MSG_RESULT([i486])
2047       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2048                          [i486 atomic implementation])
2049       glib_memory_barrier_needed=no
2050       ;;
2051     sparc*)
2052       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2053                 when you are using a sparc with v9 instruction set (most
2054                 sparcs nowadays). This will make the code for atomic
2055                 operations much faster. The resulting code will not run
2056                 on very old sparcs though."
2057
2058       AC_LINK_IFELSE([[
2059         main ()
2060         {
2061           int tmp1, tmp2, tmp3;
2062           __asm__ __volatile__("casx [%2], %0, %1"
2063                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2064         }]],
2065         AC_MSG_RESULT([sparcv9])
2066         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2067                            [sparcv9 atomic implementation]),
2068         AC_MSG_RESULT([no])
2069         AC_MSG_WARN([[$SPARCV9_WARNING]]))
2070       glib_memory_barrier_needed=yes
2071       ;;
2072     alpha*)
2073       AC_MSG_RESULT([alpha])
2074       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2075                          [alpha atomic implementation])
2076       glib_memory_barrier_needed=yes
2077       ;;
2078     x86_64)
2079       AC_MSG_RESULT([x86_64])
2080       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2081                          [x86_64 atomic implementation])
2082       glib_memory_barrier_needed=no
2083      ;;
2084     powerpc*)
2085       AC_MSG_RESULT([powerpc])
2086       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2087                          [powerpc atomic implementation])
2088       glib_memory_barrier_needed=yes
2089       AC_MSG_CHECKING([whether asm supports numbered local labels])
2090       AC_TRY_COMPILE(
2091                 ,[
2092                         __asm__ __volatile__ ("1:       nop\n"
2093                                               "         bne-    1b")
2094                 ],[
2095                         AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2096                         AC_MSG_RESULT([yes])
2097                 ],[
2098                         AC_MSG_RESULT([no])
2099                 ])
2100       ;;
2101     ia64)
2102       AC_MSG_RESULT([ia64])
2103       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2104                          [ia64 atomic implementation])
2105       glib_memory_barrier_needed=yes
2106       ;;
2107     s390|s390x)
2108       AC_MSG_RESULT([s390])
2109       AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2110                          [s390 atomic implementation])
2111       glib_memory_barrier_needed=no
2112       ;;
2113     arm*)
2114       AC_MSG_RESULT([arm])
2115       AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2116                          [arm atomic implementation])
2117       glib_memory_barrier_needed=no
2118       ;;
2119     *)
2120       AC_MSG_RESULT([none])
2121       glib_memory_barrier_needed=yes
2122       ;;
2123   esac
2124 fi
2125
2126 dnl ****************************************
2127 dnl *** GLib POLL* compatibility defines ***
2128 dnl ****************************************
2129
2130 glib_poll_includes=["
2131 #include <sys/types.h>
2132 #include <sys/poll.h>
2133 "]
2134
2135 if test $ac_cv_header_sys_types_h = yes &&
2136    test $ac_cv_header_sys_poll_h = yes ; then
2137   glib_failed=false
2138   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2139   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2140   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2141   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2142   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2143   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2144   if $glib_failed ; then
2145     AC_MSG_ERROR([Could not determine values for POLL* constants])
2146   fi
2147 else
2148   glib_cv_value_POLLIN=1
2149   glib_cv_value_POLLOUT=4
2150   glib_cv_value_POLLPRI=2
2151   glib_cv_value_POLLERR=8
2152   glib_cv_value_POLLHUP=16
2153   glib_cv_value_POLLNVAL=32
2154 fi
2155
2156 AC_MSG_CHECKING([for broken poll])
2157 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2158         #include <stdlib.h>
2159         #include <fcntl.h>
2160         #include <poll.h>
2161         #ifdef HAVE_SYS_POLL_H
2162         #include <sys/poll.h>
2163         #endif
2164         int main(void) {
2165           struct pollfd fds[1];
2166           int fd;
2167           fd = open("/dev/null", 1);
2168           fds[0].fd = fd;
2169           fds[0].events = POLLIN;
2170           fds[0].revents = 0;
2171           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2172                 exit(1);  /* Does not work for devices -- fail */
2173           }
2174           exit(0);
2175         }]])],
2176   [broken_poll=no],
2177   [broken_poll=yes
2178    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2179   [broken_poll="no (cross compiling)"])
2180 AC_MSG_RESULT($broken_poll)
2181
2182 dnl *********************
2183 dnl *** GRegex checks ***
2184 dnl *********************
2185 PCRE_REQUIRED_VERSION=7.2
2186
2187 # Check if we should compile GRegex
2188 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2189               [disable the compilation of GRegex]),
2190 [case "${enableval}" in
2191   yes) enable_regex=true ;;
2192   no)  enable_regex=false ;;
2193   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2194 esac],
2195 [enable_regex=true])
2196
2197 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2198
2199 if test x$enable_regex = xtrue; then
2200   # Check if we should use the internal or the system-supplied pcre
2201   AC_ARG_WITH(pcre,
2202              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2203                              [specify whether to use the internal or the
2204                               system-supplied PCRE library])])
2205
2206   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2207
2208   if test "x$with_pcre" = xsystem; then
2209     PKG_CHECK_MODULES(PCRE,
2210                       libpcre >= $PCRE_REQUIRED_VERSION)
2211     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2212                    glib_save_CFLAGS="$CFLAGS"
2213                    glib_save_LDFLAGS="$LDFLAGS"
2214                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LDFLAGS="$LDFLAGS $PCRE_LIBS"
2215                    AC_TRY_RUN([#include <pcre.h>
2216                                int main () {
2217                                  int support;
2218                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2219                                  if (!support)
2220                                    return 1;
2221                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2222                                  if (!support)
2223                                    return 1;
2224                                  return 0;
2225                                }],
2226                    glib_cv_pcre_has_unicode=yes,
2227                    glib_cv_pcre_has_unicode=no,
2228                    glib_cv_pcre_has_unicode=yes)
2229                    CFLAGS="$glib_save_CFLAGS"
2230                    LDFLAGS="$glib_save_LDFLAGS"
2231         ])
2232     if test "$glib_cv_pcre_has_unicode" = "no"; then
2233       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2234     fi
2235     AC_SUBST(PCRE_CFLAGS)
2236     AC_SUBST(PCRE_LIBS)
2237     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2238     PCRE_REQUIRES=libpcre
2239     AC_SUBST(PCRE_REQUIRES)
2240   else
2241     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2242     if test x"$GCC" = xyes; then
2243       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2244       save_CFLAGS="$CFLAGS"
2245       CFLAGS="$CFLAGS -Wno-pointer-sign"
2246       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2247                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2248       CFLAGS="$save_CFLAGS"
2249     fi
2250   fi
2251   AC_SUBST(PCRE_WARN_CFLAGS)
2252 else
2253   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2254 fi
2255
2256 dnl **********************
2257 dnl *** Win32 API libs ***
2258 dnl **********************
2259
2260 case $host in
2261   *-*-cygwin*)
2262         G_LIBS_EXTRA="-luser32 -lkernel32"
2263     ;;
2264   *-*-mingw*)
2265         G_LIBS_EXTRA="-lws2_32 -lole32"
2266     ;;
2267   *)
2268         G_LIBS_EXTRA=""
2269     ;;
2270 esac
2271 AC_SUBST(G_LIBS_EXTRA)
2272
2273 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2274 dnl since we need it for g_iconv()
2275
2276 AC_MSG_CHECKING([for EILSEQ])
2277 AC_TRY_COMPILE([
2278 #include <errno.h>
2279 ],
2280 [
2281 int error = EILSEQ;
2282 ], have_eilseq=yes, have_eilseq=no);
2283 AC_MSG_RESULT($have_eilseq)
2284
2285 dnl ******************************************************************
2286 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2287 dnl ******************************************************************
2288
2289 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2290
2291 if test $cross_compiling = yes; then
2292   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2293   if test x$GLIB_GENMARSHAL = xno; then
2294     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2295   fi
2296 fi
2297
2298 dnl **************************
2299 dnl *** Checks for gtk-doc ***
2300 dnl **************************
2301
2302 GTK_DOC_CHECK([1.8])
2303
2304 AC_ARG_ENABLE(man,
2305               [AC_HELP_STRING([--enable-man],
2306                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2307               enable_man=no)
2308
2309 if test "${enable_man}" != no; then
2310 dnl
2311 dnl Check for xsltproc
2312 dnl
2313 AC_PATH_PROG([XSLTPROC], [xsltproc])
2314   if test -z "$XSLTPROC"; then
2315     enable_man=no
2316   fi
2317
2318   dnl check for DocBook DTD and stylesheets in the local catalog.
2319   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2320      [DocBook XML DTD V4.1.2],,enable_man=no)
2321   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2322      [DocBook XSL Stylesheets],,enable_man=no)
2323 fi
2324
2325 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2326
2327 dnl ******************************
2328 dnl *** output the whole stuff ***
2329 dnl ******************************
2330
2331 dnl this section will only be run if config.status is invoked with no
2332 dnl arguments, or with "glibconfig.h" as an argument.
2333 AC_CONFIG_COMMANDS([glibconfig.h],
2334 [
2335         outfile=glibconfig.h-tmp
2336         cat > $outfile <<\_______EOF
2337 /* glibconfig.h
2338  *
2339  * This is a generated file.  Please modify 'configure.in'
2340  */
2341
2342 #ifndef __G_LIBCONFIG_H__
2343 #define __G_LIBCONFIG_H__
2344
2345 #include <glib/gmacros.h>
2346
2347 _______EOF
2348
2349         if test x$glib_limits_h = xyes; then
2350           echo '#include <limits.h>' >> $outfile
2351         fi
2352         if test x$glib_float_h = xyes; then
2353           echo '#include <float.h>' >> $outfile
2354         fi
2355         if test x$glib_values_h = xyes; then
2356           echo '#include <values.h>' >> $outfile
2357         fi
2358         if test "$glib_header_alloca_h" = "yes"; then
2359           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2360         fi
2361         if test x$glib_sys_poll_h = xyes; then
2362           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2363         fi
2364
2365         cat >> $outfile <<_______EOF
2366
2367 G_BEGIN_DECLS
2368
2369 #define G_MINFLOAT      $glib_mf
2370 #define G_MAXFLOAT      $glib_Mf
2371 #define G_MINDOUBLE     $glib_md
2372 #define G_MAXDOUBLE     $glib_Md
2373 #define G_MINSHORT      $glib_ms
2374 #define G_MAXSHORT      $glib_Ms
2375 #define G_MAXUSHORT     $glib_Mus
2376 #define G_MININT        $glib_mi
2377 #define G_MAXINT        $glib_Mi
2378 #define G_MAXUINT       $glib_Mui
2379 #define G_MINLONG       $glib_ml
2380 #define G_MAXLONG       $glib_Ml
2381 #define G_MAXULONG      $glib_Mul
2382
2383 _______EOF
2384
2385
2386         ### this should always be true in a modern C/C++ compiler
2387         cat >>$outfile <<_______EOF
2388 typedef signed char gint8;
2389 typedef unsigned char guint8;
2390 _______EOF
2391
2392
2393         if test -n "$gint16"; then
2394           cat >>$outfile <<_______EOF
2395 typedef signed $gint16 gint16;
2396 typedef unsigned $gint16 guint16;
2397 #define G_GINT16_MODIFIER $gint16_modifier
2398 #define G_GINT16_FORMAT $gint16_format
2399 #define G_GUINT16_FORMAT $guint16_format
2400 _______EOF
2401         fi
2402
2403
2404         if test -n "$gint32"; then
2405           cat >>$outfile <<_______EOF
2406 typedef signed $gint32 gint32;
2407 typedef unsigned $gint32 guint32;
2408 #define G_GINT32_MODIFIER $gint32_modifier
2409 #define G_GINT32_FORMAT $gint32_format
2410 #define G_GUINT32_FORMAT $guint32_format
2411 _______EOF
2412         fi
2413
2414         cat >>$outfile <<_______EOF
2415 #define G_HAVE_GINT64 1          /* deprecated, always true */
2416
2417 ${glib_extension}typedef signed $gint64 gint64;
2418 ${glib_extension}typedef unsigned $gint64 guint64;
2419
2420 #define G_GINT64_CONSTANT(val)  $gint64_constant
2421 #define G_GUINT64_CONSTANT(val) $guint64_constant
2422 _______EOF
2423
2424         if test x$gint64_format != x ; then
2425           cat >>$outfile <<_______EOF
2426 #define G_GINT64_MODIFIER $gint64_modifier
2427 #define G_GINT64_FORMAT $gint64_format
2428 #define G_GUINT64_FORMAT $guint64_format
2429 _______EOF
2430         else
2431           cat >>$outfile <<_______EOF
2432 #undef G_GINT64_MODIFIER
2433 #undef G_GINT64_FORMAT
2434 #undef G_GUINT64_FORMAT
2435 _______EOF
2436         fi
2437
2438         cat >>$outfile <<_______EOF
2439
2440 #define GLIB_SIZEOF_VOID_P $glib_void_p
2441 #define GLIB_SIZEOF_LONG   $glib_long
2442 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2443
2444 _______EOF
2445
2446         cat >>$outfile <<_______EOF
2447 typedef signed $glib_size_type_define gssize;
2448 typedef unsigned $glib_size_type_define gsize;
2449 #define G_GSIZE_MODIFIER $gsize_modifier
2450 #define G_GSSIZE_FORMAT $gssize_format
2451 #define G_GSIZE_FORMAT $gsize_format
2452
2453 #define G_MAXSIZE       G_MAXU$glib_msize_type
2454 #define G_MINSSIZE      G_MIN$glib_msize_type
2455 #define G_MAXSSIZE      G_MAX$glib_msize_type
2456
2457 typedef gint64 goffset;
2458 #define G_MINOFFSET     G_MININT64
2459 #define G_MAXOFFSET     G_MAXINT64
2460
2461 _______EOF
2462
2463         if test -z "$glib_unknown_void_p"; then
2464           cat >>$outfile <<_______EOF
2465
2466 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2467 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2468
2469 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2470 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2471 _______EOF
2472         else
2473           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2474         fi
2475
2476
2477
2478         cat >>$outfile <<_______EOF
2479 $glib_atexit
2480 $glib_memmove
2481 $glib_defines
2482 $glib_os
2483
2484 $glib_vacopy
2485
2486 #ifdef  __cplusplus
2487 #define G_HAVE_INLINE   1
2488 #else   /* !__cplusplus */
2489 $glib_inline
2490 #endif  /* !__cplusplus */
2491
2492 #ifdef  __cplusplus
2493 #define G_CAN_INLINE    1
2494 _______EOF
2495
2496         if test x$g_can_inline = xyes ; then
2497                 cat >>$outfile <<_______EOF
2498 #else   /* !__cplusplus */
2499 #define G_CAN_INLINE    1
2500 _______EOF
2501         fi
2502
2503         cat >>$outfile <<_______EOF
2504 #endif
2505
2506 _______EOF
2507
2508         if test x$g_have_iso_c_varargs = xyes ; then
2509                 cat >>$outfile <<_______EOF
2510 #ifndef __cplusplus
2511 # define G_HAVE_ISO_VARARGS 1
2512 #endif
2513 _______EOF
2514         fi
2515         if test x$g_have_iso_cxx_varargs = xyes ; then
2516                 cat >>$outfile <<_______EOF
2517 #ifdef __cplusplus
2518 # define G_HAVE_ISO_VARARGS 1
2519 #endif
2520 _______EOF
2521         fi
2522         if test x$g_have_gnuc_varargs = xyes ; then
2523                 cat >>$outfile <<_______EOF
2524
2525 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2526  * is passed ISO vararg support is turned off, and there is no work
2527  * around to turn it on, so we unconditionally turn it off.
2528  */
2529 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2530 #  undef G_HAVE_ISO_VARARGS
2531 #endif
2532
2533 #define G_HAVE_GNUC_VARARGS 1
2534 _______EOF
2535         fi
2536
2537         case x$g_stack_grows in
2538         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2539         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2540         esac
2541
2542
2543         echo >>$outfile
2544         if test x$g_have_eilseq = xno; then
2545                 cat >>$outfile <<_______EOF
2546 #ifndef EILSEQ
2547 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2548  * The correspondence between this and the corresponding definition
2549  * in libiconv is essential.
2550  */
2551 #  define EILSEQ ENOENT
2552 #endif
2553 _______EOF
2554
2555         fi
2556
2557         if test x$g_have_gnuc_visibility = xyes; then
2558                 cat >>$outfile <<_______EOF
2559 #define G_HAVE_GNUC_VISIBILITY 1
2560 _______EOF
2561         fi
2562                 cat >>$outfile <<_______EOF
2563 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2564 #define G_GNUC_INTERNAL __hidden
2565 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2566 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2567 #else
2568 #define G_GNUC_INTERNAL
2569 #endif
2570 _______EOF
2571
2572
2573         echo >>$outfile
2574         if test x$g_mutex_has_default = xyes; then
2575                 cat >>$outfile <<_______EOF
2576 $g_enable_threads_def G_THREADS_ENABLED
2577 #define G_THREADS_IMPL_$g_threads_impl_def
2578 typedef struct _GStaticMutex GStaticMutex;
2579 struct _GStaticMutex
2580 {
2581   struct _GMutex *runtime_mutex;
2582   union {
2583     char   pad[[$g_mutex_sizeof]];
2584     double dummy_double;
2585     void  *dummy_pointer;
2586     long   dummy_long;
2587   } static_mutex;
2588 };
2589 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2590 #define g_static_mutex_get_mutex(mutex) \\
2591   (g_thread_use_default_impl ? ((GMutex*) ((mutex)->static_mutex.pad)) : \\
2592    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2593 _______EOF
2594         else
2595                 cat >>$outfile <<_______EOF
2596 $g_enable_threads_def G_THREADS_ENABLED
2597 #define G_THREADS_IMPL_$g_threads_impl_def
2598 typedef struct _GMutex* GStaticMutex;
2599 #define G_STATIC_MUTEX_INIT NULL
2600 #define g_static_mutex_get_mutex(mutex) \\
2601   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2602 _______EOF
2603         fi
2604
2605         cat >>$outfile <<_______EOF
2606 /* This represents a system thread as used by the implementation. An
2607  * alien implementaion, as loaded by g_thread_init can only count on
2608  * "sizeof (gpointer)" bytes to store their info. We however need more
2609  * for some of our native implementations. */
2610 typedef union _GSystemThread GSystemThread;
2611 union _GSystemThread
2612 {
2613   char   data[[$g_system_thread_sizeof]];
2614   double dummy_double;
2615   void  *dummy_pointer;
2616   long   dummy_long;
2617 };
2618 _______EOF
2619         if test x"$g_memory_barrier_needed" != xno; then
2620           echo >>$outfile
2621           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2622         fi
2623
2624         echo >>$outfile
2625         g_bit_sizes="16 32 64"
2626         for bits in $g_bit_sizes; do
2627           cat >>$outfile <<_______EOF
2628 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2629 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2630 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2631 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2632 _______EOF
2633         done
2634
2635         cat >>$outfile <<_______EOF
2636 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2637 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2638 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2639 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2640 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2641 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2642 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2643 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2644 #define G_BYTE_ORDER $g_byte_order
2645
2646 #define GLIB_SYSDEF_POLLIN =$g_pollin
2647 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2648 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2649 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2650 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2651 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2652
2653 #define G_MODULE_SUFFIX "$g_module_suffix"
2654
2655 typedef $g_pid_type GPid;
2656
2657 G_END_DECLS
2658
2659 #endif /* GLIBCONFIG_H */
2660 _______EOF
2661
2662
2663         if cmp -s $outfile glibconfig.h; then
2664           AC_MSG_NOTICE([glibconfig.h is unchanged])
2665           rm -f $outfile
2666         else
2667           mv $outfile glibconfig.h
2668         fi
2669 ],[
2670
2671 # Note that if two cases are the same, case goes with the first one.
2672 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2673 # on variable expansion in case labels.  Look at the generated config.status
2674 # for a hint.
2675
2676 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2677   glib_header_alloca_h="$ac_cv_working_alloca_h"
2678 else
2679   glib_header_alloca_h="$ac_cv_header_alloca_h"
2680 fi
2681
2682 case xyes in
2683 x$ac_cv_header_float_h)
2684   glib_float_h=yes
2685   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2686   glib_md=DBL_MIN glib_Md=DBL_MAX
2687   ;;
2688 x$ac_cv_header_values_h)
2689   glib_values_h=yes
2690   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2691   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2692   ;;
2693 esac
2694
2695 case xyes in
2696 x$ac_cv_header_limits_h)
2697   glib_limits_h=yes
2698   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2699   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2700   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2701   ;;
2702 x$ac_cv_header_values_h)
2703   glib_values_h=yes
2704   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2705   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2706   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2707   ;;
2708 esac
2709
2710 if test x$ac_cv_header_sys_poll_h = xyes ; then
2711   glib_sys_poll_h=yes
2712 fi
2713
2714 case 2 in
2715 $ac_cv_sizeof_short)
2716   gint16=short
2717   gint16_modifier='"h"'
2718   gint16_format='"hi"'
2719   guint16_format='"hu"'
2720   ;;
2721 $ac_cv_sizeof_int)
2722   gint16=int
2723   gint16_modifier='""'
2724   gint16_format='"i"'
2725   guint16_format='"u"'
2726   ;;
2727 esac
2728 case 4 in
2729 $ac_cv_sizeof_short)
2730   gint32=short
2731   gint32_modifier='"h"'
2732   gint32_format='"hi"'
2733   guint32_format='"hu"'
2734   ;;
2735 $ac_cv_sizeof_int)
2736   gint32=int
2737   gint32_modifier='""'
2738   gint32_format='"i"'
2739   guint32_format='"u"'
2740   ;;
2741 $ac_cv_sizeof_long)
2742   gint32=long
2743   gint32_modifier='"l"'
2744   gint32_format='"li"'
2745   guint32_format='"lu"'
2746   ;;
2747 esac
2748 case 8 in
2749 $ac_cv_sizeof_int)
2750   gint64=int
2751   gint64_modifier='""'
2752   gint64_format='"i"'
2753   guint64_format='"u"'
2754   glib_extension=
2755   gint64_constant='(val)'
2756   guint64_constant='(val)'
2757   ;;
2758 $ac_cv_sizeof_long)
2759   gint64=long
2760   gint64_modifier='"l"'
2761   gint64_format='"li"'
2762   guint64_format='"lu"'
2763   glib_extension=
2764   gint64_constant='(val##L)'
2765   guint64_constant='(val##UL)'
2766   ;;
2767 $ac_cv_sizeof_long_long)
2768   gint64='long long'
2769   if test -n "$glib_cv_long_long_format"; then
2770     gint64_modifier='"'$glib_cv_long_long_format'"'
2771     gint64_format='"'$glib_cv_long_long_format'i"'
2772     guint64_format='"'$glib_cv_long_long_format'u"'
2773   fi
2774   glib_extension='G_GNUC_EXTENSION '
2775   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2776   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
2777   ;;
2778 $ac_cv_sizeof___int64)
2779   gint64='__int64'
2780   if test -n "$glib_cv_long_long_format"; then
2781     gint64_modifier='"'$glib_cv_long_long_format'"'
2782     gint64_format='"'$glib_cv_long_long_format'i"'
2783     guint64_format='"'$glib_cv_long_long_format'u"'
2784   fi
2785   glib_extension=
2786   gint64_constant='(val##i64)'
2787   guint64_constant='(val##ui64)'
2788   ;;
2789 esac
2790 glib_size_t=$ac_cv_sizeof_size_t
2791 glib_size_type_define=$glib_size_type
2792 glib_void_p=$ac_cv_sizeof_long
2793 glib_long=$ac_cv_sizeof_void_p
2794
2795 case $glib_size_type in
2796 short)
2797   gsize_modifier='"h"'
2798   gsize_format='"hu"'
2799   gssize_format='"hi"'
2800   glib_msize_type='SHRT'
2801   ;;
2802 int)
2803   gsize_modifier='""'
2804   gsize_format='"u"'
2805   gssize_format='"i"'
2806   glib_msize_type='INT'
2807   ;;
2808 long)
2809   gsize_modifier='"l"'
2810   gsize_format='"lu"'
2811   gssize_format='"li"'
2812   glib_msize_type='LONG'
2813   ;;
2814 esac
2815
2816 gintbits=`expr $ac_cv_sizeof_int \* 8`
2817 glongbits=`expr $ac_cv_sizeof_long \* 8`
2818
2819
2820 case $ac_cv_sizeof_void_p in
2821 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2822 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2823 *)                      glib_unknown_void_p=yes ;;
2824 esac
2825
2826
2827 case xyes in
2828 x$ac_cv_func_atexit)
2829   glib_atexit="
2830 #ifdef NeXT /* @#%@! NeXTStep */
2831 # define g_ATEXIT(proc) (!atexit (proc))
2832 #else
2833 # define g_ATEXIT(proc) (atexit (proc))
2834 #endif"
2835   ;;
2836 x$ac_cv_func_on_exit)
2837   glib_atexit="
2838 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2839   ;;
2840 esac
2841
2842 case xyes in
2843 x$ac_cv_func_memmove)
2844   glib_memmove='
2845 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
2846   ;;
2847 x$glib_cv_working_bcopy)
2848   glib_memmove="
2849 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2850 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2851   ;;
2852 *)
2853   glib_memmove="
2854 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2855  * so we have to roll our own copy routine. */
2856 void g_memmove (void* dest, const void * src, unsigned long len);"
2857   ;;
2858 esac
2859
2860 glib_defines="
2861 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2862 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2863 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2864 "
2865
2866 case xyes in
2867 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2868 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2869 *)                      glib_vacopy=''
2870 esac
2871
2872 if test x$glib_cv_va_val_copy = xno; then
2873   glib_vacopy="\$glib_vacopy
2874 #define G_VA_COPY_AS_ARRAY 1"
2875 fi
2876
2877 if test x$glib_cv_hasinline = xyes; then
2878     glib_inline='#define G_HAVE_INLINE 1'
2879 fi
2880 if test x$glib_cv_has__inline = xyes; then
2881     glib_inline="\$glib_inline
2882 #define G_HAVE___INLINE 1"
2883 fi
2884 if test x$glib_cv_has__inline__ = xyes; then
2885     glib_inline="\$glib_inline
2886 #define G_HAVE___INLINE__ 1"
2887 fi
2888
2889 g_have_gnuc_varargs=$g_have_gnuc_varargs
2890 g_have_iso_c_varargs=$g_have_iso_c_varargs
2891 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2892
2893 g_can_inline=$g_can_inline
2894 g_have_gnuc_visibility=$g_have_gnuc_visibility
2895 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
2896
2897 case xyes in
2898 x$ac_cv_c_bigendian)
2899   g_byte_order=G_BIG_ENDIAN
2900   g_bs_native=BE
2901   g_bs_alien=LE
2902   ;;
2903 *)
2904   g_byte_order=G_LITTLE_ENDIAN
2905   g_bs_native=LE
2906   g_bs_alien=BE
2907   ;;
2908 esac
2909
2910 g_pollin=$glib_cv_value_POLLIN
2911 g_pollout=$glib_cv_value_POLLOUT
2912 g_pollpri=$glib_cv_value_POLLPRI
2913 g_pollhup=$glib_cv_value_POLLHUP
2914 g_pollerr=$glib_cv_value_POLLERR
2915 g_pollnval=$glib_cv_value_POLLNVAL
2916
2917 g_stack_grows=$glib_cv_stack_grows
2918
2919 g_have_eilseq=$have_eilseq
2920
2921 case x$have_threads in
2922 xno)    g_enable_threads_def="#undef";;
2923 *)      g_enable_threads_def="#define";;
2924 esac
2925
2926 g_threads_impl_def=$g_threads_impl
2927
2928 g_mutex_has_default="$mutex_has_default"
2929 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2930 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2931 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2932
2933 g_memory_barrier_needed="$glib_memory_barrier_needed"
2934
2935 g_module_suffix="$glib_gmodule_suffix"
2936
2937 g_pid_type="$glib_pid_type"
2938 case $host in
2939   *-*-beos*)
2940     glib_os="#define G_OS_BEOS"
2941     ;;
2942   *-*-cygwin*)
2943     glib_os="#define G_OS_UNIX
2944 #define G_PLATFORM_WIN32
2945 #define G_WITH_CYGWIN"
2946     ;;
2947   *-*-mingw*)
2948     glib_os="#define G_OS_WIN32
2949 #define G_PLATFORM_WIN32"
2950     ;;
2951   *)
2952     glib_os="#define G_OS_UNIX"
2953     ;;
2954 esac
2955 ])
2956
2957 AC_CONFIG_FILES([
2958 glib-2.0.pc
2959 glib-2.0-uninstalled.pc
2960 gmodule-2.0.pc
2961 gmodule-export-2.0.pc
2962 gmodule-no-export-2.0.pc
2963 gmodule-2.0-uninstalled.pc
2964 gmodule-no-export-2.0-uninstalled.pc
2965 gthread-2.0.pc
2966 gthread-2.0-uninstalled.pc
2967 gobject-2.0.pc
2968 gobject-2.0-uninstalled.pc
2969 glib-zip
2970 glib-gettextize
2971 Makefile
2972 build/Makefile
2973 build/win32/Makefile
2974 build/win32/dirent/Makefile
2975 build/win32/vs8/Makefile
2976 glib/Makefile
2977 glib/libcharset/Makefile
2978 glib/gnulib/Makefile
2979 glib/pcre/Makefile
2980 glib/update-pcre/Makefile
2981 glib/tests/Makefile
2982 gmodule/Makefile
2983 gmodule/gmoduleconf.h
2984 gobject/Makefile
2985 gobject/glib-mkenums
2986 gthread/Makefile
2987 po/Makefile.in
2988 docs/Makefile
2989 docs/reference/Makefile
2990 docs/reference/glib/Makefile
2991 docs/reference/glib/version.xml
2992 docs/reference/gobject/Makefile
2993 docs/reference/gobject/version.xml
2994 tests/Makefile
2995 tests/gobject/Makefile
2996 tests/refcount/Makefile
2997 m4macros/Makefile
2998 ])
2999
3000 AC_CONFIG_COMMANDS([chmod-scripts],
3001 [chmod 0755 glib-zip
3002 chmod 0755 glib-gettextize
3003 chmod 0755 gobject/glib-mkenums])
3004
3005 # we want to invoke this macro solely so that the config.status script
3006 # and automake generated makefiles know about these generated files.
3007 # They are only needed to distcheck the package
3008 if false; then
3009   AC_CONFIG_FILES([
3010     INSTALL
3011     README
3012     config.h.win32
3013     glibconfig.h.win32
3014     glib/makefile.msc
3015     glib/glib.rc
3016     gmodule/makefile.msc
3017     gmodule/gmodule.rc
3018     gobject/makefile.msc
3019     gobject/gobject.rc
3020     gthread/makefile.msc
3021     gthread/gthread.rc
3022     tests/makefile.msc
3023   ])
3024 fi
3025
3026 AC_OUTPUT