configure.in

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