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