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 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 unsetenv getc_unlocked)
 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 ****************************************
1174 dnl *** platform dependent source checks ***
1175 dnl ****************************************
1176
1177 AC_MSG_CHECKING(for platform-dependent source)
1178 case "$host" in
1179   *-*-cygwin*|*-*-mingw*)
1180     PLATFORMDEP=gwin32.lo
1181     ;;
1182   *)
1183     PLATFORMDEP=
1184     ;;
1185 esac
1186 AC_MSG_RESULT($PLATFORMDEP)
1187 AC_SUBST(PLATFORMDEP)
1188
1189 AC_MSG_CHECKING([whether to compile timeloop])
1190 case "$host" in
1191   *-*-cygwin*|*-*-mingw*)
1192     enable_timeloop=no
1193     ;;
1194   *)
1195     enable_timeloop=yes
1196     ;;
1197 esac
1198 AC_MSG_RESULT($enable_timeloop)
1199 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1200
1201 AC_MSG_CHECKING([if building for some Win32 platform])
1202 case "$host" in
1203   *-*-mingw*|*-*-cygwin*)
1204     platform_win32=yes
1205     ;;
1206   *)
1207     platform_win32=no
1208     ;;
1209 esac
1210 AC_MSG_RESULT($platform_win32)
1211 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1212
1213 dnl ***********************
1214 dnl *** g_thread checks ***
1215 dnl ***********************
1216
1217 AC_ARG_WITH(threads,
1218            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/solaris/win32@:>@],
1219                            [specify a thread implementation to use])],
1220            [if test "x$with_threads" = x; then
1221                 want_threads=yes
1222             else
1223                 want_threads=$with_threads
1224             fi],
1225            [want_threads=yes])
1226 if test "x$enable_threads" = "xno"; then
1227         want_threads=no
1228 fi
1229
1230 dnl error and warning message
1231 dnl *************************
1232
1233 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1234                 computer. GLib will not have a default thread implementation."
1235
1236 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1237                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1238                 compilation now, but then your programs might not work.
1239                 Please provide information on how it is done on your system."
1240
1241 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1242                 "
1243
1244 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1245                 provide information on your thread implementation.
1246                 You can also run 'configure --disable-threads'
1247                 to compile without thread support."
1248
1249 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1250                 functions will not be MT-safe during their first call because
1251                 there is no working 'getpwuid_r' on your system."
1252
1253 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1254                 because there is no 'localtime_r' on your system."
1255
1256 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1257                 crude surrogate will be used. If you happen to know a
1258                 yield function for your system, please inform the GLib
1259                 developers."
1260
1261 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1262                 threads on your system. Thus threads can only have the default
1263                 priority. If you happen to know these main/max
1264                 priorities, please inform the GLib developers."
1265
1266 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1267                 linking threaded applications. As GLib cannot do that
1268                 automatically, you will get an linkg error everytime you are
1269                 not using the right compiler. In that case you have to relink
1270                 with the right compiler. Ususally just '_r' is appended
1271                 to the compiler name."
1272
1273 dnl determination of thread implementation
1274 dnl ***************************************
1275
1276 # have_threads=no   means no thread support
1277 # have_threads=none means no default thread implementation
1278
1279 have_threads=no
1280 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1281         case $host in
1282                 *-*-solaris*)
1283                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1284                 ;;
1285         esac
1286 fi
1287 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1288                                 || test "x$want_threads" = xdce; then
1289         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1290         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1291         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1292         glib_save_CPPFLAGS="$CPPFLAGS"
1293         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1294         if test "x$have_threads" = xno; then
1295                 AC_TRY_COMPILE([#include <pthread.h>],
1296                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1297                         have_threads=posix)
1298         fi
1299         if test "x$have_threads" = xno; then
1300                 AC_TRY_COMPILE([#include <pthread.h>],
1301                         [pthread_mutex_t m;
1302                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1303                         have_threads=dce)
1304         fi
1305         # Tru64Unix requires -pthread to find pthread.h. See #103020
1306         CPPFLAGS="$CPPFLAGS -pthread"
1307         if test "x$have_threads" = xno; then
1308         AC_TRY_COMPILE([#include <pthread.h>],
1309                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1310                        have_threads=posix)
1311         fi
1312         CPPFLAGS="$glib_save_CPPFLAGS"
1313 fi
1314 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1315         case $host in
1316                 *-*-mingw*)
1317                 have_threads=win32
1318                 ;;
1319         esac
1320 fi
1321 if test "x$want_threads" = xnone; then
1322         have_threads=none
1323 fi
1324
1325 AC_MSG_CHECKING(for thread implementation)
1326
1327 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1328         AC_MSG_RESULT(none available)
1329         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1330 else
1331         AC_MSG_RESULT($have_threads)
1332 fi
1333
1334
1335 dnl determination of G_THREAD_CFLAGS
1336 dnl ********************************
1337
1338 G_THREAD_LIBS=
1339 G_THREAD_LIBS_EXTRA=
1340 G_THREAD_CFLAGS=
1341
1342 dnl
1343 dnl Test program for basic POSIX threads functionality
1344 dnl
1345 m4_define([glib_thread_test],[
1346 #include <pthread.h>
1347 int check_me = 0;
1348 void* func(void* data) {check_me = 42; return &check_me;}
1349 int main()
1350  { pthread_t t;
1351    void *ret;
1352    pthread_create (&t, $1, func, 0);
1353    pthread_join (t, &ret);
1354    exit (check_me != 42 || ret != &check_me);
1355 }])
1356
1357 dnl
1358 dnl Test program for sched_get_priority_min()
1359 dnl
1360 m4_define([glib_sched_priority_test],[
1361 #include <sched.h>
1362 #include <errno.h>
1363 int main() {
1364     errno = 0;
1365     return sched_get_priority_min(SCHED_OTHER)==-1
1366            && errno != 0;
1367 }])
1368
1369 if test x"$have_threads" != xno; then
1370
1371   if test x"$have_threads" = xposix; then
1372     # First we test for posix, whether -pthread or -pthreads do the trick as
1373     # both CPPFLAG and LIBS.
1374     # One of them does for most gcc versions and some other platforms/compilers
1375     # too and could be considered as the canonical way to go.
1376     for flag in pthread pthreads; do
1377       glib_save_CFLAGS="$CFLAGS"
1378       CFLAGS="$CFLAGS -$flag"
1379       AC_TRY_RUN(glib_thread_test(0),
1380                  glib_flag_works=yes,
1381                  glib_flag_works=no,
1382                  [AC_LINK_IFELSE(glib_thread_test(0),
1383                                  glib_flag_works=yes,
1384                                  glib_flag_works=no)])
1385       CFLAGS="$glib_save_CFLAGS"
1386       if test $glib_flag_works = yes ; then
1387          G_THREAD_CFLAGS=-$flag
1388          G_THREAD_LIBS=-$flag
1389       fi
1390     done
1391   fi
1392
1393   if test x"$G_THREAD_CFLAGS" = x; then
1394
1395     # The canonical -pthread[s] does not work. Try something different.
1396
1397     case $host in
1398         *-aix*)
1399                 if test x"$GCC" = xyes; then
1400                         # GCC 3.0 and above needs -pthread.
1401                         # Should be coverd by the case above.
1402                         # GCC 2.x and below needs -mthreads
1403                         G_THREAD_CFLAGS="-mthreads"
1404                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1405                 else
1406                         # We are probably using the aix compiler. Normaly a
1407                         # program would have to be compiled with the _r variant
1408                         # of the corresponding compiler, but we as GLib cannot
1409                         # do that: but the good news is that for compiling the
1410                         # only difference is the added -D_THREAD_SAFE compile
1411                         # option. This is according to the "C for AIX User's
1412                         # Guide".
1413                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1414                 fi
1415                 ;;
1416         *-dg-dgux*)  # DG/UX
1417                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1418                 ;;
1419         *-osf*)
1420                 # So we are using dce threads. posix threads are already
1421                 # catched above.
1422                 G_THREAD_CFLAGS="-threads"
1423                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1424                 ;;
1425         *-solaris*)
1426                 if test x"$GCC" = xyes; then
1427                    # We are using solaris threads. posix threads are
1428                    # already catched above.
1429                         G_THREAD_CFLAGS="-threads"
1430                 else
1431                         G_THREAD_CFLAGS="-mt"
1432                 fi
1433                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1434                 ;;
1435         *-sysv5uw7*) # UnixWare 7
1436                 # We are not using gcc with -pthread. Catched above.
1437                 G_THREAD_CFLAGS="-Kthread"
1438                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1439                 ;;
1440         *)
1441                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1442                 ;;
1443     esac
1444
1445   fi
1446
1447     # if we are not finding the localtime_r function, then we probably are
1448     # not using the proper multithread flag
1449
1450     glib_save_CPPFLAGS="$CPPFLAGS"
1451     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1452
1453     # First we test, whether localtime_r is declared in time.h
1454     # directly. Then we test whether a macro localtime_r exists, in
1455     # which case localtime_r in the test program is replaced and thus
1456     # if we still find localtime_r in the output, it is not defined as
1457     # a macro.
1458
1459     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1460       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1461                                                            localtime_r(a,b)],
1462                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1463
1464     CPPFLAGS="$glib_save_CPPFLAGS"
1465
1466     AC_MSG_CHECKING(thread related cflags)
1467     AC_MSG_RESULT($G_THREAD_CFLAGS)
1468     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1469 fi
1470
1471 dnl determination of G_THREAD_LIBS
1472 dnl ******************************
1473
1474 mutex_has_default=no
1475 case $have_threads in
1476         posix|dce)
1477           glib_save_CPPFLAGS="$CPPFLAGS"
1478           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1479           if test x"$G_THREAD_LIBS" = x; then
1480             case $host in
1481               *-aix*)
1482                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1483                 # probably using the aix compiler.
1484                 AC_MSG_WARN($AIX_COMPILE_INFO)
1485                 ;;
1486               *)
1487                 G_THREAD_LIBS=error
1488                 glib_save_LIBS="$LIBS"
1489                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1490                         if test x"$thread_lib" = x; then
1491                                 add_thread_lib=""
1492                                 IN=""
1493                         else
1494                                 add_thread_lib="-l$thread_lib"
1495                                 IN=" in -l$thread_lib"
1496                         fi
1497                         if test x"$have_threads" = xposix; then
1498                                 defattr=0
1499                         else
1500                                 defattr=pthread_attr_default
1501                         fi
1502
1503                         LIBS="$add_thread_lib $glib_save_LIBS"
1504
1505                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1506                         AC_TRY_RUN(glib_thread_test($defattr),
1507                                    glib_result=yes,
1508                                    glib_result=no,
1509                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
1510                                                    glib_result=yes,
1511                                                    glib_result=no)])
1512                         AC_MSG_RESULT($glib_result)
1513
1514                         if test "$glib_result" = "yes" ; then
1515                           G_THREAD_LIBS="$add_thread_lib"
1516                           break
1517                         fi
1518                 done
1519                 if test "x$G_THREAD_LIBS" = xerror; then
1520                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1521                 fi
1522                 LIBS="$glib_save_LIBS"
1523                 ;;
1524             esac
1525           fi
1526
1527           glib_save_LIBS="$LIBS"
1528           for thread_lib in "" rt rte; do
1529             if test x"$thread_lib" = x; then
1530               add_thread_lib=""
1531               IN=""
1532             else
1533               add_thread_lib="-l$thread_lib"
1534               IN=" in -l$thread_lib"
1535             fi
1536             LIBS="$add_thread_lib $glib_save_LIBS"
1537
1538             AC_MSG_CHECKING(for sched_get_priority_min$IN)
1539             AC_TRY_RUN(glib_sched_priority_test,
1540                        glib_result=yes,
1541                        glib_result=no,
1542                        [AC_LINK_IFELSE(glib_sched_priority_test,
1543                                        glib_result=yes,
1544                                        glib_result=no)])
1545             AC_MSG_RESULT($glib_result)
1546
1547             if test "$glib_result" = "yes" ; then
1548                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1549                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1550                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1551                break
1552             fi
1553           done
1554           LIBS="$glib_save_LIBS"
1555           mutex_has_default=yes
1556           mutex_default_type='pthread_mutex_t'
1557           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1558           mutex_header_file='pthread.h'
1559           if test "x$have_threads" = "xposix"; then
1560             g_threads_impl="POSIX"
1561           else
1562             g_threads_impl="DCE"
1563             have_threads="posix"
1564           fi
1565           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1566           CPPFLAGS="$glib_save_CPPFLAGS"
1567           ;;
1568         solaris)
1569            mutex_has_default=yes
1570            mutex_default_type='mutex_t'
1571            mutex_default_init="DEFAULTMUTEX"
1572            mutex_header_file='thread.h'
1573            g_threads_impl="SOLARIS"
1574            ;;
1575         win32)
1576            g_threads_impl="WIN32"
1577            ;;
1578         none|no)
1579            g_threads_impl="NONE"
1580            ;;
1581         *)
1582            g_threads_impl="NONE"
1583            G_THREAD_LIBS=error
1584            ;;
1585 esac
1586
1587 if test "x$G_THREAD_LIBS" = xerror; then
1588         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1589 fi
1590
1591 case $host in
1592   *-*-beos*)
1593     G_THREAD_LIBS="-lbe -lroot -lglib "
1594     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1595     ;;
1596   *)
1597     ;;
1598 esac
1599
1600 AC_MSG_CHECKING(thread related libraries)
1601 AC_MSG_RESULT($G_THREAD_LIBS)
1602
1603 dnl check for mt safe function variants and some posix functions
1604 dnl ************************************************************
1605
1606 if test x"$have_threads" != xno; then
1607         glib_save_LIBS="$LIBS"
1608         # we are not doing the following for now, as this might require glib
1609         # to always be linked with the thread libs on some platforms.
1610         # LIBS="$LIBS $G_THREAD_LIBS"
1611         AC_CHECK_FUNCS(localtime_r)
1612         if test "$ac_cv_header_pwd_h" = "yes"; then
1613                 AC_CACHE_CHECK([for posix getpwuid_r],
1614                         ac_cv_func_posix_getpwuid_r,
1615                         [AC_TRY_RUN([
1616 #include <errno.h>
1617 #include <pwd.h>
1618 int main () {
1619     char buffer[10000];
1620     struct passwd pwd, *pwptr = &pwd;
1621     int error;
1622     errno = 0;
1623     error = getpwuid_r (0, &pwd, buffer,
1624                         sizeof (buffer), &pwptr);
1625    return (error < 0 && errno == ENOSYS)
1626            || error == ENOSYS;
1627 }                               ],
1628                                 [ac_cv_func_posix_getpwuid_r=yes],
1629                                 [ac_cv_func_posix_getpwuid_r=no])])
1630                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
1631                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1632                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1633                                 [Have POSIX function getpwuid_r])
1634                 else
1635                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1636                                 ac_cv_func_nonposix_getpwuid_r,
1637                                 [AC_TRY_LINK([#include <pwd.h>],
1638                                         [char buffer[10000];
1639                                         struct passwd pwd;
1640                                         getpwuid_r (0, &pwd, buffer,
1641                                                         sizeof (buffer));],
1642                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1643                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1644                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
1645                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1646                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1647                                         [Have non-POSIX function getpwuid_r])
1648                         fi
1649                 fi
1650         fi
1651         LIBS="$G_THREAD_LIBS $LIBS"
1652         if test x"$have_threads" = xposix; then
1653                 glib_save_CPPFLAGS="$CPPFLAGS"
1654                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1655                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1656                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1657                 # This is not AC_CHECK_FUNC to also work with function
1658                 # name mangling in header files.
1659                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1660                 AC_TRY_LINK([#include <pthread.h>],
1661                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1662                         [AC_MSG_RESULT(yes)
1663                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1664                                   [Have function pthread_attr_setstacksize])],
1665                         [AC_MSG_RESULT(no)])
1666                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1667                 if test x"$posix_priority_min" = x; then
1668                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1669                                 PX_PRIO_MIN],,[
1670                                 posix_priority_min=PX_PRIO_MIN
1671                                 posix_priority_max=PX_PRIO_MAX])
1672                 fi
1673                 if test x"$posix_priority_min" = x; then
1674                         # AIX
1675                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1676                                 PTHREAD_PRIO_MIN],,[
1677                                 posix_priority_min=PTHREAD_PRIO_MIN
1678                                 posix_priority_max=PTHREAD_PRIO_MAX])
1679                 fi
1680                 if test x"$posix_priority_min" = x; then
1681                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1682                                 PRI_OTHER_MIN],,[
1683                                 posix_priority_min=PRI_OTHER_MIN
1684                                 posix_priority_max=PRI_OTHER_MAX])
1685                 fi
1686                 if test x"$posix_priority_min" = x; then
1687                         AC_MSG_RESULT(none found)
1688                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1689                         posix_priority_min=-1
1690                         posix_priority_max=-1
1691                 else
1692                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1693                         AC_MSG_CHECKING(for pthread_setschedparam)
1694                         AC_TRY_LINK([#include <pthread.h>],
1695                           [pthread_t t; pthread_setschedparam(&t, 0, NULL)],
1696                           [AC_MSG_RESULT(yes)
1697                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1698                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
1699                           [AC_MSG_RESULT(no)
1700                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
1701                 fi
1702                 posix_yield_func=none
1703                 AC_MSG_CHECKING(for posix yield function)
1704                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1705                                                         thr_yield; do
1706                         AC_TRY_LINK([#include <pthread.h>],
1707                                 [$yield_func()],
1708                                 [posix_yield_func="$yield_func"
1709                                 break])
1710                 done
1711                 if test x"$posix_yield_func" = xnone; then
1712                         AC_MSG_RESULT(none found)
1713                         AC_MSG_WARN($POSIX_NO_YIELD)
1714                         posix_yield_func="g_usleep(1000)"
1715                 else
1716                         AC_MSG_RESULT($posix_yield_func)
1717                         posix_yield_func="$posix_yield_func()"
1718                 fi
1719                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1720                 CPPFLAGS="$glib_save_CPPFLAGS"
1721
1722                 AC_CACHE_CHECK([whether to use the PID niceness surrogate for thread priorities],
1723                                glib_cv_use_pid_surrogate,
1724                  [AC_TRY_RUN([
1725 #include <pthread.h>
1726 #include <sys/types.h>
1727 #include <unistd.h>
1728 pid_t other_pid = 0;
1729
1730 void* func(void* data) {other_pid = getpid();}
1731 main()
1732 { pthread_t t;
1733   void *ret;
1734   pthread_create (&t, 0, func, NULL);
1735   pthread_join (t, &ret);
1736   exit (getpid()==other_pid ||
1737         $posix_priority_min != $posix_priority_max);
1738 }               ],
1739                 [glib_cv_use_pid_surrogate=yes],
1740                 [glib_cv_use_pid_surrogate=no],
1741                 [])])
1742           GLIB_ASSERT_SET(glib_cv_use_pid_surrogate)
1743           if test "$glib_cv_use_pid_surrogate" = "yes" ; then
1744             AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1,
1745                       [whether to use the PID niceness surrogate for thread priorities])
1746           fi
1747
1748         elif test x"$have_threads" = xwin32; then
1749                 # It's a pointer to a private struct
1750                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1751         elif test x"$have_threads" = xsolaris; then
1752                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1753         fi
1754
1755         LIBS="$glib_save_LIBS"
1756
1757         # now spit out all the warnings.
1758         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1759            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1760                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1761         fi
1762         if test "$ac_cv_func_localtime_r" != "yes"; then
1763                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1764         fi
1765 fi
1766
1767 if test x"$glib_cv_sizeof_system_thread" = x; then
1768    # use a pointer as a fallback.
1769    GLIB_SIZEOF(,void *, system_thread)
1770 fi
1771
1772 #
1773 # Hack to deal with:
1774 #
1775 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
1776 #     building shared libraries with linux.
1777 #  b) libtool doesn't recognize -pthread as a library dependency.
1778 #
1779 case $host in
1780   *-*-linux*)
1781     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1782     ;;
1783   *)
1784     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
1785     ;;
1786 esac
1787
1788 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1789                    [Source file containing theread implementation])
1790 AC_SUBST(G_THREAD_CFLAGS)
1791 AC_SUBST(G_THREAD_LIBS)
1792 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1793 AC_SUBST(G_THREAD_LIBS_EXTRA)
1794
1795 dnl **********************************************
1796 dnl *** GDefaultMutex setup and initialization ***
1797 dnl **********************************************
1798 dnl
1799 dnl if mutex_has_default = yes, we also got
1800 dnl mutex_default_type, mutex_default_init and mutex_header_file
1801 if test $mutex_has_default = yes ; then
1802         glib_save_CPPFLAGS="$CPPFLAGS"
1803         glib_save_LIBS="$LIBS"
1804         LIBS="$G_THREAD_LIBS $LIBS"
1805         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1806         GLIB_SIZEOF([#include <$mutex_header_file>],
1807                     $mutex_default_type,
1808                     gmutex)
1809         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1810                            $mutex_default_type,
1811                            gmutex,
1812                            $glib_cv_sizeof_gmutex,
1813                            $mutex_default_init)
1814         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1815                 mutex_has_default=no
1816         fi
1817         CPPFLAGS="$glib_save_CPPFLAGS"
1818         LIBS="$glib_save_LIBS"
1819 fi
1820
1821 dnl ****************************************
1822 dnl *** GLib POLL* compatibility defines ***
1823 dnl ****************************************
1824
1825 glib_poll_includes=["
1826 #include <sys/types.h>
1827 #include <sys/poll.h>
1828 "]
1829
1830 if test $ac_cv_header_sys_types_h = yes &&
1831    test $ac_cv_header_sys_poll_h = yes ; then
1832   glib_failed=false
1833   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1834   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1835   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1836   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1837   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1838   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1839   if $glib_failed ; then
1840     AC_MSG_ERROR([Could not determine values for POLL* constants])
1841   fi
1842 else
1843   glib_cv_value_POLLIN=1
1844   glib_cv_value_POLLOUT=4
1845   glib_cv_value_POLLPRI=2
1846   glib_cv_value_POLLERR=8
1847   glib_cv_value_POLLHUP=16
1848   glib_cv_value_POLLNVAL=32
1849 fi
1850
1851 dnl **********************
1852 dnl *** Win32 API libs ***
1853 dnl **********************
1854
1855 case $host in
1856   *-*-cygwin*)
1857         G_LIBS_EXTRA="-luser32 -lkernel32"
1858     ;;
1859   *-*-mingw*)
1860         G_LIBS_EXTRA="-lwsock32"
1861     ;;
1862   *)
1863         G_LIBS_EXTRA=""
1864     ;;
1865 esac
1866 AC_SUBST(G_LIBS_EXTRA)
1867
1868 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1869 dnl since we need it for g_iconv()
1870
1871 AC_MSG_CHECKING([for EILSEQ])
1872 AC_TRY_COMPILE([
1873 #include <errno.h>
1874 ],
1875 [
1876 int error = EILSEQ;
1877 ], have_eilseq=yes, have_eilseq=no);
1878 AC_MSG_RESULT($have_eilseq)
1879
1880 dnl ******************************************************************
1881 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1882 dnl ******************************************************************
1883
1884 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1885
1886 if test $cross_compiling = yes; then
1887   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1888   if test x$GLIB_GENMARSHAL = xno; then
1889     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1890   fi
1891 fi
1892
1893 dnl **************************
1894 dnl *** Checks for gtk-doc ***
1895 dnl **************************
1896
1897 GTK_DOC_CHECK([1.0])
1898
1899 dnl ******************************
1900 dnl *** output the whole stuff ***
1901 dnl ******************************
1902
1903 dnl this section will only be run if config.status is invoked with no
1904 dnl arguments, or with "glibconfig.h" as an argument.
1905 AC_CONFIG_COMMANDS([glibconfig.h],
1906 [
1907         outfile=glibconfig.h-tmp
1908         cat > $outfile <<\_______EOF
1909 /* glibconfig.h
1910  *
1911  * This is a generated file.  Please modify 'configure.in'
1912  */
1913
1914 #ifndef __G_LIBCONFIG_H__
1915 #define __G_LIBCONFIG_H__
1916
1917 #include <glib/gmacros.h>
1918
1919 _______EOF
1920
1921         if test x$glib_limits_h = xyes; then
1922           echo '#include <limits.h>' >> $outfile
1923         fi
1924         if test x$glib_float_h = xyes; then
1925           echo '#include <float.h>' >> $outfile
1926         fi
1927         if test x$glib_values_h = xyes; then
1928           echo '#include <values.h>' >> $outfile
1929         fi
1930         if test "$glib_header_alloca_h" = "yes"; then
1931           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1932         fi
1933         if test x$glib_sys_poll_h = xyes; then
1934           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1935         fi
1936
1937         cat >> $outfile <<_______EOF
1938
1939 G_BEGIN_DECLS
1940
1941 #define G_MINFLOAT      $glib_mf
1942 #define G_MAXFLOAT      $glib_Mf
1943 #define G_MINDOUBLE     $glib_md
1944 #define G_MAXDOUBLE     $glib_Md
1945 #define G_MINSHORT      $glib_ms
1946 #define G_MAXSHORT      $glib_Ms
1947 #define G_MAXUSHORT     $glib_Mus
1948 #define G_MININT        $glib_mi
1949 #define G_MAXINT        $glib_Mi
1950 #define G_MAXUINT       $glib_Mui
1951 #define G_MINLONG       $glib_ml
1952 #define G_MAXLONG       $glib_Ml
1953 #define G_MAXULONG      $glib_Mul
1954
1955 #define G_MININT64      G_GINT64_CONSTANT(0x8000000000000000)
1956 #define G_MAXINT64      G_GINT64_CONSTANT(0x7fffffffffffffff)
1957 #define G_MAXUINT64     G_GINT64_CONSTANT(0xffffffffffffffffU)
1958
1959 _______EOF
1960
1961
1962         ### this should always be true in a modern C/C++ compiler
1963         cat >>$outfile <<_______EOF
1964 typedef signed char gint8;
1965 typedef unsigned char guint8;
1966 _______EOF
1967
1968
1969         if test -n "$gint16"; then
1970           cat >>$outfile <<_______EOF
1971 typedef signed $gint16 gint16;
1972 typedef unsigned $gint16 guint16;
1973 #define G_GINT16_FORMAT $gint16_format
1974 #define G_GUINT16_FORMAT $guint16_format
1975 _______EOF
1976         fi
1977
1978
1979         if test -n "$gint32"; then
1980           cat >>$outfile <<_______EOF
1981 typedef signed $gint32 gint32;
1982 typedef unsigned $gint32 guint32;
1983 #define G_GINT32_FORMAT $gint32_format
1984 #define G_GUINT32_FORMAT $guint32_format
1985 _______EOF
1986         fi
1987
1988         cat >>$outfile <<_______EOF
1989 #define G_HAVE_GINT64 1          /* deprecated, always true */
1990
1991 ${glib_extension}typedef signed $gint64 gint64;
1992 ${glib_extension}typedef unsigned $gint64 guint64;
1993
1994 #define G_GINT64_CONSTANT(val)  $gint64_constant
1995 _______EOF
1996
1997         if test x$gint64_format != x ; then
1998           cat >>$outfile <<_______EOF
1999 #define G_GINT64_FORMAT $gint64_format
2000 #define G_GUINT64_FORMAT $guint64_format
2001 _______EOF
2002         else
2003           cat >>$outfile <<_______EOF
2004 #undef G_GINT64_FORMAT
2005 #undef G_GUINT64_FORMAT
2006 _______EOF
2007         fi
2008
2009         cat >>$outfile <<_______EOF
2010
2011 #define GLIB_SIZEOF_VOID_P $glib_void_p
2012 #define GLIB_SIZEOF_LONG   $glib_long
2013 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2014
2015 _______EOF
2016
2017 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
2018 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
2019
2020         if test -z "$glib_unknown_void_p"; then
2021           cat >>$outfile <<_______EOF
2022
2023 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2024 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2025
2026 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2027 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2028 _______EOF
2029         else
2030           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2031         fi
2032
2033
2034
2035         cat >>$outfile <<_______EOF
2036 $glib_atexit
2037 $glib_memmove
2038 $glib_defines
2039 $glib_os
2040
2041 $glib_vacopy
2042
2043 #ifdef  __cplusplus
2044 #define G_HAVE_INLINE   1
2045 #else   /* !__cplusplus */
2046 $glib_inline
2047 #endif  /* !__cplusplus */
2048
2049 _______EOF
2050
2051         if test x$g_have_iso_c_varargs = xyes ; then
2052                 cat >>$outfile <<_______EOF
2053 #ifndef __cplusplus
2054 # define G_HAVE_ISO_VARARGS 1
2055 #endif
2056 _______EOF
2057         fi
2058         if test x$g_have_iso_cxx_varargs = xyes ; then
2059                 cat >>$outfile <<_______EOF
2060 #ifdef __cplusplus
2061 # define G_HAVE_ISO_VARARGS 1
2062 #endif
2063 _______EOF
2064         fi
2065         if test x$g_have_gnuc_varargs = xyes ; then
2066                 cat >>$outfile <<_______EOF
2067
2068 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2069  * is passed ISO vararg support is turned off, and there is no work
2070  * around to turn it on, so we unconditionally turn it off.
2071  */
2072 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2073 #  undef G_HAVE_ISO_VARARGS
2074 #endif
2075
2076 #define G_HAVE_GNUC_VARARGS 1
2077 _______EOF
2078         fi
2079
2080         case x$g_stack_grows in
2081         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2082         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2083         esac
2084
2085
2086         echo >>$outfile
2087         if test x$g_have_eilseq = xno; then
2088                 cat >>$outfile <<_______EOF
2089 #ifndef EILSEQ
2090 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2091  * The correspondence between this and the corresponding definition
2092  * in libiconv is essential.
2093  */
2094 #  define EILSEQ ENOENT
2095 #endif
2096 _______EOF
2097
2098         fi
2099
2100         echo >>$outfile
2101         if test x$g_mutex_has_default = xyes; then
2102                 cat >>$outfile <<_______EOF
2103 $g_enable_threads_def G_THREADS_ENABLED
2104 #define G_THREADS_IMPL_$g_threads_impl_def
2105 typedef struct _GStaticMutex GStaticMutex;
2106 struct _GStaticMutex
2107 {
2108   struct _GMutex *runtime_mutex;
2109   union {
2110     char   pad[[$g_mutex_sizeof]];
2111     double dummy_double;
2112     void  *dummy_pointer;
2113     long   dummy_long;
2114   } static_mutex;
2115 };
2116 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2117 #define g_static_mutex_get_mutex(mutex) \
2118   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
2119    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
2120 _______EOF
2121         else
2122                 cat >>$outfile <<_______EOF
2123 $g_enable_threads_def G_THREADS_ENABLED
2124 #define G_THREADS_IMPL_$g_threads_impl_def
2125 typedef struct _GMutex* GStaticMutex;
2126 #define G_STATIC_MUTEX_INIT NULL
2127 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
2128 _______EOF
2129         fi
2130
2131         cat >>$outfile <<_______EOF
2132 /* This represents a system thread as used by the implementation. An
2133  * alien implementaion, as loaded by g_thread_init can only count on
2134  * "sizeof (gpointer)" bytes to store their info. We however need more
2135  * for some of our native implementations. */
2136 typedef union _GSystemThread GSystemThread;
2137 union _GSystemThread
2138 {
2139   char   data[[$g_system_thread_sizeof]];
2140   double dummy_double;
2141   void  *dummy_pointer;
2142   long   dummy_long;
2143 };
2144 _______EOF
2145
2146         echo >>$outfile
2147         g_bit_sizes="16 32 64"
2148         for bits in $g_bit_sizes; do
2149           cat >>$outfile <<_______EOF
2150 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2151 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2152 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2153 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2154 _______EOF
2155         done
2156
2157         cat >>$outfile <<_______EOF
2158 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2159 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2160 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2161 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2162 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2163 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2164 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2165 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2166 #define G_BYTE_ORDER $g_byte_order
2167
2168 #define GLIB_SYSDEF_POLLIN =$g_pollin
2169 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2170 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2171 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2172 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2173 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2174
2175 #define G_MODULE_SUFFIX "$g_module_suffix"
2176
2177 G_END_DECLS
2178
2179 #endif /* GLIBCONFIG_H */
2180 _______EOF
2181
2182
2183         if cmp -s $outfile glibconfig.h; then
2184           AC_MSG_NOTICE([glibconfig.h is unchanged])
2185           rm -f $outfile
2186         else
2187           mv $outfile glibconfig.h
2188         fi
2189 ],[
2190
2191 # Note that if two cases are the same, case goes with the first one.
2192 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2193 # on variable expansion in case labels.  Look at the generated config.status
2194 # for a hint.
2195
2196 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2197   glib_header_alloca_h="$ac_cv_working_alloca_h"
2198 else
2199   glib_header_alloca_h="$ac_cv_header_alloca_h"
2200 fi
2201
2202 case xyes in
2203 x$ac_cv_header_float_h)
2204   glib_float_h=yes
2205   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2206   glib_md=DBL_MIN glib_Md=DBL_MAX
2207   ;;
2208 x$ac_cv_header_values_h)
2209   glib_values_h=yes
2210   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2211   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2212   ;;
2213 esac
2214
2215 case xyes in
2216 x$ac_cv_header_limits_h)
2217   glib_limits_h=yes
2218   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2219   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2220   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2221   ;;
2222 x$ac_cv_header_values_h)
2223   glib_values_h=yes
2224   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2225   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2226   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2227   ;;
2228 esac
2229
2230 if test x$ac_cv_header_sys_poll_h = xyes ; then
2231   glib_sys_poll_h=yes
2232 fi
2233
2234 case 2 in
2235 $ac_cv_sizeof_short)
2236   gint16=short
2237   gint16_format='"hi"'
2238   guint16_format='"hu"'
2239   ;;
2240 $ac_cv_sizeof_int)
2241   gint16=int
2242   gint16_format='"i"'
2243   guint16_format='"u"'
2244   ;;
2245 esac
2246 case 4 in
2247 $ac_cv_sizeof_short)
2248   gint32=short
2249   gint32_format='"hi"'
2250   guint32_format='"hu"'
2251   ;;
2252 $ac_cv_sizeof_int)
2253   gint32=int
2254   gint32_format='"i"'
2255   guint32_format='"u"'
2256   ;;
2257 $ac_cv_sizeof_long)
2258   gint32=long
2259   gint32_format='"li"'
2260   guint32_format='"lu"'
2261   ;;
2262 esac
2263 case 8 in
2264 $ac_cv_sizeof_int)
2265   gint64=int
2266   gint64_format='"i"'
2267   guint64_format='"u"'
2268   glib_extension=
2269   gint64_constant='(val)'
2270   ;;
2271 $ac_cv_sizeof_long)
2272   gint64=long
2273   gint64_format='"li"'
2274   guint64_format='"lu"'
2275   glib_extension=
2276   gint64_constant='(val##L)'
2277   ;;
2278 $ac_cv_sizeof_long_long)
2279   gint64='long long'
2280   if test -n "$glib_cv_long_long_format"; then
2281     gint64_format='"'$glib_cv_long_long_format'i"'
2282     guint64_format='"'$glib_cv_long_long_format'u"'
2283   fi
2284   glib_extension='G_GNUC_EXTENSION '
2285   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2286   ;;
2287 $ac_cv_sizeof___int64)
2288   gint64='__int64'
2289   if test -n "$glib_cv_long_long_format"; then
2290     gint64_format='"'$glib_cv_long_long_format'i"'
2291     guint64_format='"'$glib_cv_long_long_format'u"'
2292   fi
2293   glib_extension=
2294   gint64_constant='(val##i64)'
2295   ;;
2296 esac
2297 glib_size_t=$ac_cv_sizeof_size_t
2298 glib_size_type_define=$glib_size_type
2299 glib_void_p=$ac_cv_sizeof_long
2300 glib_long=$ac_cv_sizeof_void_p
2301
2302 gintbits=`expr $ac_cv_sizeof_int \* 8`
2303 glongbits=`expr $ac_cv_sizeof_long \* 8`
2304
2305
2306 case $ac_cv_sizeof_void_p in
2307 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2308 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2309 *)                      glib_unknown_void_p=yes ;;
2310 esac
2311
2312
2313 case xyes in
2314 x$ac_cv_func_atexit)
2315   glib_atexit="
2316 #ifdef NeXT /* @#%@! NeXTStep */
2317 # define g_ATEXIT(proc) (!atexit (proc))
2318 #else
2319 # define g_ATEXIT(proc) (atexit (proc))
2320 #endif"
2321   ;;
2322 x$ac_cv_func_on_exit)
2323   glib_atexit="
2324 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2325   ;;
2326 esac
2327
2328 case xyes in
2329 x$ac_cv_func_memmove)
2330   glib_memmove='
2331 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2332   ;;
2333 x$glib_cv_working_bcopy)
2334   glib_memmove="
2335 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2336 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2337   ;;
2338 *)
2339   glib_memmove="
2340 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2341  * so we have to roll our own copy routine. */
2342 void g_memmove (void* dest, const void * src, unsigned long len);"
2343   ;;
2344 esac
2345
2346 glib_defines="
2347 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2348 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2349 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2350 "
2351
2352 case xyes in
2353 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2354 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2355 *)                      glib_vacopy=''
2356 esac
2357
2358 if test x$glib_cv_va_val_copy = xno; then
2359   glib_vacopy="\$glib_vacopy
2360 #define G_VA_COPY_AS_ARRAY 1"
2361 fi
2362
2363 if test x$glib_cv_hasinline = xyes; then
2364     glib_inline='#define G_HAVE_INLINE 1'
2365 fi
2366 if test x$glib_cv_has__inline = xyes; then
2367     glib_inline="\$glib_inline
2368 #define G_HAVE___INLINE 1"
2369 fi
2370 if test x$glib_cv_has__inline__ = xyes; then
2371     glib_inline="\$glib_inline
2372 #define G_HAVE___INLINE__ 1"
2373 fi
2374
2375 g_have_gnuc_varargs=$g_have_gnuc_varargs
2376 g_have_iso_c_varargs=$g_have_iso_c_varargs
2377 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2378
2379 case xyes in
2380 x$ac_cv_c_bigendian)
2381   g_byte_order=G_BIG_ENDIAN
2382   g_bs_native=BE
2383   g_bs_alien=LE
2384   ;;
2385 *)
2386   g_byte_order=G_LITTLE_ENDIAN
2387   g_bs_native=LE
2388   g_bs_alien=BE
2389   ;;
2390 esac
2391
2392 g_pollin=$glib_cv_value_POLLIN
2393 g_pollout=$glib_cv_value_POLLOUT
2394 g_pollpri=$glib_cv_value_POLLPRI
2395 g_pollhup=$glib_cv_value_POLLHUP
2396 g_pollerr=$glib_cv_value_POLLERR
2397 g_pollnval=$glib_cv_value_POLLNVAL
2398
2399 g_stack_grows=$glib_cv_stack_grows
2400
2401 g_have_eilseq=$have_eilseq
2402
2403 case x$have_threads in
2404 xno)    g_enable_threads_def="#undef";;
2405 *)      g_enable_threads_def="#define";;
2406 esac
2407
2408 g_threads_impl_def=$g_threads_impl
2409
2410 g_mutex_has_default="$mutex_has_default"
2411 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2412 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2413 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2414
2415 g_module_suffix="$glib_gmodule_suffix"
2416
2417 case $host in
2418   *-*-beos*)
2419     glib_os="#define G_OS_BEOS"
2420     ;;
2421   *-*-cygwin*)
2422     glib_os="#define G_OS_UNIX
2423 #define G_PLATFORM_WIN32
2424 #define G_WITH_CYGWIN"
2425     ;;
2426   *-*-mingw*)
2427     glib_os="#define G_OS_WIN32
2428 #define G_PLATFORM_WIN32"
2429     ;;
2430   *)
2431     glib_os="#define G_OS_UNIX"
2432     ;;
2433 esac
2434 ])
2435
2436 AC_CONFIG_FILES([
2437 glib-2.0.pc
2438 glib-2.0-uninstalled.pc
2439 gmodule-2.0.pc
2440 gmodule-2.0-uninstalled.pc
2441 gthread-2.0.pc
2442 gthread-2.0-uninstalled.pc
2443 gobject-2.0.pc
2444 gobject-2.0-uninstalled.pc
2445 glib-zip
2446 glib-gettextize
2447 Makefile
2448 build/Makefile
2449 build/win32/Makefile
2450 build/win32/dirent/Makefile
2451 glib/Makefile
2452 glib/libcharset/Makefile
2453 glib/trio/Makefile
2454 gmodule/Makefile
2455 gmodule/gmoduleconf.h
2456 gobject/Makefile
2457 gobject/glib-mkenums
2458 gthread/Makefile
2459 po/Makefile.in
2460 docs/Makefile
2461 docs/reference/Makefile
2462 docs/reference/glib/Makefile
2463 docs/reference/glib/version.xml
2464 docs/reference/gobject/Makefile
2465 docs/reference/gobject/version.xml
2466 tests/Makefile
2467 m4macros/Makefile
2468 ])
2469
2470 AC_CONFIG_COMMANDS([chmod-scripts],
2471 [chmod 0755 glib-zip
2472 chmod 0755 glib-gettextize
2473 chmod 0755 gobject/glib-mkenums])
2474
2475 # we want to invoke this macro solely so that the config.status script
2476 # and automake generated makefiles know about these generated files.
2477 # They are only needed to distcheck the package
2478 if false; then
2479   AC_CONFIG_FILES([
2480     INSTALL
2481     README
2482     config.h.win32
2483     glibconfig.h.win32
2484     glib/makefile.mingw
2485     glib/makefile.msc
2486     glib/glib.rc
2487     gmodule/makefile.mingw
2488     gmodule/makefile.msc
2489     gmodule/gmodule.rc
2490     gobject/makefile.mingw
2491     gobject/makefile.msc
2492     gobject/gobject.rc
2493     gthread/makefile.mingw
2494     gthread/makefile.msc
2495     gthread/gthread.rc
2496     tests/makefile.mingw
2497     tests/makefile.msc
2498   ])
2499 fi
2500
2501 AC_OUTPUT