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