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