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