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