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