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