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