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