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