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