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