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