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/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" = xposix \
1432                                 || test "x$want_threads" = xdce; then
1433         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1434         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1435         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1436         glib_save_CPPFLAGS="$CPPFLAGS"
1437         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1438         if test "x$have_threads" = xno; then
1439                 AC_TRY_COMPILE([#include <pthread.h>],
1440                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1441                         have_threads=posix)
1442         fi
1443         if test "x$have_threads" = xno; then
1444                 AC_TRY_COMPILE([#include <pthread.h>],
1445                         [pthread_mutex_t m;
1446                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1447                         have_threads=dce)
1448         fi
1449         # Tru64Unix requires -pthread to find pthread.h. See #103020
1450         CPPFLAGS="$CPPFLAGS -pthread"
1451         if test "x$have_threads" = xno; then
1452         AC_TRY_COMPILE([#include <pthread.h>],
1453                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1454                        have_threads=posix)
1455         fi
1456         CPPFLAGS="$glib_save_CPPFLAGS"
1457 fi
1458 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1459         case $host in
1460                 *-*-mingw*)
1461                 have_threads=win32
1462                 ;;
1463         esac
1464 fi
1465 if test "x$want_threads" = xnone; then
1466         have_threads=none
1467 fi
1468
1469 AC_MSG_CHECKING(for thread implementation)
1470
1471 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1472         AC_MSG_RESULT(none available)
1473         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1474 else
1475         AC_MSG_RESULT($have_threads)
1476 fi
1477
1478
1479 dnl determination of G_THREAD_CFLAGS
1480 dnl ********************************
1481
1482 G_THREAD_LIBS=
1483 G_THREAD_LIBS_EXTRA=
1484 G_THREAD_CFLAGS=
1485
1486 dnl
1487 dnl Test program for basic POSIX threads functionality
1488 dnl
1489 m4_define([glib_thread_test],[
1490 #include <pthread.h>
1491 int check_me = 0;
1492 void* func(void* data) {check_me = 42; return &check_me;}
1493 int main()
1494  { pthread_t t;
1495    void *ret;
1496    pthread_create (&t, $1, func, 0);
1497    pthread_join (t, &ret);
1498    exit (check_me != 42 || ret != &check_me);
1499 }])
1500
1501 dnl
1502 dnl Test program for sched_get_priority_min()
1503 dnl
1504 m4_define([glib_sched_priority_test],[
1505 #include <sched.h>
1506 #include <errno.h>
1507 int main() {
1508     errno = 0;
1509     return sched_get_priority_min(SCHED_OTHER)==-1
1510            && errno != 0;
1511 }])
1512
1513 if test x"$have_threads" != xno; then
1514
1515   if test x"$have_threads" = xposix; then
1516     # First we test for posix, whether -pthread or -pthreads do the trick as
1517     # both CPPFLAG and LIBS.
1518     # One of them does for most gcc versions and some other platforms/compilers
1519     # too and could be considered as the canonical way to go.
1520     case $host in
1521       *-*-cygwin*)
1522          # skip cygwin -pthread or -pthreads test
1523          ;;
1524       *)
1525         for flag in pthread pthreads mt; do
1526           glib_save_CFLAGS="$CFLAGS"
1527           CFLAGS="$CFLAGS -$flag"
1528           AC_TRY_RUN(glib_thread_test(0),
1529                      glib_flag_works=yes,
1530                      glib_flag_works=no,
1531                      [AC_LINK_IFELSE(glib_thread_test(0),
1532                                      glib_flag_works=yes,
1533                                      glib_flag_works=no)])
1534           CFLAGS="$glib_save_CFLAGS"
1535           if test $glib_flag_works = yes ; then
1536              G_THREAD_CFLAGS=-$flag
1537              G_THREAD_LIBS=-$flag
1538           fi
1539         done
1540          ;;
1541     esac
1542   fi
1543
1544   if test x"$G_THREAD_CFLAGS" = x; then
1545
1546     # The canonical -pthread[s] does not work. Try something different.
1547
1548     case $host in
1549         *-aix*)
1550                 if test x"$GCC" = xyes; then
1551                         # GCC 3.0 and above needs -pthread.
1552                         # Should be coverd by the case above.
1553                         # GCC 2.x and below needs -mthreads
1554                         G_THREAD_CFLAGS="-mthreads"
1555                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1556                 else
1557                         # We are probably using the aix compiler. Normaly a
1558                         # program would have to be compiled with the _r variant
1559                         # of the corresponding compiler, but we as GLib cannot
1560                         # do that: but the good news is that for compiling the
1561                         # only difference is the added -D_THREAD_SAFE compile
1562                         # option. This is according to the "C for AIX User's
1563                         # Guide".
1564                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1565                 fi
1566                 ;;
1567         *-dg-dgux*)  # DG/UX
1568                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1569                 ;;
1570         *-osf*)
1571                 # So we are using dce threads. posix threads are already
1572                 # catched above.
1573                 G_THREAD_CFLAGS="-threads"
1574                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1575                 ;;
1576         *-sysv5uw7*) # UnixWare 7
1577                 # We are not using gcc with -pthread. Catched above.
1578                 G_THREAD_CFLAGS="-Kthread"
1579                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1580                 ;;
1581         *-mingw*)
1582                 # No flag needed when using MSVCRT.DLL
1583                 G_THREAD_CFLAGS=""
1584                 ;;
1585         *)
1586                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1587                 ;;
1588     esac
1589
1590   fi
1591
1592     # if we are not finding the localtime_r function, then we probably are
1593     # not using the proper multithread flag
1594
1595     glib_save_CPPFLAGS="$CPPFLAGS"
1596     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1597
1598     # First we test, whether localtime_r is declared in time.h
1599     # directly. Then we test whether a macro localtime_r exists, in
1600     # which case localtime_r in the test program is replaced and thus
1601     # if we still find localtime_r in the output, it is not defined as
1602     # a macro.
1603
1604     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1605       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1606                                                            localtime_r(a,b)],
1607                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1608
1609     CPPFLAGS="$glib_save_CPPFLAGS"
1610
1611     AC_MSG_CHECKING(thread related cflags)
1612     AC_MSG_RESULT($G_THREAD_CFLAGS)
1613     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1614 fi
1615
1616 dnl determination of G_THREAD_LIBS
1617 dnl ******************************
1618
1619 mutex_has_default=no
1620 case $have_threads in
1621         posix|dce)
1622           glib_save_CPPFLAGS="$CPPFLAGS"
1623           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1624           if test x"$G_THREAD_LIBS" = x; then
1625             case $host in
1626               *-aix*)
1627                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1628                 # probably using the aix compiler.
1629                 AC_MSG_WARN($AIX_COMPILE_INFO)
1630                 ;;
1631               *)
1632                 G_THREAD_LIBS=error
1633                 glib_save_LIBS="$LIBS"
1634                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1635                         if test x"$thread_lib" = x; then
1636                                 add_thread_lib=""
1637                                 IN=""
1638                         else
1639                                 add_thread_lib="-l$thread_lib"
1640                                 IN=" in -l$thread_lib"
1641                         fi
1642                         if test x"$have_threads" = xposix; then
1643                                 defattr=0
1644                         else
1645                                 defattr=pthread_attr_default
1646                         fi
1647
1648                         LIBS="$add_thread_lib $glib_save_LIBS"
1649
1650                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1651                         AC_TRY_RUN(glib_thread_test($defattr),
1652                                    glib_result=yes,
1653                                    glib_result=no,
1654                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
1655                                                    glib_result=yes,
1656                                                    glib_result=no)])
1657                         AC_MSG_RESULT($glib_result)
1658
1659                         if test "$glib_result" = "yes" ; then
1660                           G_THREAD_LIBS="$add_thread_lib"
1661                           break
1662                         fi
1663                 done
1664                 if test "x$G_THREAD_LIBS" = xerror; then
1665                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1666                 fi
1667                 LIBS="$glib_save_LIBS"
1668                 ;;
1669             esac
1670           fi
1671
1672           glib_save_LIBS="$LIBS"
1673           for thread_lib in "" rt rte; do
1674             if test x"$thread_lib" = x; then
1675               add_thread_lib=""
1676               IN=""
1677             else
1678               add_thread_lib="-l$thread_lib"
1679               IN=" in -l$thread_lib"
1680             fi
1681             LIBS="$add_thread_lib $glib_save_LIBS"
1682
1683             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1684             AC_TRY_RUN(glib_sched_priority_test,
1685                        glib_result=yes,
1686                        glib_result=no,
1687                        [AC_LINK_IFELSE(glib_sched_priority_test,
1688                                        glib_result=yes,
1689                                        glib_result=no)])
1690             AC_MSG_RESULT($glib_result)
1691
1692             if test "$glib_result" = "yes" ; then
1693                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1694                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1695                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1696                break
1697             fi
1698           done
1699           LIBS="$glib_save_LIBS"
1700           mutex_has_default=yes
1701           mutex_default_type='pthread_mutex_t'
1702           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1703           mutex_header_file='pthread.h'
1704           if test "x$have_threads" = "xposix"; then
1705             g_threads_impl="POSIX"
1706           else
1707             g_threads_impl="DCE"
1708             have_threads="posix"
1709           fi
1710           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1711           CPPFLAGS="$glib_save_CPPFLAGS"
1712           ;;
1713         win32)
1714            g_threads_impl="WIN32"
1715            ;;
1716         none|no)
1717            g_threads_impl="NONE"
1718            ;;
1719         *)
1720            g_threads_impl="NONE"
1721            G_THREAD_LIBS=error
1722            ;;
1723 esac
1724
1725 if test "x$G_THREAD_LIBS" = xerror; then
1726         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1727 fi
1728
1729 case $host in
1730   *-*-beos*)
1731     G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
1732     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1733     ;;
1734   *)
1735     ;;
1736 esac
1737
1738 AC_MSG_CHECKING(thread related libraries)
1739 AC_MSG_RESULT($G_THREAD_LIBS)
1740
1741 dnl check for mt safe function variants and some posix functions
1742 dnl ************************************************************
1743
1744 if test x"$have_threads" != xno; then
1745         glib_save_LIBS="$LIBS"
1746         # we are not doing the following for now, as this might require glib
1747         # to always be linked with the thread libs on some platforms.
1748         # LIBS="$LIBS $G_THREAD_LIBS"
1749         AC_CHECK_FUNCS(localtime_r)
1750         if test "$ac_cv_header_pwd_h" = "yes"; then
1751                 AC_CACHE_CHECK([for posix getpwuid_r],
1752                         ac_cv_func_posix_getpwuid_r,
1753                         [AC_TRY_RUN([
1754 #include <errno.h>
1755 #include <pwd.h>
1756 int main () {
1757     char buffer[10000];
1758     struct passwd pwd, *pwptr = &pwd;
1759     int error;
1760     errno = 0;
1761     error = getpwuid_r (0, &pwd, buffer,
1762                         sizeof (buffer), &pwptr);
1763    return (error < 0 && errno == ENOSYS)
1764            || error == ENOSYS;
1765 }                               ],
1766                                 [ac_cv_func_posix_getpwuid_r=yes],
1767                                 [ac_cv_func_posix_getpwuid_r=no])])
1768                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1769                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1770                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1771                                 [Have POSIX function getpwuid_r])
1772                 else
1773                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1774                                 ac_cv_func_nonposix_getpwuid_r,
1775                                 [AC_TRY_LINK([#include <pwd.h>],
1776                                         [char buffer[10000];
1777                                         struct passwd pwd;
1778                                         getpwuid_r (0, &pwd, buffer,
1779                                                         sizeof (buffer));],
1780                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1781                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1782                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1783                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1784                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1785                                         [Have non-POSIX function getpwuid_r])
1786                         fi
1787                 fi
1788         fi
1789         LIBS="$G_THREAD_LIBS $LIBS"
1790         if test x"$have_threads" = xposix; then
1791                 glib_save_CPPFLAGS="$CPPFLAGS"
1792                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1793                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1794                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1795                 # This is not AC_CHECK_FUNC to also work with function
1796                 # name mangling in header files.
1797                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1798                 AC_TRY_LINK([#include <pthread.h>],
1799                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1800                         [AC_MSG_RESULT(yes)
1801                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1802                                   [Have function pthread_attr_setstacksize])],
1803                         [AC_MSG_RESULT(no)])
1804                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1805                 if test x"$posix_priority_min" = x; then
1806                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1807                                 PX_PRIO_MIN],,[
1808                                 posix_priority_min=PX_PRIO_MIN
1809                                 posix_priority_max=PX_PRIO_MAX])
1810                 fi
1811                 if test x"$posix_priority_min" = x; then
1812                         # AIX
1813                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1814                                 PTHREAD_PRIO_MIN],,[
1815                                 posix_priority_min=PTHREAD_PRIO_MIN
1816                                 posix_priority_max=PTHREAD_PRIO_MAX])
1817                 fi
1818                 if test x"$posix_priority_min" = x; then
1819                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1820                                 PRI_OTHER_MIN],,[
1821                                 posix_priority_min=PRI_OTHER_MIN
1822                                 posix_priority_max=PRI_OTHER_MAX])
1823                 fi
1824                 if test x"$posix_priority_min" = x; then
1825                         AC_MSG_RESULT(none found)
1826                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1827                         posix_priority_min=-1
1828                         posix_priority_max=-1
1829                 else
1830                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1831                         AC_MSG_CHECKING(for pthread_setschedparam)
1832                         AC_TRY_LINK([#include <pthread.h>],
1833                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
1834                           [AC_MSG_RESULT(yes)
1835                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1836                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1837                           [AC_MSG_RESULT(no)
1838                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1839                 fi
1840                 posix_yield_func=none
1841                 AC_MSG_CHECKING(for posix yield function)
1842                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1843                                                         thr_yield; do
1844                         AC_TRY_LINK([#include <pthread.h>],
1845                                 [$yield_func()],
1846                                 [posix_yield_func="$yield_func"
1847                                 break])
1848                 done
1849                 if test x"$posix_yield_func" = xnone; then
1850                         AC_MSG_RESULT(none found)
1851                         AC_MSG_WARN($POSIX_NO_YIELD)
1852                         posix_yield_func="g_usleep(1000)"
1853                 else
1854                         AC_MSG_RESULT($posix_yield_func)
1855                         posix_yield_func="$posix_yield_func()"
1856                 fi
1857                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1858                 CPPFLAGS="$glib_save_CPPFLAGS"
1859
1860         elif test x"$have_threads" = xwin32; then
1861                 # It's a pointer to a private struct
1862                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1863         fi
1864
1865         LIBS="$glib_save_LIBS"
1866
1867         # now spit out all the warnings.
1868         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1869            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1870                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1871         fi
1872         if test "$ac_cv_func_localtime_r" != "yes"; then
1873                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1874         fi
1875 fi
1876
1877 if test x"$glib_cv_sizeof_system_thread" = x; then
1878    # use a pointer as a fallback.
1879    GLIB_SIZEOF(,void *, system_thread)
1880 fi
1881
1882 #
1883 # Hack to deal with:
1884 #
1885 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
1886 #     building shared libraries with linux.
1887 #
1888 case $host in
1889   *-*-linux*)
1890     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1891     ;;
1892   *)
1893     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
1894     ;;
1895 esac
1896
1897 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1898                    [Source file containing theread implementation])
1899 AC_SUBST(G_THREAD_CFLAGS)
1900 AC_SUBST(G_THREAD_LIBS)
1901 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1902 AC_SUBST(G_THREAD_LIBS_EXTRA)
1903
1904 dnl **********************************************
1905 dnl *** GDefaultMutex setup and initialization ***
1906 dnl **********************************************
1907 dnl
1908 dnl if mutex_has_default = yes, we also got
1909 dnl mutex_default_type, mutex_default_init and mutex_header_file
1910 if test $mutex_has_default = yes ; then
1911         glib_save_CPPFLAGS="$CPPFLAGS"
1912         glib_save_LIBS="$LIBS"
1913         LIBS="$G_THREAD_LIBS $LIBS"
1914         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1915         GLIB_SIZEOF([#include <$mutex_header_file>],
1916                     $mutex_default_type,
1917                     gmutex)
1918         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1919                            $mutex_default_type,
1920                            gmutex,
1921                            $glib_cv_sizeof_gmutex,
1922                            $mutex_default_init)
1923         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1924                 mutex_has_default=no
1925         fi
1926         CPPFLAGS="$glib_save_CPPFLAGS"
1927         LIBS="$glib_save_LIBS"
1928 fi
1929
1930 dnl ********************************
1931 dnl *** g_atomic_* tests for gcc ***
1932 dnl ********************************
1933
1934 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
1935
1936 if test x"$GCC" = xyes; then
1937   case $host_cpu in
1938     i386)
1939       AC_MSG_RESULT([none])
1940       glib_memory_barrier_needed=no
1941       ;;
1942     i?86)
1943       AC_MSG_RESULT([i486])
1944       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
1945                          [i486 atomic implementation])
1946       glib_memory_barrier_needed=no
1947       ;;
1948     sparc*)
1949       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
1950                 when you are using a sparc with v9 instruction set (most
1951                 sparcs nowadays). This will make the code for atomic
1952                 operations much faster. The resulting code will not run
1953                 on very old sparcs though."
1954
1955       AC_LINK_IFELSE([[
1956         main ()
1957         {
1958           int tmp1, tmp2, tmp3;
1959           __asm__ __volatile__("casx [%2], %0, %1"
1960                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
1961         }]],
1962         AC_MSG_RESULT([sparcv9])
1963         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
1964                            [sparcv9 atomic implementation]),
1965         AC_MSG_RESULT([no])
1966         AC_MSG_WARN([[$SPARCV9_WARNING]]))
1967       glib_memory_barrier_needed=yes
1968       ;;
1969     alpha*)
1970       AC_MSG_RESULT([alpha])
1971       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
1972                          [alpha atomic implementation])
1973       glib_memory_barrier_needed=yes
1974       ;;
1975     x86_64)
1976       AC_MSG_RESULT([x86_64])
1977       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
1978                          [x86_64 atomic implementation])
1979       glib_memory_barrier_needed=no
1980      ;;
1981     powerpc*)
1982       AC_MSG_RESULT([powerpc])
1983       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
1984                          [powerpc atomic implementation])
1985       glib_memory_barrier_needed=yes
1986       ;;
1987     ia64)
1988       AC_MSG_RESULT([ia64])
1989       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
1990                          [ia64 atomic implementation])
1991       glib_memory_barrier_needed=yes
1992       ;;
1993     s390|s390x)
1994       AC_MSG_RESULT([s390])
1995       AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
1996                          [s390 atomic implementation])
1997       glib_memory_barrier_needed=no
1998       ;;
1999     *)
2000       AC_MSG_RESULT([none])
2001       glib_memory_barrier_needed=yes
2002       ;;
2003   esac
2004 fi
2005
2006 dnl ****************************************
2007 dnl *** GLib POLL* compatibility defines ***
2008 dnl ****************************************
2009
2010 glib_poll_includes=["
2011 #include <sys/types.h>
2012 #include <sys/poll.h>
2013 "]
2014
2015 if test $ac_cv_header_sys_types_h = yes &&
2016    test $ac_cv_header_sys_poll_h = yes ; then
2017   glib_failed=false
2018   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2019   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2020   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2021   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2022   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2023   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2024   if $glib_failed ; then
2025     AC_MSG_ERROR([Could not determine values for POLL* constants])
2026   fi
2027 else
2028   glib_cv_value_POLLIN=1
2029   glib_cv_value_POLLOUT=4
2030   glib_cv_value_POLLPRI=2
2031   glib_cv_value_POLLERR=8
2032   glib_cv_value_POLLHUP=16
2033   glib_cv_value_POLLNVAL=32
2034 fi
2035
2036 dnl **********************
2037 dnl *** Win32 API libs ***
2038 dnl **********************
2039
2040 case $host in
2041   *-*-cygwin*)
2042         G_LIBS_EXTRA="-luser32 -lkernel32"
2043     ;;
2044   *-*-mingw*)
2045         G_LIBS_EXTRA="-lws2_32 -lole32"
2046     ;;
2047   *)
2048         G_LIBS_EXTRA=""
2049     ;;
2050 esac
2051 AC_SUBST(G_LIBS_EXTRA)
2052
2053 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2054 dnl since we need it for g_iconv()
2055
2056 AC_MSG_CHECKING([for EILSEQ])
2057 AC_TRY_COMPILE([
2058 #include <errno.h>
2059 ],
2060 [
2061 int error = EILSEQ;
2062 ], have_eilseq=yes, have_eilseq=no);
2063 AC_MSG_RESULT($have_eilseq)
2064
2065 dnl ******************************************************************
2066 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2067 dnl ******************************************************************
2068
2069 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2070
2071 if test $cross_compiling = yes; then
2072   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2073   if test x$GLIB_GENMARSHAL = xno; then
2074     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2075   fi
2076 fi
2077
2078 dnl **************************
2079 dnl *** Checks for gtk-doc ***
2080 dnl **************************
2081
2082 GTK_DOC_CHECK([1.4])
2083
2084 AC_ARG_ENABLE(man,
2085               [AC_HELP_STRING([--enable-man],
2086                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2087               enable_man=no)
2088
2089 if test "${enable_man}" != no; then
2090 dnl
2091 dnl Check for xsltproc
2092 dnl
2093 AC_PATH_PROG([XSLTPROC], [xsltproc])
2094   if test -z "$XSLTPROC"; then
2095     enable_man=no
2096   fi
2097
2098   dnl check for DocBook DTD and stylesheets in the local catalog.
2099   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2100      [DocBook XML DTD V4.1.2],,enable_man=no)
2101   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2102      [DocBook XSL Stylesheets],,enable_man=no)
2103 fi
2104
2105 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2106
2107 dnl ******************************
2108 dnl *** output the whole stuff ***
2109 dnl ******************************
2110
2111 dnl this section will only be run if config.status is invoked with no
2112 dnl arguments, or with "glibconfig.h" as an argument.
2113 AC_CONFIG_COMMANDS([glibconfig.h],
2114 [
2115         outfile=glibconfig.h-tmp
2116         cat > $outfile <<\_______EOF
2117 /* glibconfig.h
2118  *
2119  * This is a generated file.  Please modify 'configure.in'
2120  */
2121
2122 #ifndef __G_LIBCONFIG_H__
2123 #define __G_LIBCONFIG_H__
2124
2125 #include <glib/gmacros.h>
2126
2127 _______EOF
2128
2129         if test x$glib_limits_h = xyes; then
2130           echo '#include <limits.h>' >> $outfile
2131         fi
2132         if test x$glib_float_h = xyes; then
2133           echo '#include <float.h>' >> $outfile
2134         fi
2135         if test x$glib_values_h = xyes; then
2136           echo '#include <values.h>' >> $outfile
2137         fi
2138         if test "$glib_header_alloca_h" = "yes"; then
2139           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2140         fi
2141         if test x$glib_sys_poll_h = xyes; then
2142           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2143         fi
2144
2145         cat >> $outfile <<_______EOF
2146
2147 G_BEGIN_DECLS
2148
2149 #define G_MINFLOAT      $glib_mf
2150 #define G_MAXFLOAT      $glib_Mf
2151 #define G_MINDOUBLE     $glib_md
2152 #define G_MAXDOUBLE     $glib_Md
2153 #define G_MINSHORT      $glib_ms
2154 #define G_MAXSHORT      $glib_Ms
2155 #define G_MAXUSHORT     $glib_Mus
2156 #define G_MININT        $glib_mi
2157 #define G_MAXINT        $glib_Mi
2158 #define G_MAXUINT       $glib_Mui
2159 #define G_MINLONG       $glib_ml
2160 #define G_MAXLONG       $glib_Ml
2161 #define G_MAXULONG      $glib_Mul
2162
2163 _______EOF
2164
2165
2166         ### this should always be true in a modern C/C++ compiler
2167         cat >>$outfile <<_______EOF
2168 typedef signed char gint8;
2169 typedef unsigned char guint8;
2170 _______EOF
2171
2172
2173         if test -n "$gint16"; then
2174           cat >>$outfile <<_______EOF
2175 typedef signed $gint16 gint16;
2176 typedef unsigned $gint16 guint16;
2177 #define G_GINT16_MODIFIER $gint16_modifier
2178 #define G_GINT16_FORMAT $gint16_format
2179 #define G_GUINT16_FORMAT $guint16_format
2180 _______EOF
2181         fi
2182
2183
2184         if test -n "$gint32"; then
2185           cat >>$outfile <<_______EOF
2186 typedef signed $gint32 gint32;
2187 typedef unsigned $gint32 guint32;
2188 #define G_GINT32_MODIFIER $gint32_modifier
2189 #define G_GINT32_FORMAT $gint32_format
2190 #define G_GUINT32_FORMAT $guint32_format
2191 _______EOF
2192         fi
2193
2194         cat >>$outfile <<_______EOF
2195 #define G_HAVE_GINT64 1          /* deprecated, always true */
2196
2197 ${glib_extension}typedef signed $gint64 gint64;
2198 ${glib_extension}typedef unsigned $gint64 guint64;
2199
2200 #define G_GINT64_CONSTANT(val)  $gint64_constant
2201 #define G_GUINT64_CONSTANT(val) $guint64_constant
2202 _______EOF
2203
2204         if test x$gint64_format != x ; then
2205           cat >>$outfile <<_______EOF
2206 #define G_GINT64_MODIFIER $gint64_modifier
2207 #define G_GINT64_FORMAT $gint64_format
2208 #define G_GUINT64_FORMAT $guint64_format
2209 _______EOF
2210         else
2211           cat >>$outfile <<_______EOF
2212 #undef G_GINT64_MODIFIER
2213 #undef G_GINT64_FORMAT
2214 #undef G_GUINT64_FORMAT
2215 _______EOF
2216         fi
2217
2218         cat >>$outfile <<_______EOF
2219
2220 #define GLIB_SIZEOF_VOID_P $glib_void_p
2221 #define GLIB_SIZEOF_LONG   $glib_long
2222 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2223
2224 _______EOF
2225
2226         cat >>$outfile <<_______EOF
2227 typedef signed $glib_size_type_define gssize;
2228 typedef unsigned $glib_size_type_define gsize;
2229 #define G_GSIZE_MODIFIER $gsize_modifier
2230 #define G_GSSIZE_FORMAT $gssize_format
2231 #define G_GSIZE_FORMAT $gsize_format
2232
2233 #define G_MAXSIZE       G_MAXU$glib_msize_type
2234 _______EOF
2235
2236         if test -z "$glib_unknown_void_p"; then
2237           cat >>$outfile <<_______EOF
2238
2239 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2240 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2241
2242 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2243 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2244 _______EOF
2245         else
2246           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2247         fi
2248
2249
2250
2251         cat >>$outfile <<_______EOF
2252 $glib_atexit
2253 $glib_memmove
2254 $glib_defines
2255 $glib_os
2256
2257 $glib_vacopy
2258
2259 #ifdef  __cplusplus
2260 #define G_HAVE_INLINE   1
2261 #else   /* !__cplusplus */
2262 $glib_inline
2263 #endif  /* !__cplusplus */
2264
2265 #ifdef  __cplusplus
2266 #define G_CAN_INLINE    1
2267 _______EOF
2268
2269         if test x$g_can_inline = xyes ; then
2270                 cat >>$outfile <<_______EOF
2271 #else   /* !__cplusplus */
2272 #define G_CAN_INLINE    1
2273 _______EOF
2274         fi
2275
2276         cat >>$outfile <<_______EOF
2277 #endif
2278
2279 _______EOF
2280
2281         if test x$g_have_iso_c_varargs = xyes ; then
2282                 cat >>$outfile <<_______EOF
2283 #ifndef __cplusplus
2284 # define G_HAVE_ISO_VARARGS 1
2285 #endif
2286 _______EOF
2287         fi
2288         if test x$g_have_iso_cxx_varargs = xyes ; then
2289                 cat >>$outfile <<_______EOF
2290 #ifdef __cplusplus
2291 # define G_HAVE_ISO_VARARGS 1
2292 #endif
2293 _______EOF
2294         fi
2295         if test x$g_have_gnuc_varargs = xyes ; then
2296                 cat >>$outfile <<_______EOF
2297
2298 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2299  * is passed ISO vararg support is turned off, and there is no work
2300  * around to turn it on, so we unconditionally turn it off.
2301  */
2302 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2303 #  undef G_HAVE_ISO_VARARGS
2304 #endif
2305
2306 #define G_HAVE_GNUC_VARARGS 1
2307 _______EOF
2308         fi
2309
2310         case x$g_stack_grows in
2311         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2312         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2313         esac
2314
2315
2316         echo >>$outfile
2317         if test x$g_have_eilseq = xno; then
2318                 cat >>$outfile <<_______EOF
2319 #ifndef EILSEQ
2320 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2321  * The correspondence between this and the corresponding definition
2322  * in libiconv is essential.
2323  */
2324 #  define EILSEQ ENOENT
2325 #endif
2326 _______EOF
2327
2328         fi
2329
2330         if test x$g_have_gnuc_visibility = xyes ; then
2331                 cat >>$outfile <<_______EOF
2332 #define G_HAVE_GNUC_VISIBILITY 1
2333 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2334 _______EOF
2335         else
2336                 cat >>$outfile <<_______EOF
2337 #define G_GNUC_INTERNAL
2338 _______EOF
2339         fi
2340
2341
2342         echo >>$outfile
2343         if test x$g_mutex_has_default = xyes; then
2344                 cat >>$outfile <<_______EOF
2345 $g_enable_threads_def G_THREADS_ENABLED
2346 #define G_THREADS_IMPL_$g_threads_impl_def
2347 typedef struct _GStaticMutex GStaticMutex;
2348 struct _GStaticMutex
2349 {
2350   struct _GMutex *runtime_mutex;
2351   union {
2352     char   pad[[$g_mutex_sizeof]];
2353     double dummy_double;
2354     void  *dummy_pointer;
2355     long   dummy_long;
2356   } static_mutex;
2357 };
2358 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2359 #define g_static_mutex_get_mutex(mutex) \\
2360   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \\
2361    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2362 _______EOF
2363         else
2364                 cat >>$outfile <<_______EOF
2365 $g_enable_threads_def G_THREADS_ENABLED
2366 #define G_THREADS_IMPL_$g_threads_impl_def
2367 typedef struct _GMutex* GStaticMutex;
2368 #define G_STATIC_MUTEX_INIT NULL
2369 #define g_static_mutex_get_mutex(mutex) \\
2370   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2371 _______EOF
2372         fi
2373
2374         cat >>$outfile <<_______EOF
2375 /* This represents a system thread as used by the implementation. An
2376  * alien implementaion, as loaded by g_thread_init can only count on
2377  * "sizeof (gpointer)" bytes to store their info. We however need more
2378  * for some of our native implementations. */
2379 typedef union _GSystemThread GSystemThread;
2380 union _GSystemThread
2381 {
2382   char   data[[$g_system_thread_sizeof]];
2383   double dummy_double;
2384   void  *dummy_pointer;
2385   long   dummy_long;
2386 };
2387 _______EOF
2388         if test x"$g_memory_barrier_needed" != xno; then
2389           echo >>$outfile
2390           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2391         fi
2392
2393         echo >>$outfile
2394         g_bit_sizes="16 32 64"
2395         for bits in $g_bit_sizes; do
2396           cat >>$outfile <<_______EOF
2397 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2398 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2399 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2400 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2401 _______EOF
2402         done
2403
2404         cat >>$outfile <<_______EOF
2405 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2406 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2407 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2408 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2409 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2410 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2411 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2412 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2413 #define G_BYTE_ORDER $g_byte_order
2414
2415 #define GLIB_SYSDEF_POLLIN =$g_pollin
2416 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2417 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2418 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2419 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2420 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2421
2422 #define G_MODULE_SUFFIX "$g_module_suffix"
2423
2424 typedef $g_pid_type GPid;
2425
2426 G_END_DECLS
2427
2428 #endif /* GLIBCONFIG_H */
2429 _______EOF
2430
2431
2432         if cmp -s $outfile glibconfig.h; then
2433           AC_MSG_NOTICE([glibconfig.h is unchanged])
2434           rm -f $outfile
2435         else
2436           mv $outfile glibconfig.h
2437         fi
2438 ],[
2439
2440 # Note that if two cases are the same, case goes with the first one.
2441 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2442 # on variable expansion in case labels.  Look at the generated config.status
2443 # for a hint.
2444
2445 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2446   glib_header_alloca_h="$ac_cv_working_alloca_h"
2447 else
2448   glib_header_alloca_h="$ac_cv_header_alloca_h"
2449 fi
2450
2451 case xyes in
2452 x$ac_cv_header_float_h)
2453   glib_float_h=yes
2454   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2455   glib_md=DBL_MIN glib_Md=DBL_MAX
2456   ;;
2457 x$ac_cv_header_values_h)
2458   glib_values_h=yes
2459   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2460   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2461   ;;
2462 esac
2463
2464 case xyes in
2465 x$ac_cv_header_limits_h)
2466   glib_limits_h=yes
2467   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2468   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2469   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2470   ;;
2471 x$ac_cv_header_values_h)
2472   glib_values_h=yes
2473   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2474   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2475   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2476   ;;
2477 esac
2478
2479 if test x$ac_cv_header_sys_poll_h = xyes ; then
2480   glib_sys_poll_h=yes
2481 fi
2482
2483 case 2 in
2484 $ac_cv_sizeof_short)
2485   gint16=short
2486   gint16_modifier='"h"'
2487   gint16_format='"hi"'
2488   guint16_format='"hu"'
2489   ;;
2490 $ac_cv_sizeof_int)
2491   gint16=int
2492   gint16_modifier='""'
2493   gint16_format='"i"'
2494   guint16_format='"u"'
2495   ;;
2496 esac
2497 case 4 in
2498 $ac_cv_sizeof_short)
2499   gint32=short
2500   gint32_modifier='"h"'
2501   gint32_format='"hi"'
2502   guint32_format='"hu"'
2503   ;;
2504 $ac_cv_sizeof_int)
2505   gint32=int
2506   gint32_modifier='""'
2507   gint32_format='"i"'
2508   guint32_format='"u"'
2509   ;;
2510 $ac_cv_sizeof_long)
2511   gint32=long
2512   gint32_modifier='"l"'
2513   gint32_format='"li"'
2514   guint32_format='"lu"'
2515   ;;
2516 esac
2517 case 8 in
2518 $ac_cv_sizeof_int)
2519   gint64=int
2520   gint64_modifier='""'
2521   gint64_format='"i"'
2522   guint64_format='"u"'
2523   glib_extension=
2524   gint64_constant='(val)'
2525   guint64_constant='(val)'
2526   ;;
2527 $ac_cv_sizeof_long)
2528   gint64=long
2529   gint64_modifier='"l"'
2530   gint64_format='"li"'
2531   guint64_format='"lu"'
2532   glib_extension=
2533   gint64_constant='(val##L)'
2534   guint64_constant='(val##UL)'
2535   ;;
2536 $ac_cv_sizeof_long_long)
2537   gint64='long long'
2538   if test -n "$glib_cv_long_long_format"; then
2539     gint64_modifier='"'$glib_cv_long_long_format'"'
2540     gint64_format='"'$glib_cv_long_long_format'i"'
2541     guint64_format='"'$glib_cv_long_long_format'u"'
2542   fi
2543   glib_extension='G_GNUC_EXTENSION '
2544   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2545   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
2546   ;;
2547 $ac_cv_sizeof___int64)
2548   gint64='__int64'
2549   if test -n "$glib_cv_long_long_format"; then
2550     gint64_modifier='"'$glib_cv_long_long_format'"'
2551     gint64_format='"'$glib_cv_long_long_format'i"'
2552     guint64_format='"'$glib_cv_long_long_format'u"'
2553   fi
2554   glib_extension=
2555   gint64_constant='(val##i64)'
2556   guint64_constant='(val##ui64)'
2557   ;;
2558 esac
2559 glib_size_t=$ac_cv_sizeof_size_t
2560 glib_size_type_define=$glib_size_type
2561 glib_void_p=$ac_cv_sizeof_long
2562 glib_long=$ac_cv_sizeof_void_p
2563
2564 case $glib_size_type in
2565 short)
2566   gsize_modifier='"h"'
2567   gsize_format='"hu"'
2568   gssize_format='"hi"'
2569   glib_msize_type='SHRT'
2570   ;;
2571 int)
2572   gsize_modifier='""'
2573   gsize_format='"u"'
2574   gssize_format='"i"'
2575   glib_msize_type='INT'
2576   ;;
2577 long)
2578   gsize_modifier='"l"'
2579   gsize_format='"lu"'
2580   gssize_format='"li"'
2581   glib_msize_type='LONG'
2582   ;;
2583 esac
2584
2585 gintbits=`expr $ac_cv_sizeof_int \* 8`
2586 glongbits=`expr $ac_cv_sizeof_long \* 8`
2587
2588
2589 case $ac_cv_sizeof_void_p in
2590 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2591 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2592 *)                      glib_unknown_void_p=yes ;;
2593 esac
2594
2595
2596 case xyes in
2597 x$ac_cv_func_atexit)
2598   glib_atexit="
2599 #ifdef NeXT /* @#%@! NeXTStep */
2600 # define g_ATEXIT(proc) (!atexit (proc))
2601 #else
2602 # define g_ATEXIT(proc) (atexit (proc))
2603 #endif"
2604   ;;
2605 x$ac_cv_func_on_exit)
2606   glib_atexit="
2607 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2608   ;;
2609 esac
2610
2611 case xyes in
2612 x$ac_cv_func_memmove)
2613   glib_memmove='
2614 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
2615   ;;
2616 x$glib_cv_working_bcopy)
2617   glib_memmove="
2618 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2619 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2620   ;;
2621 *)
2622   glib_memmove="
2623 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2624  * so we have to roll our own copy routine. */
2625 void g_memmove (void* dest, const void * src, unsigned long len);"
2626   ;;
2627 esac
2628
2629 glib_defines="
2630 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2631 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2632 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2633 "
2634
2635 case xyes in
2636 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2637 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2638 *)                      glib_vacopy=''
2639 esac
2640
2641 if test x$glib_cv_va_val_copy = xno; then
2642   glib_vacopy="\$glib_vacopy
2643 #define G_VA_COPY_AS_ARRAY 1"
2644 fi
2645
2646 if test x$glib_cv_hasinline = xyes; then
2647     glib_inline='#define G_HAVE_INLINE 1'
2648 fi
2649 if test x$glib_cv_has__inline = xyes; then
2650     glib_inline="\$glib_inline
2651 #define G_HAVE___INLINE 1"
2652 fi
2653 if test x$glib_cv_has__inline__ = xyes; then
2654     glib_inline="\$glib_inline
2655 #define G_HAVE___INLINE__ 1"
2656 fi
2657
2658 g_have_gnuc_varargs=$g_have_gnuc_varargs
2659 g_have_iso_c_varargs=$g_have_iso_c_varargs
2660 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2661
2662 g_can_inline=$g_can_inline
2663 g_have_gnuc_visibility=$g_have_gnuc_visibility
2664
2665 case xyes in
2666 x$ac_cv_c_bigendian)
2667   g_byte_order=G_BIG_ENDIAN
2668   g_bs_native=BE
2669   g_bs_alien=LE
2670   ;;
2671 *)
2672   g_byte_order=G_LITTLE_ENDIAN
2673   g_bs_native=LE
2674   g_bs_alien=BE
2675   ;;
2676 esac
2677
2678 g_pollin=$glib_cv_value_POLLIN
2679 g_pollout=$glib_cv_value_POLLOUT
2680 g_pollpri=$glib_cv_value_POLLPRI
2681 g_pollhup=$glib_cv_value_POLLHUP
2682 g_pollerr=$glib_cv_value_POLLERR
2683 g_pollnval=$glib_cv_value_POLLNVAL
2684
2685 g_stack_grows=$glib_cv_stack_grows
2686
2687 g_have_eilseq=$have_eilseq
2688
2689 case x$have_threads in
2690 xno)    g_enable_threads_def="#undef";;
2691 *)      g_enable_threads_def="#define";;
2692 esac
2693
2694 g_threads_impl_def=$g_threads_impl
2695
2696 g_mutex_has_default="$mutex_has_default"
2697 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2698 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2699 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2700
2701 g_memory_barrier_needed="$glib_memory_barrier_needed"
2702
2703 g_module_suffix="$glib_gmodule_suffix"
2704
2705 g_pid_type="$glib_pid_type"
2706 case $host in
2707   *-*-beos*)
2708     glib_os="#define G_OS_BEOS"
2709     ;;
2710   *-*-cygwin*)
2711     glib_os="#define G_OS_UNIX
2712 #define G_PLATFORM_WIN32
2713 #define G_WITH_CYGWIN"
2714     ;;
2715   *-*-mingw*)
2716     glib_os="#define G_OS_WIN32
2717 #define G_PLATFORM_WIN32"
2718     ;;
2719   *)
2720     glib_os="#define G_OS_UNIX"
2721     ;;
2722 esac
2723 ])
2724
2725 AC_CONFIG_FILES([
2726 glib-2.0.pc
2727 glib-2.0-uninstalled.pc
2728 gmodule-2.0.pc
2729 gmodule-export-2.0.pc
2730 gmodule-no-export-2.0.pc
2731 gmodule-2.0-uninstalled.pc
2732 gmodule-no-export-2.0-uninstalled.pc
2733 gthread-2.0.pc
2734 gthread-2.0-uninstalled.pc
2735 gobject-2.0.pc
2736 gobject-2.0-uninstalled.pc
2737 glib-zip
2738 glib-gettextize
2739 Makefile
2740 build/Makefile
2741 build/win32/Makefile
2742 build/win32/dirent/Makefile
2743 glib/Makefile
2744 glib/libcharset/Makefile
2745 glib/gnulib/Makefile
2746 gmodule/Makefile
2747 gmodule/gmoduleconf.h
2748 gobject/Makefile
2749 gobject/glib-mkenums
2750 gthread/Makefile
2751 po/Makefile.in
2752 docs/Makefile
2753 docs/reference/Makefile
2754 docs/reference/glib/Makefile
2755 docs/reference/glib/version.xml
2756 docs/reference/gobject/Makefile
2757 docs/reference/gobject/version.xml
2758 tests/Makefile
2759 tests/gobject/Makefile
2760 tests/refcount/Makefile
2761 m4macros/Makefile
2762 ])
2763
2764 AC_CONFIG_COMMANDS([chmod-scripts],
2765 [chmod 0755 glib-zip
2766 chmod 0755 glib-gettextize
2767 chmod 0755 gobject/glib-mkenums])
2768
2769 # we want to invoke this macro solely so that the config.status script
2770 # and automake generated makefiles know about these generated files.
2771 # They are only needed to distcheck the package
2772 if false; then
2773   AC_CONFIG_FILES([
2774     INSTALL
2775     README
2776     config.h.win32
2777     glibconfig.h.win32
2778     glib/makefile.msc
2779     glib/glib.rc
2780     gmodule/makefile.msc
2781     gmodule/gmodule.rc
2782     gobject/makefile.msc
2783     gobject/gobject.rc
2784     gthread/makefile.msc
2785     gthread/gthread.rc
2786     tests/makefile.msc
2787   ])
2788 fi
2789
2790 AC_OUTPUT