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