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