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