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