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