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], [2])
  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 az be bg bn ca cs 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 sv ta tr uk vi 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_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1694                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1695                 fi
1696                 posix_yield_func=none
1697                 AC_MSG_CHECKING(for posix yield function)
1698                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1699                                                         thr_yield; do
1700                         AC_TRY_LINK([#include <pthread.h>],
1701                                 [$yield_func()],
1702                                 [posix_yield_func="$yield_func"
1703                                 break])
1704                 done
1705                 if test x"$posix_yield_func" = xnone; then
1706                         AC_MSG_RESULT(none found)
1707                         AC_MSG_WARN($POSIX_NO_YIELD)
1708                         posix_yield_func="g_usleep(1000)"
1709                 else
1710                         AC_MSG_RESULT($posix_yield_func)
1711                         posix_yield_func="$posix_yield_func()"
1712                 fi
1713                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1714                 CPPFLAGS="$glib_save_CPPFLAGS"
1715
1716                 AC_CACHE_CHECK([whether to use the PID niceness surrogate for thread priorities],
1717                                glib_cv_use_pid_surrogate,
1718                  [AC_TRY_RUN([
1719 #include <pthread.h>
1720 #include <sys/types.h>
1721 #include <unistd.h>
1722 pid_t other_pid = 0;
1723
1724 void* func(void* data) {other_pid = getpid();}
1725 main()
1726 { pthread_t t;
1727   void *ret;
1728   pthread_create (&t, 0, func, NULL);
1729   pthread_join (t, &ret);
1730   exit (getpid()==other_pid ||
1731         $posix_priority_min != $posix_priority_max);
1732 }               ],
1733                 [glib_cv_use_pid_surrogate=yes],
1734                 [glib_cv_use_pid_surrogate=no],
1735                 [])])
1736           GLIB_ASSERT_SET(glib_cv_use_pid_surrogate)
1737           if test "$glib_cv_use_pid_surrogate" = "yes" ; then
1738             AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1,
1739                       [whether to use the PID niceness surrogate for thread priorities])
1740           fi
1741
1742         elif test x"$have_threads" = xwin32; then
1743                 # It's a pointer to a private struct
1744                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1745         elif test x"$have_threads" = xsolaris; then
1746                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1747         fi
1748
1749         LIBS="$glib_save_LIBS"
1750
1751         # now spit out all the warnings.
1752         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1753            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1754                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1755         fi
1756         if test "$ac_cv_func_localtime_r" != "yes"; then
1757                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1758         fi
1759 fi
1760
1761 if test x"$glib_cv_sizeof_system_thread" = x; then
1762    # use a pointer as a fallback.
1763    GLIB_SIZEOF(,void *, system_thread)
1764 fi
1765
1766 #
1767 # Hack to deal with:
1768 #
1769 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
1770 #     building shared libraries with linux.
1771 #  b) libtool doesn't recognize -pthread as a library dependency.
1772 #
1773 case $host in
1774   *-*-linux*)
1775     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
1776     ;;
1777   *)
1778     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-Wc,-pthread/`"
1779     ;;
1780 esac
1781
1782 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1783                    [Source file containing theread implementation])
1784 AC_SUBST(G_THREAD_CFLAGS)
1785 AC_SUBST(G_THREAD_LIBS)
1786 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
1787 AC_SUBST(G_THREAD_LIBS_EXTRA)
1788
1789 dnl **********************************************
1790 dnl *** GDefaultMutex setup and initialization ***
1791 dnl **********************************************
1792 dnl
1793 dnl if mutex_has_default = yes, we also got
1794 dnl mutex_default_type, mutex_default_init and mutex_header_file
1795 if test $mutex_has_default = yes ; then
1796         glib_save_CPPFLAGS="$CPPFLAGS"
1797         glib_save_LIBS="$LIBS"
1798         LIBS="$G_THREAD_LIBS $LIBS"
1799         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1800         GLIB_SIZEOF([#include <$mutex_header_file>],
1801                     $mutex_default_type,
1802                     gmutex)
1803         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1804                            $mutex_default_type,
1805                            gmutex,
1806                            $glib_cv_sizeof_gmutex,
1807                            $mutex_default_init)
1808         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1809                 mutex_has_default=no
1810         fi
1811         CPPFLAGS="$glib_save_CPPFLAGS"
1812         LIBS="$glib_save_LIBS"
1813 fi
1814
1815 dnl ****************************************
1816 dnl *** GLib POLL* compatibility defines ***
1817 dnl ****************************************
1818
1819 glib_poll_includes=["
1820 #include <sys/types.h>
1821 #include <sys/poll.h>
1822 "]
1823
1824 if test $ac_cv_header_sys_types_h = yes &&
1825    test $ac_cv_header_sys_poll_h = yes ; then
1826   glib_failed=false
1827   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
1828   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
1829   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
1830   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
1831   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
1832   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
1833   if $glib_failed ; then
1834     AC_MSG_ERROR([Could not determine values for POLL* constants])
1835   fi
1836 else
1837   glib_cv_value_POLLIN=1
1838   glib_cv_value_POLLOUT=4
1839   glib_cv_value_POLLPRI=2
1840   glib_cv_value_POLLERR=8
1841   glib_cv_value_POLLHUP=16
1842   glib_cv_value_POLLNVAL=32
1843 fi
1844
1845 dnl **********************
1846 dnl *** Win32 API libs ***
1847 dnl **********************
1848
1849 case $host in
1850   *-*-cygwin*)
1851         G_LIBS_EXTRA="-luser32 -lkernel32"
1852     ;;
1853   *-*-mingw*)
1854         G_LIBS_EXTRA="-lwsock32"
1855     ;;
1856   *)
1857         G_LIBS_EXTRA=""
1858     ;;
1859 esac
1860 AC_SUBST(G_LIBS_EXTRA)
1861
1862 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1863 dnl since we need it for g_iconv()
1864
1865 AC_MSG_CHECKING([for EILSEQ])
1866 AC_TRY_COMPILE([
1867 #include <errno.h>
1868 ],
1869 [
1870 int error = EILSEQ;
1871 ], have_eilseq=yes, have_eilseq=no);
1872 AC_MSG_RESULT($have_eilseq)
1873
1874 dnl ******************************************************************
1875 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1876 dnl ******************************************************************
1877
1878 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1879
1880 if test $cross_compiling = yes; then
1881   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1882   if test x$GLIB_GENMARSHAL = xno; then
1883     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1884   fi
1885 fi
1886
1887 dnl **************************
1888 dnl *** Checks for gtk-doc ***
1889 dnl **************************
1890
1891 GTK_DOC_CHECK([1.0])
1892
1893 dnl ******************************
1894 dnl *** output the whole stuff ***
1895 dnl ******************************
1896
1897 dnl this section will only be run if config.status is invoked with no
1898 dnl arguments, or with "glibconfig.h" as an argument.
1899 AC_CONFIG_COMMANDS([glibconfig.h],
1900 [
1901         outfile=glibconfig.h-tmp
1902         cat > $outfile <<\_______EOF
1903 /* glibconfig.h
1904  *
1905  * This is a generated file.  Please modify 'configure.in'
1906  */
1907
1908 #ifndef __G_LIBCONFIG_H__
1909 #define __G_LIBCONFIG_H__
1910
1911 #include <glib/gmacros.h>
1912
1913 _______EOF
1914
1915         if test x$glib_limits_h = xyes; then
1916           echo '#include <limits.h>' >> $outfile
1917         fi
1918         if test x$glib_float_h = xyes; then
1919           echo '#include <float.h>' >> $outfile
1920         fi
1921         if test x$glib_values_h = xyes; then
1922           echo '#include <values.h>' >> $outfile
1923         fi
1924         if test "$glib_header_alloca_h" = "yes"; then
1925           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1926         fi
1927         if test x$glib_sys_poll_h = xyes; then
1928           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1929         fi
1930
1931         cat >> $outfile <<_______EOF
1932
1933 G_BEGIN_DECLS
1934
1935 #define G_MINFLOAT      $glib_mf
1936 #define G_MAXFLOAT      $glib_Mf
1937 #define G_MINDOUBLE     $glib_md
1938 #define G_MAXDOUBLE     $glib_Md
1939 #define G_MINSHORT      $glib_ms
1940 #define G_MAXSHORT      $glib_Ms
1941 #define G_MAXUSHORT     $glib_Mus
1942 #define G_MININT        $glib_mi
1943 #define G_MAXINT        $glib_Mi
1944 #define G_MAXUINT       $glib_Mui
1945 #define G_MINLONG       $glib_ml
1946 #define G_MAXLONG       $glib_Ml
1947 #define G_MAXULONG      $glib_Mul
1948
1949 #define G_MININT64      ((gint64)  0x8000000000000000)
1950 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1951 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1952
1953 _______EOF
1954
1955
1956         ### this should always be true in a modern C/C++ compiler
1957         cat >>$outfile <<_______EOF
1958 typedef signed char gint8;
1959 typedef unsigned char guint8;
1960 _______EOF
1961
1962
1963         if test -n "$gint16"; then
1964           cat >>$outfile <<_______EOF
1965 typedef signed $gint16 gint16;
1966 typedef unsigned $gint16 guint16;
1967 #define G_GINT16_FORMAT $gint16_format
1968 #define G_GUINT16_FORMAT $guint16_format
1969 _______EOF
1970         fi
1971
1972
1973         if test -n "$gint32"; then
1974           cat >>$outfile <<_______EOF
1975 typedef signed $gint32 gint32;
1976 typedef unsigned $gint32 guint32;
1977 #define G_GINT32_FORMAT $gint32_format
1978 #define G_GUINT32_FORMAT $guint32_format
1979 _______EOF
1980         fi
1981
1982         cat >>$outfile <<_______EOF
1983 #define G_HAVE_GINT64 1          /* deprecated, always true */
1984
1985 ${glib_extension}typedef signed $gint64 gint64;
1986 ${glib_extension}typedef unsigned $gint64 guint64;
1987
1988 #define G_GINT64_CONSTANT(val)  $gint64_constant
1989 _______EOF
1990
1991         if test x$gint64_format != x ; then
1992           cat >>$outfile <<_______EOF
1993 #define G_GINT64_FORMAT $gint64_format
1994 #define G_GUINT64_FORMAT $guint64_format
1995 _______EOF
1996         else
1997           cat >>$outfile <<_______EOF
1998 #undef G_GINT64_FORMAT
1999 #undef G_GUINT64_FORMAT
2000 _______EOF
2001         fi
2002
2003         cat >>$outfile <<_______EOF
2004
2005 #define GLIB_SIZEOF_VOID_P $glib_void_p
2006 #define GLIB_SIZEOF_LONG   $glib_long
2007 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2008
2009 _______EOF
2010
2011 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
2012 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
2013
2014         if test -z "$glib_unknown_void_p"; then
2015           cat >>$outfile <<_______EOF
2016
2017 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2018 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2019
2020 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2021 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2022 _______EOF
2023         else
2024           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2025         fi
2026
2027
2028
2029         cat >>$outfile <<_______EOF
2030 $glib_atexit
2031 $glib_memmove
2032 $glib_defines
2033 $glib_os
2034
2035 $glib_vacopy
2036
2037 #ifdef  __cplusplus
2038 #define G_HAVE_INLINE   1
2039 #else   /* !__cplusplus */
2040 $glib_inline
2041 #endif  /* !__cplusplus */
2042
2043 _______EOF
2044
2045         if test x$g_have_iso_c_varargs = xyes ; then
2046                 cat >>$outfile <<_______EOF
2047 #ifndef __cplusplus
2048 # define G_HAVE_ISO_VARARGS 1
2049 #endif
2050 _______EOF
2051         fi
2052         if test x$g_have_iso_cxx_varargs = xyes ; then
2053                 cat >>$outfile <<_______EOF
2054 #ifdef __cplusplus
2055 # define G_HAVE_ISO_VARARGS 1
2056 #endif
2057 _______EOF
2058         fi
2059         if test x$g_have_gnuc_varargs = xyes ; then
2060                 cat >>$outfile <<_______EOF
2061
2062 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2063  * is passed ISO vararg support is turned off, and there is no work
2064  * around to turn it on, so we unconditionally turn it off.
2065  */
2066 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2067 #  undef G_HAVE_ISO_VARARGS
2068 #endif
2069
2070 #define G_HAVE_GNUC_VARARGS 1
2071 _______EOF
2072         fi
2073
2074         case x$g_stack_grows in
2075         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2076         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2077         esac
2078
2079
2080         echo >>$outfile
2081         if test x$g_have_eilseq = xno; then
2082                 cat >>$outfile <<_______EOF
2083 #ifndef EILSEQ
2084 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2085  * The correspondence between this and the corresponding definition
2086  * in libiconv is essential.
2087  */
2088 #  define EILSEQ ENOENT
2089 #endif
2090 _______EOF
2091
2092         fi
2093
2094         echo >>$outfile
2095         if test x$g_mutex_has_default = xyes; then
2096                 cat >>$outfile <<_______EOF
2097 $g_enable_threads_def G_THREADS_ENABLED
2098 #define G_THREADS_IMPL_$g_threads_impl_def
2099 typedef struct _GStaticMutex GStaticMutex;
2100 struct _GStaticMutex
2101 {
2102   struct _GMutex *runtime_mutex;
2103   union {
2104     char   pad[[$g_mutex_sizeof]];
2105     double dummy_double;
2106     void  *dummy_pointer;
2107     long   dummy_long;
2108   } static_mutex;
2109 };
2110 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2111 #define g_static_mutex_get_mutex(mutex) \
2112   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
2113    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
2114 _______EOF
2115         else
2116                 cat >>$outfile <<_______EOF
2117 $g_enable_threads_def G_THREADS_ENABLED
2118 #define G_THREADS_IMPL_$g_threads_impl_def
2119 typedef struct _GMutex* GStaticMutex;
2120 #define G_STATIC_MUTEX_INIT NULL
2121 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
2122 _______EOF
2123         fi
2124
2125         cat >>$outfile <<_______EOF
2126 /* This represents a system thread as used by the implementation. An
2127  * alien implementaion, as loaded by g_thread_init can only count on
2128  * "sizeof (gpointer)" bytes to store their info. We however need more
2129  * for some of our native implementations. */
2130 typedef union _GSystemThread GSystemThread;
2131 union _GSystemThread
2132 {
2133   char   data[[$g_system_thread_sizeof]];
2134   double dummy_double;
2135   void  *dummy_pointer;
2136   long   dummy_long;
2137 };
2138 _______EOF
2139
2140         echo >>$outfile
2141         g_bit_sizes="16 32 64"
2142         for bits in $g_bit_sizes; do
2143           cat >>$outfile <<_______EOF
2144 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2145 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2146 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2147 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2148 _______EOF
2149         done
2150
2151         cat >>$outfile <<_______EOF
2152 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2153 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2154 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2155 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2156 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2157 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2158 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2159 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2160 #define G_BYTE_ORDER $g_byte_order
2161
2162 #define GLIB_SYSDEF_POLLIN =$g_pollin
2163 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2164 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2165 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2166 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2167 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2168
2169 #define G_MODULE_SUFFIX "$g_module_suffix"
2170
2171 G_END_DECLS
2172
2173 #endif /* GLIBCONFIG_H */
2174 _______EOF
2175
2176
2177         if cmp -s $outfile glibconfig.h; then
2178           AC_MSG_NOTICE([glibconfig.h is unchanged])
2179           rm -f $outfile
2180         else
2181           mv $outfile glibconfig.h
2182         fi
2183 ],[
2184
2185 # Note that if two cases are the same, case goes with the first one.
2186 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2187 # on variable expansion in case labels.  Look at the generated config.status
2188 # for a hint.
2189
2190 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2191   glib_header_alloca_h="$ac_cv_working_alloca_h"
2192 else
2193   glib_header_alloca_h="$ac_cv_header_alloca_h"
2194 fi
2195
2196 case xyes in
2197 x$ac_cv_header_float_h)
2198   glib_float_h=yes
2199   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2200   glib_md=DBL_MIN glib_Md=DBL_MAX
2201   ;;
2202 x$ac_cv_header_values_h)
2203   glib_values_h=yes
2204   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2205   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2206   ;;
2207 esac
2208
2209 case xyes in
2210 x$ac_cv_header_limits_h)
2211   glib_limits_h=yes
2212   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2213   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2214   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2215   ;;
2216 x$ac_cv_header_values_h)
2217   glib_values_h=yes
2218   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2219   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2220   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2221   ;;
2222 esac
2223
2224 if test x$ac_cv_header_sys_poll_h = xyes ; then
2225   glib_sys_poll_h=yes
2226 fi
2227
2228 case 2 in
2229 $ac_cv_sizeof_short)
2230   gint16=short
2231   gint16_format='"hi"'
2232   guint16_format='"hu"'
2233   ;;
2234 $ac_cv_sizeof_int)
2235   gint16=int
2236   gint16_format='"i"'
2237   guint16_format='"u"'
2238   ;;
2239 esac
2240 case 4 in
2241 $ac_cv_sizeof_short)
2242   gint32=short
2243   gint32_format='"hi"'
2244   guint32_format='"hu"'
2245   ;;
2246 $ac_cv_sizeof_int)
2247   gint32=int
2248   gint32_format='"i"'
2249   guint32_format='"u"'
2250   ;;
2251 $ac_cv_sizeof_long)
2252   gint32=long
2253   gint32_format='"li"'
2254   guint32_format='"lu"'
2255   ;;
2256 esac
2257 case 8 in
2258 $ac_cv_sizeof_int)
2259   gint64=int
2260   gint64_format='"i"'
2261   guint64_format='"u"'
2262   glib_extension=
2263   gint64_constant='(val)'
2264   ;;
2265 $ac_cv_sizeof_long)
2266   gint64=long
2267   gint64_format='"li"'
2268   guint64_format='"lu"'
2269   glib_extension=
2270   gint64_constant='(val##L)'
2271   ;;
2272 $ac_cv_sizeof_long_long)
2273   gint64='long long'
2274   if test -n "$glib_cv_long_long_format"; then
2275     gint64_format='"'$glib_cv_long_long_format'i"'
2276     guint64_format='"'$glib_cv_long_long_format'u"'
2277   fi
2278   glib_extension='G_GNUC_EXTENSION '
2279   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2280   ;;
2281 $ac_cv_sizeof___int64)
2282   gint64='__int64'
2283   if test -n "$glib_cv_long_long_format"; then
2284     gint64_format='"'$glib_cv_long_long_format'i"'
2285     guint64_format='"'$glib_cv_long_long_format'u"'
2286   fi
2287   glib_extension=
2288   gint64_constant='(val##i64)'
2289   ;;
2290 esac
2291 glib_size_t=$ac_cv_sizeof_size_t
2292 glib_size_type_define=$glib_size_type
2293 glib_void_p=$ac_cv_sizeof_long
2294 glib_long=$ac_cv_sizeof_void_p
2295
2296 gintbits=`expr $ac_cv_sizeof_int \* 8`
2297 glongbits=`expr $ac_cv_sizeof_long \* 8`
2298
2299
2300 case $ac_cv_sizeof_void_p in
2301 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2302 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2303 *)                      glib_unknown_void_p=yes ;;
2304 esac
2305
2306
2307 case xyes in
2308 x$ac_cv_func_atexit)
2309   glib_atexit="
2310 #ifdef NeXT /* @#%@! NeXTStep */
2311 # define g_ATEXIT(proc) (!atexit (proc))
2312 #else
2313 # define g_ATEXIT(proc) (atexit (proc))
2314 #endif"
2315   ;;
2316 x$ac_cv_func_on_exit)
2317   glib_atexit="
2318 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2319   ;;
2320 esac
2321
2322 case xyes in
2323 x$ac_cv_func_memmove)
2324   glib_memmove='
2325 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2326   ;;
2327 x$glib_cv_working_bcopy)
2328   glib_memmove="
2329 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2330 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2331   ;;
2332 *)
2333   glib_memmove="
2334 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2335  * so we have to roll our own copy routine. */
2336 void g_memmove (void* dest, const void * src, unsigned long len);"
2337   ;;
2338 esac
2339
2340 glib_defines="
2341 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2342 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2343 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2344 "
2345
2346 case xyes in
2347 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2348 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2349 *)                      glib_vacopy=''
2350 esac
2351
2352 if test x$glib_cv_va_val_copy = xno; then
2353   glib_vacopy="\$glib_vacopy
2354 #define G_VA_COPY_AS_ARRAY 1"
2355 fi
2356
2357 if test x$glib_cv_hasinline = xyes; then
2358     glib_inline='#define G_HAVE_INLINE 1'
2359 fi
2360 if test x$glib_cv_has__inline = xyes; then
2361     glib_inline="\$glib_inline
2362 #define G_HAVE___INLINE 1"
2363 fi
2364 if test x$glib_cv_has__inline__ = xyes; then
2365     glib_inline="\$glib_inline
2366 #define G_HAVE___INLINE__ 1"
2367 fi
2368
2369 g_have_gnuc_varargs=$g_have_gnuc_varargs
2370 g_have_iso_c_varargs=$g_have_iso_c_varargs
2371 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2372
2373 case xyes in
2374 x$ac_cv_c_bigendian)
2375   g_byte_order=G_BIG_ENDIAN
2376   g_bs_native=BE
2377   g_bs_alien=LE
2378   ;;
2379 *)
2380   g_byte_order=G_LITTLE_ENDIAN
2381   g_bs_native=LE
2382   g_bs_alien=BE
2383   ;;
2384 esac
2385
2386 g_pollin=$glib_cv_value_POLLIN
2387 g_pollout=$glib_cv_value_POLLOUT
2388 g_pollpri=$glib_cv_value_POLLPRI
2389 g_pollhup=$glib_cv_value_POLLHUP
2390 g_pollerr=$glib_cv_value_POLLERR
2391 g_pollnval=$glib_cv_value_POLLNVAL
2392
2393 g_stack_grows=$glib_cv_stack_grows
2394
2395 g_have_eilseq=$have_eilseq
2396
2397 case x$have_threads in
2398 xno)    g_enable_threads_def="#undef";;
2399 *)      g_enable_threads_def="#define";;
2400 esac
2401
2402 g_threads_impl_def=$g_threads_impl
2403
2404 g_mutex_has_default="$mutex_has_default"
2405 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2406 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2407 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2408
2409 g_module_suffix="$glib_gmodule_suffix"
2410
2411 case $host in
2412   *-*-beos*)
2413     glib_os="#define G_OS_BEOS"
2414     ;;
2415   *-*-cygwin*)
2416     glib_os="#define G_OS_UNIX
2417 #define G_PLATFORM_WIN32
2418 #define G_WITH_CYGWIN"
2419     ;;
2420   *-*-mingw*)
2421     glib_os="#define G_OS_WIN32
2422 #define G_PLATFORM_WIN32"
2423     ;;
2424   *)
2425     glib_os="#define G_OS_UNIX"
2426     ;;
2427 esac
2428 ])
2429
2430 AC_CONFIG_FILES([
2431 glib-2.0.pc
2432 glib-2.0-uninstalled.pc
2433 gmodule-2.0.pc
2434 gmodule-2.0-uninstalled.pc
2435 gthread-2.0.pc
2436 gthread-2.0-uninstalled.pc
2437 gobject-2.0.pc
2438 gobject-2.0-uninstalled.pc
2439 glib-zip
2440 glib-gettextize
2441 Makefile
2442 build/Makefile
2443 build/win32/Makefile
2444 build/win32/dirent/Makefile
2445 glib/Makefile
2446 glib/libcharset/Makefile
2447 glib/trio/Makefile
2448 gmodule/Makefile
2449 gmodule/gmoduleconf.h
2450 gobject/Makefile
2451 gobject/glib-mkenums
2452 gthread/Makefile
2453 po/Makefile.in
2454 docs/Makefile
2455 docs/reference/Makefile
2456 docs/reference/glib/Makefile
2457 docs/reference/glib/version.xml
2458 docs/reference/gobject/Makefile
2459 docs/reference/gobject/version.xml
2460 tests/Makefile
2461 m4macros/Makefile
2462 ])
2463
2464 AC_CONFIG_COMMANDS([chmod-scripts],
2465 [chmod 0755 glib-zip
2466 chmod 0755 glib-gettextize
2467 chmod 0755 gobject/glib-mkenums])
2468
2469 # we want to invoke this macro solely so that the config.status script
2470 # and automake generated makefiles know about these generated files.
2471 # They are only needed to distcheck the package
2472 if false; then
2473   AC_CONFIG_FILES([
2474     INSTALL
2475     README
2476     config.h.win32
2477     glibconfig.h.win32
2478     glib/makefile.mingw
2479     glib/makefile.msc
2480     glib/glib.rc
2481     gmodule/makefile.mingw
2482     gmodule/makefile.msc
2483     gmodule/gmodule.rc
2484     gobject/makefile.mingw
2485     gobject/makefile.msc
2486     gobject/gobject.rc
2487     gthread/makefile.mingw
2488     gthread/makefile.msc
2489     gthread/gthread.rc
2490     tests/makefile.mingw
2491     tests/makefile.msc
2492   ])
2493 fi
2494
2495 AC_OUTPUT