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
  11 #
  12 # The following version number definitions apply to GLib, GModule, GObject,
  13 # GThread and GIO as a whole, so if changes occurred in any of them, they are
  14 # all treated with the same interface and binary age.
  15 #
  16 # Making releases:
  17 #   glib_micro_version += 1;
  18 #   glib_interface_age += 1;
  19 #   glib_binary_age += 1;
  20 # if any functions have been added, set glib_interface_age to 0.
  21 # if backwards compatibility has been broken,
  22 # set glib_binary_age _and_ glib_interface_age to 0.
  23 #
  24 m4_define([glib_major_version], [2])
  25 m4_define([glib_minor_version], [20])
  26 m4_define([glib_micro_version], [2])
  27 m4_define([glib_interface_age], [2])
  28 m4_define([glib_binary_age],
  29           [m4_eval(100 * glib_minor_version + glib_micro_version)])
  30 m4_define([glib_version],
  31           [glib_major_version.glib_minor_version.glib_micro_version])
  32
  33 # libtool version related macros
  34 m4_define([glib_lt_release], [glib_major_version.glib_minor_version])
  35 m4_define([glib_lt_current],
  36           [m4_eval(100 * glib_minor_version + glib_micro_version - glib_interface_age)])
  37 m4_define([glib_lt_revision], [glib_interface_age])
  38 m4_define([glib_lt_age], [m4_eval(glib_binary_age - glib_interface_age)])
  39 m4_define([glib_lt_current_minus_age],
  40           [m4_eval(glib_lt_current - glib_lt_age)])
  41
  42 # if the minor version number is odd, then we want debugging.  Otherwise
  43 # we only want minimal debugging support.
  44 m4_define([glib_debug_default],
  45           [m4_if(m4_eval(glib_minor_version % 2), [1], [yes], [minimum])])dnl
  46
  47
  48 AC_INIT(glib, [glib_version],
  49         [http://bugzilla.gnome.org/enter_bug.cgi?product=glib])
  50
  51 AC_CONFIG_SRCDIR([glib/glib.h])
  52
  53 # Save this value here, since automake will set cflags later
  54 cflags_set=${CFLAGS+set}
  55
  56 AM_INIT_AUTOMAKE([no-define])
  57
  58 # Specify a configuration file
  59 AM_CONFIG_HEADER([config.h])
  60
  61
  62 GLIB_MAJOR_VERSION=glib_major_version
  63 GLIB_MINOR_VERSION=glib_minor_version
  64 GLIB_MICRO_VERSION=glib_micro_version
  65 GLIB_INTERFACE_AGE=glib_interface_age
  66 GLIB_BINARY_AGE=glib_binary_age
  67 GLIB_VERSION=glib_version
  68
  69 AC_SUBST(GLIB_MAJOR_VERSION)
  70 AC_SUBST(GLIB_MINOR_VERSION)
  71 AC_SUBST(GLIB_MICRO_VERSION)
  72 AC_SUBST(GLIB_VERSION)
  73 AC_SUBST(GLIB_INTERFACE_AGE)
  74 AC_SUBST(GLIB_BINARY_AGE)
  75
  76 AC_DEFINE(GLIB_MAJOR_VERSION, [glib_major_version],
  77           [Define to the GLIB major version])
  78 AC_DEFINE(GLIB_MINOR_VERSION, [glib_minor_version],
  79           [Define to the GLIB minor version])
  80 AC_DEFINE(GLIB_MICRO_VERSION, [glib_micro_version],
  81           [Define to the GLIB micro version])
  82 AC_DEFINE(GLIB_INTERFACE_AGE, [glib_interface_age],
  83           [Define to the GLIB interface age])
  84 AC_DEFINE(GLIB_BINARY_AGE, [glib_binary_age],
  85           [Define to the GLIB binary age])
  86
  87 # libtool versioning
  88 LT_RELEASE=glib_lt_release
  89 LT_CURRENT=glib_lt_current
  90 LT_REVISION=glib_lt_revision
  91 LT_AGE=glib_lt_age
  92 LT_CURRENT_MINUS_AGE=glib_lt_current_minus_age
  93 AC_SUBST(LT_RELEASE)
  94 AC_SUBST(LT_CURRENT)
  95 AC_SUBST(LT_REVISION)
  96 AC_SUBST(LT_AGE)
  97 AC_SUBST(LT_CURRENT_MINUS_AGE)
  98
  99 dnl Initialize maintainer mode
 100 AM_MAINTAINER_MODE
 101
 102 AC_CANONICAL_HOST
 103
 104 AC_MSG_CHECKING([for the BeOS])
 105 case $host in
 106   *-*-beos*)
 107     glib_native_beos="yes"
 108     ;;
 109   *)
 110     glib_native_beos="no"
 111     ;;
 112 esac
 113 AC_MSG_RESULT([$glib_native_beos])
 114
 115 dnl
 116
 117 AC_MSG_CHECKING([for Win32])
 118 LIB_EXE_MACHINE_FLAG=X86
 119 case "$host" in
 120   *-*-mingw*)
 121     glib_native_win32=yes
 122     glib_pid_type='void *'
 123     glib_cv_stack_grows=no
 124     # Unfortunately the mingw implementations of C99-style snprintf and vsnprintf
 125     # don't seem to be quite good enough, at least not in mingw-runtime-3.14.
 126     # (Sorry, I don't know exactly what is the problem, but it is related to
 127     # floating point formatting and decimal point vs. comma.)
 128     # The simple tests in AC_FUNC_VSNPRINTF_C99 and AC_FUNC_SNPRINTF_C99 aren't
 129     # rigorous enough to notice, though.
 130     # So preset the autoconf cache variables.
 131     ac_cv_func_vsnprintf_c99=no
 132     ac_cv_func_snprintf_c99=no
 133     case "$host" in
 134     x86_64-*-*)
 135       LIB_EXE_MACHINE_FLAG=X64
 136       ;;
 137     esac
 138     ;;
 139   *)
 140     glib_native_win32=no
 141     glib_pid_type=int
 142     ;;
 143 esac
 144 case $host in
 145   *-*-linux*)
 146     glib_os_linux=yes
 147     ;;
 148 esac
 149
 150 AC_MSG_RESULT([$glib_native_win32])
 151
 152 AC_SUBST(LIB_EXE_MACHINE_FLAG)
 153
 154 glib_have_carbon=no
 155 AC_MSG_CHECKING([for Mac OS X Carbon support])
 156 AC_TRY_CPP([
 157 #include <Carbon/Carbon.h>
 158 #include <CoreServices/CoreServices.h>
 159 ], glib_have_carbon=yes)
 160
 161 AC_MSG_RESULT([$glib_have_carbon])
 162
 163 AM_CONDITIONAL(OS_WIN32, [test "$glib_native_win32" = "yes"])
 164 AM_CONDITIONAL(OS_WIN32_X64, [test "$LIB_EXE_MACHINE_FLAG" = "X64"])
 165 AM_CONDITIONAL(OS_UNIX, [test "$glib_native_win32" != "yes"])
 166 AM_CONDITIONAL(OS_LINUX, [test "$glib_os_linux" = "yes"])
 167 AM_CONDITIONAL(OS_CARBON, [test "$glib_have_carbon" = "yes"])
 168
 169 if test "$glib_native_win32" = "yes"; then
 170   AC_CHECK_TOOL(WINDRES, windres, no)
 171   if test "$WINDRES" = no; then
 172     AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
 173   fi
 174   AC_CHECK_TOOL(NM, nm, no)
 175   if test "$NM" = no; then
 176     AC_MSG_ERROR([*** Could not find an implementation of nm in your PATH.])
 177   fi
 178   AC_CHECK_TOOL(RANLIB, ranlib, :)
 179   AC_CHECK_PROG(ms_librarian, [lib.exe], [yes], [no])
 180 fi
 181 AM_CONDITIONAL(MS_LIB_AVAILABLE, [test x$ms_librarian = xyes])
 182
 183 if test "$glib_native_win32" != yes; then
 184     # libtool option to control which symbols are exported
 185     # right now, symbols starting with _ are not exported
 186     LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^g.*"'
 187 else
 188     # We currently use .def files on Windows
 189     LIBTOOL_EXPORT_OPTIONS=
 190 fi
 191 AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
 192
 193 if test "x$glib_have_carbon" = "xyes"; then
 194   AC_DEFINE(HAVE_CARBON, 1, [define to 1 if Carbon is available])
 195   LDFLAGS="$LDFLAGS -framework Carbon"
 196 fi
 197
 198
 199 dnl declare --enable-* args and collect ac_help strings
 200 AC_ARG_ENABLE(debug,
 201               AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
 202                              [turn on debugging @<:@default=glib_debug_default@:>@]),,
 203               enable_debug=glib_debug_default)
 204
 205 AC_ARG_ENABLE(gc_friendly,
 206               [AC_HELP_STRING([--enable-gc-friendly],
 207                               [turn on garbage collector friendliness [default=no]])],,
 208               [enable_gc_friendly=no])
 209 AC_ARG_ENABLE(mem_pools,
 210               [AC_HELP_STRING([--disable-mem-pools],
 211                               [disable all glib memory pools])],,
 212               [disable_mem_pools=no])
 213 AC_ARG_ENABLE(threads,
 214               [AC_HELP_STRING([--enable-threads],
 215                               [turn on basic thread support [default=yes]
 216 ([=no] will override --with-threads)])],,
 217               [enable_threads=yes])
 218 AC_ARG_ENABLE(rebuilds,
 219               [AC_HELP_STRING([--disable-rebuilds],
 220                               [disable all source autogeneration rules])],,
 221               [enable_rebuilds=yes])
 222 AC_ARG_ENABLE(visibility,
 223               [AC_HELP_STRING([--disable-visibility],
 224                               [don't use ELF visibility attributes])],,
 225               [enable_visibility=yes])
 226
 227 if test "x$enable_threads" != "xyes"; then
 228   enable_threads=no
 229 fi
 230
 231 AC_MSG_CHECKING([whether to enable garbage collector friendliness])
 232 if test "x$enable_gc_friendly" = "xyes"; then
 233   AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
 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 dnl Checks for programs.
 249 AC_PROG_CC
 250 AC_PROG_CPP
 251
 252 dnl Check for a working C++ compiler, but do not bail out, if none is found.
 253 AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], [gcc])
 254 AC_LANG_SAVE
 255 AC_LANG_CPLUSPLUS
 256 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
 257 AM_CONDITIONAL(HAVE_CXX, [test "$CXX" != ""])
 258 AC_LANG_RESTORE
 259
 260 AM_PROG_CC_STDC
 261 AM_PROG_CC_C_O
 262 AC_PROG_INSTALL
 263
 264 AC_SYS_LARGEFILE
 265
 266 #
 267 # Find pkg-config
 268 #
 269 AC_PATH_PROG(PKG_CONFIG, [pkg-config], [no])
 270 if test x$PKG_CONFIG = xno ; then
 271   AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
 272 fi
 273
 274 if $PKG_CONFIG --atleast-pkgconfig-version 0.16 ; then
 275   :
 276 else
 277   AC_MSG_ERROR([*** pkg-config too old; version 0.16 or better required.])
 278 fi
 279
 280 if test "x$enable_debug" = "xyes"; then
 281   if test x$cflags_set != xset ; then
 282       case " $CFLAGS " in
 283       *[[\ \    ]]-g[[\ \       ]]*) ;;
 284       *) CFLAGS="$CFLAGS -g" ;;
 285       esac
 286   fi
 287
 288   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 289 else
 290   GLIB_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
 291
 292   if test "x$enable_debug" = "xno"; then
 293     GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 294   fi
 295 fi
 296
 297 if test "x$enable_visibility" = "xno"; then
 298   GLIB_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DDISABLE_VISIBILITY"
 299 fi
 300
 301 # Ensure MSVC-compatible struct packing convention is used when
 302 # compiling for Win32 with gcc.
 303 # What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
 304 # gcc2 uses "-fnative-struct".
 305 if test x"$glib_native_win32" = xyes; then
 306   if test x"$GCC" = xyes; then
 307     msnative_struct=''
 308     AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
 309     if test -z "$ac_cv_prog_CC"; then
 310       our_gcc="$CC"
 311     else
 312       our_gcc="$ac_cv_prog_CC"
 313     fi
 314     case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
 315       2.)
 316         if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
 317           msnative_struct='-fnative-struct'
 318         fi
 319         ;;
 320       *)
 321         if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
 322           msnative_struct='-mms-bitfields'
 323         fi
 324         ;;
 325     esac
 326     if test x"$msnative_struct" = x ; then
 327       AC_MSG_RESULT([no way])
 328       AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
 329     else
 330       CFLAGS="$CFLAGS $msnative_struct"
 331       AC_MSG_RESULT([${msnative_struct}])
 332     fi
 333   fi
 334 fi
 335 GLIB_EXTRA_CFLAGS="${msnative_struct}"
 336 AC_SUBST(GLIB_EXTRA_CFLAGS)
 337
 338 AC_EXEEXT
 339
 340 # define a MAINT-like variable REBUILD which is set if Perl
 341 # and awk are found, so autogenerated sources can be rebuilt
 342 AC_PROG_AWK
 343 AC_CHECK_PROGS(PERL, [perl5 perl])
 344 # We would like indent, but don't require it.
 345 AC_CHECK_PROG(INDENT, indent, indent)
 346 REBUILD=\#
 347 if test "x$enable_rebuilds" = "xyes" && \
 348      test -n "$PERL" && \
 349      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 350      test -n "$AWK" ; then
 351   REBUILD=
 352 fi
 353 AC_SUBST(REBUILD)
 354
 355 # Need full path to Perl for glib-mkenums
 356 #
 357 if test "x$PERL" != x ; then
 358   AC_PATH_PROG(PERL_PATH, [$PERL])
 359 fi
 360 if test "x$PERL_PATH" = x ; then
 361   PERL_PATH="/usr/bin/env perl"
 362 fi
 363 AC_SUBST(PERL_PATH)
 364
 365 # Need suitable python path for greport
 366 AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
 367
 368
 369 dnl ***********************
 370 dnl *** Tests for iconv ***
 371 dnl ***********************
 372 dnl
 373 dnl We do this before the gettext checks, to avoid distortion
 374
 375 dnl On Windows we use a native implementation
 376
 377 if test x"$glib_native_win32" = xyes; then
 378   with_libiconv=native
 379 else
 380   AC_ARG_WITH(libiconv,
 381               [AC_HELP_STRING([--with-libiconv=@<:@no/gnu/native@:>@],
 382                               [use the libiconv library])],,
 383               [with_libiconv=maybe])
 384
 385   found_iconv=no
 386   case $with_libiconv in
 387     maybe)
 388       # Check in the C library first
 389       AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
 390       # Check if we have GNU libiconv
 391       if test $found_iconv = "no"; then
 392         AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
 393       fi
 394       # Check if we have a iconv in -liconv, possibly from vendor
 395       if test $found_iconv = "no"; then
 396         AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
 397       fi
 398       ;;
 399     no)
 400       AC_CHECK_FUNC(iconv_open, [with_libiconv=no; found_iconv=yes])
 401       ;;
 402     gnu|yes)
 403       AC_CHECK_LIB(iconv, libiconv_open, [with_libiconv=gnu; found_iconv=yes])
 404       ;;
 405     native)
 406       AC_CHECK_LIB(iconv, iconv_open, [with_libiconv=native; found_iconv=yes])
 407       ;;
 408   esac
 409
 410   if test "x$found_iconv" = "xno" ; then
 411      AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
 412   fi
 413 fi
 414
 415 gl_GLIBC21
 416 AC_ARG_ENABLE(iconv-cache,
 417               [AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
 418                               [cache iconv descriptors [default=auto]])],,
 419               [enable_iconv_cache=auto])
 420
 421 AC_MSG_CHECKING([Whether to cache iconv descriptors])
 422 case $enable_iconv_cache in
 423   auto)
 424     if test $ac_cv_gnu_library_2_1 = yes; then
 425       enable_iconv_cache=no
 426     else
 427       enable_iconv_cache=yes
 428     fi
 429   ;;
 430   yes|no)
 431   ;;
 432   *) AC_MSG_ERROR([Value given to --enable-iconv-cache must be one of yes, no or auto])
 433   ;;
 434 esac
 435
 436 if test $enable_iconv_cache = yes; then
 437    AC_DEFINE(NEED_ICONV_CACHE,1,[Do we cache iconv descriptors])
 438 fi
 439
 440 AC_MSG_RESULT($enable_iconv_cache)
 441
 442
 443 dnl
 444 dnl gettext support
 445 dnl
 446
 447 ALL_LINGUAS="`grep -v '^#' "$srcdir/po/LINGUAS" | tr '\n' ' '`"
 448 AC_SUBST([CONFIG_STATUS_DEPENDENCIES],['$(top_srcdir)/po/LINGUAS'])
 449 GLIB_GNU_GETTEXT
 450
 451 if test "$gt_cv_have_gettext" != "yes" ; then
 452   AC_MSG_ERROR([
 453 *** You must have either have gettext support in your C library, or use the
 454 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
 455 ])
 456 fi
 457
 458 LIBS="$INTLLIBS $LIBS"
 459
 460 GETTEXT_PACKAGE=glib20
 461 AC_SUBST(GETTEXT_PACKAGE)
 462 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, ["$GETTEXT_PACKAGE"],
 463   [Define the gettext package to be used])
 464
 465 GLIB_DEFINE_LOCALEDIR(GLIB_LOCALE_DIR)
 466
 467 dnl
 468 dnl Now we are done with gettext checks, figure out ICONV_LIBS
 469 dnl
 470
 471 if test x"$glib_native_win32" != xyes; then
 472   if test x$with_libiconv != xno ; then
 473     case " $INTLLIBS " in
 474     *[[\ \      ]]-liconv[[\ \  ]]*) ;;
 475     *) ICONV_LIBS="-liconv" ;;
 476     esac
 477   fi
 478 fi
 479 AC_SUBST(ICONV_LIBS)
 480
 481 case $with_libiconv in
 482   gnu)
 483     AC_DEFINE(USE_LIBICONV_GNU, 1, [Using GNU libiconv])
 484     ;;
 485   native)
 486     AC_DEFINE(USE_LIBICONV_NATIVE, 1, [Using a native implementation of iconv in a separate library])
 487     ;;
 488 esac
 489
 490 dnl Initialize libtool
 491 AM_DISABLE_STATIC
 492 AC_LIBTOOL_WIN32_DLL
 493 AM_PROG_LIBTOOL
 494 dnl when using libtool 2.x create libtool early, because it's used in configure
 495 m4_ifdef([LT_OUTPUT], [LT_OUTPUT])
 496
 497
 498 if test "x$GCC" = "xyes"; then
 499   case " $CFLAGS " in
 500   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 501   *) CFLAGS="$CFLAGS -Wall" ;;
 502   esac
 503 fi
 504
 505 CPPFLAGS="$CPPFLAGS -DG_DISABLE_SINGLE_INCLUDES"
 506
 507 if test "$glib_native_win32" = "yes"; then
 508   if test x$enable_static = xyes -a x$enable_shared = xyes; then
 509     AC_MSG_ERROR([Can not build both shared and static at the same time on Windows.])
 510   fi
 511   if test x$enable_static = xyes; then
 512     glib_win32_static_compilation=yes
 513     GLIB_WIN32_STATIC_COMPILATION_DEFINE="#define GLIB_STATIC_COMPILATION 1
 514 #define GOBJECT_STATIC_COMPILATION 1"
 515     AC_SUBST(GLIB_WIN32_STATIC_COMPILATION_DEFINE)
 516   fi
 517 fi
 518 AM_CONDITIONAL(OS_WIN32_AND_DLL_COMPILATION, [test x$glib_native_win32 = xyes -a x$glib_win32_static_compilation != xyes])
 519
 520 dnl
 521 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 522 dnl
 523 if test $cross_compiling != yes ; then
 524     AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 525     glib_save_LIBS=$LIBS
 526     LIBS="$LIBS -lm"
 527     AC_TRY_RUN([#include <math.h>
 528                  int main (void) { return (log(1) != log(1.)); }],
 529          AC_MSG_RESULT(none needed),
 530          glib_save_CFLAGS=$CFLAGS
 531          CFLAGS="$CFLAGS -std1"
 532          AC_TRY_RUN([#include <math.h>
 533                      int main (void) { return (log(1) != log(1.)); }],
 534              AC_MSG_RESULT(-std1),
 535              AC_MSG_RESULT()
 536              CFLAGS=$glib_save_CFLAGS
 537              AC_MSG_WARN(
 538                     [No ANSI prototypes found in library. (-std1 didn't work.)])
 539          )
 540     )
 541     LIBS=$glib_save_LIBS
 542 fi
 543
 544 dnl NeXTStep cc seems to need this
 545 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 546 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 547   AC_MSG_RESULT(none needed),
 548   glib_save_CFLAGS=$CFLAGS
 549   CFLAGS="$CFLAGS -posix"
 550   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 551     AC_MSG_RESULT(-posix),
 552     AC_MSG_RESULT()
 553     CFLAGS=$glib_save_CFLAGS
 554     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 555
 556 # Checks for header files.
 557 AC_HEADER_STDC
 558
 559 # Checks for library functions.
 560 AC_FUNC_VPRINTF
 561 AC_FUNC_ALLOCA
 562 AC_CHECK_FUNCS(mmap)
 563 AC_CHECK_FUNCS(posix_memalign)
 564 AC_CHECK_FUNCS(memalign)
 565 AC_CHECK_FUNCS(valloc)
 566 AC_CHECK_FUNCS(fsync)
 567
 568 AC_CHECK_FUNCS(atexit on_exit)
 569
 570 AC_CHECK_FUNCS(timegm gmtime_r)
 571
 572 AC_CHECK_SIZEOF(char)
 573 AC_CHECK_SIZEOF(short)
 574 AC_CHECK_SIZEOF(long)
 575 AC_CHECK_SIZEOF(int)
 576 AC_CHECK_SIZEOF(void *)
 577 AC_CHECK_SIZEOF(long long)
 578 AC_CHECK_SIZEOF(__int64)
 579
 580 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
 581   :
 582 else
 583   AC_MSG_ERROR([
 584 *** GLib requires a 64 bit type. You might want to consider
 585 *** using the GNU C compiler.
 586 ])
 587 fi
 588
 589 if test x$glib_native_win32 != xyes && test x$ac_cv_sizeof_long_long = x8; then
 590         # long long is a 64 bit integer.
 591         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 592         AC_CACHE_VAL(glib_cv_long_long_format,[
 593                 for format in ll q I64; do
 594                   AC_TRY_RUN([#include <stdio.h>
 595                         int main()
 596                         {
 597                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 598                           char buffer[1000];
 599                           sprintf (buffer, "%${format}u", a);
 600                           sscanf (buffer, "%${format}u", &b);
 601                           exit (b!=a);
 602                         }
 603                         ],
 604                         [glib_cv_long_long_format=${format}
 605                         break],
 606                         [],[:])
 607                 done])
 608         if test -n "$glib_cv_long_long_format"; then
 609           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 610           AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
 611           if test x"$glib_cv_long_long_format" = xI64; then
 612             AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
 613           fi
 614         else
 615           AC_MSG_RESULT(none)
 616         fi
 617 elif test x$ac_cv_sizeof___int64 = x8; then
 618         # __int64 is a 64 bit integer.
 619         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 620         # We know this is MSVCRT.DLL, and what the formats are
 621         glib_cv_long_long_format=I64
 622         AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 623         AC_DEFINE(HAVE_LONG_LONG_FORMAT,1,[define if system printf can print long long])
 624         AC_DEFINE(HAVE_INT64_AND_I64,1,[define to support printing 64-bit integers with format I64])
 625 fi
 626
 627 dnl long doubles were not used, and a portability problem
 628 dnl AC_C_LONG_DOUBLE
 629 AC_C_CONST
 630
 631 dnl ok, here we try to check whether the systems prototypes for
 632 dnl malloc and friends actually match the prototypes provided
 633 dnl by gmem.h (keep in sync). i currently only know how to check
 634 dnl this reliably with gcc (-Werror), improvements for other
 635 dnl compilers are apprechiated.
 636 SANE_MALLOC_PROTOS=no
 637 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 638 glib_save_CFLAGS=$CFLAGS
 639 if test "x$GCC" = "xyes"; then
 640   CFLAGS="$CFLAGS -Werror"
 641   AC_TRY_COMPILE([#include <stdlib.h>], [
 642     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 643     void* (*my_malloc_p)  (size_t)         = malloc;
 644     void  (*my_free_p)    (void*)          = free;
 645     void* (*my_realloc_p) (void*, size_t)  = realloc;
 646     my_calloc_p = 0;
 647     my_malloc_p = 0;
 648     my_free_p = 0;
 649     my_realloc_p = 0;
 650   ],
 651     AC_DEFINE(SANE_MALLOC_PROTOS, 1,
 652       [Define if you have correct malloc prototypes])
 653     SANE_MALLOC_PROTOS=yes)
 654 fi
 655 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 656 CFLAGS=$glib_save_CFLAGS
 657
 658 dnl
 659 dnl check in which direction the stack grows
 660 dnl
 661 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
 662         AC_TRY_RUN([
 663         volatile int *a = 0, *b = 0;
 664         void foo (void);
 665         int main () { volatile int y = 7; a = &y; foo (); return b > a; }
 666         void foo (void) { volatile int x = 5; b = &x; }
 667         ],
 668         glib_cv_stack_grows=no
 669         ,
 670         glib_cv_stack_grows=yes
 671         ,)
 672 ])
 673
 674 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 675 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 676 dnl actually supported.
 677 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 678         AC_COMPILE_IFELSE([
 679         __inline int foo () { return 0; }
 680         int main () { return foo (); }
 681         ],
 682         glib_cv_has__inline=yes
 683         ,
 684         glib_cv_has__inline=no
 685         ,)
 686 ])
 687 case x$glib_cv_has__inline in
 688 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 689 esac
 690 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 691         AC_COMPILE_IFELSE([
 692         __inline__ int foo () { return 0; }
 693         int main () { return foo (); }
 694         ],
 695         glib_cv_has__inline__=yes
 696         ,
 697         glib_cv_has__inline__=no
 698         ,)
 699 ])
 700 case x$glib_cv_has__inline__ in
 701 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 702 esac
 703 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 704         AC_COMPILE_IFELSE([
 705         #undef inline
 706         inline int foo () { return 0; }
 707         int main () { return foo (); }
 708         ],
 709         glib_cv_hasinline=yes
 710         ,
 711         glib_cv_hasinline=no
 712         ,)
 713 ])
 714 case x$glib_cv_hasinline in
 715 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 716 esac
 717
 718 # if we can use inline functions in headers
 719 AC_MSG_CHECKING(if inline functions in headers work)
 720 AC_LINK_IFELSE([
 721 #if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
 722 #  undef inline
 723 #  define inline __inline__
 724 #elif !defined (G_HAVE_INLINE)
 725 #  undef inline
 726 #  if defined (G_HAVE___INLINE__)
 727 #    define inline __inline__
 728 #  elif defined (G_HAVE___INLINE)
 729 #    define inline __inline
 730 #  endif
 731 #endif
 732
 733 int glib_test_func2 (int);
 734
 735 static inline int
 736 glib_test_func1 (void) {
 737   return glib_test_func2 (1);
 738 }
 739
 740 int
 741 main (void) {
 742   int i = 1;
 743 }],[g_can_inline=yes],[g_can_inline=no])
 744 AC_MSG_RESULT($g_can_inline)
 745
 746 dnl *** check for working do while(0) macros ***
 747 AC_CACHE_CHECK([for working do while(0) macros], g_cv_support_dowhile_macros, [
 748         AC_TRY_COMPILE([],[
 749         #define STMT_START do
 750         #define STMT_END while(0)
 751         #define STMT_TEST STMT_START { i = 0; } STMT_END
 752         int main(void) { int i = 1; STMT_TEST; return i; }],
 753         [g_cv_support_dowhile_macros=yes],
 754         [g_cv_support_dowhile_macros=no],
 755         [g_cv_support_dowhile_macros=yes])
 756 ])
 757 if test x$g_cv_support_dowhile_macros = xyes; then
 758   AC_DEFINE(HAVE_DOWHILE_MACROS, 1, [define for working do while(0) macros])
 759 fi
 760
 761 # check for flavours of varargs macros
 762 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
 763 AC_TRY_COMPILE([],[
 764 int a(int p1, int p2, int p3);
 765 #define call_a(...) a(1,__VA_ARGS__)
 766 call_a(2,3);
 767 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
 768 AC_MSG_RESULT($g_have_iso_c_varargs)
 769
 770 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
 771 if test "$CXX" = ""; then
 772 dnl No C++ compiler
 773   g_have_iso_cxx_varargs=no
 774 else
 775   AC_LANG_CPLUSPLUS
 776   AC_TRY_COMPILE([],[
 777 int a(int p1, int p2, int p3);
 778 #define call_a(...) a(1,__VA_ARGS__)
 779 call_a(2,3);
 780 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
 781   AC_LANG_C
 782 fi
 783 AC_MSG_RESULT($g_have_iso_cxx_varargs)
 784
 785 AC_MSG_CHECKING(for GNUC varargs macros)
 786 AC_TRY_COMPILE([],[
 787 int a(int p1, int p2, int p3);
 788 #define call_a(params...) a(1,params)
 789 call_a(2,3);
 790 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
 791 AC_MSG_RESULT($g_have_gnuc_varargs)
 792
 793 # check for GNUC visibility support
 794 AC_MSG_CHECKING(for GNUC visibility attribute)
 795 GLIB_CHECK_COMPILE_WARNINGS([
 796 void
 797 __attribute__ ((visibility ("hidden")))
 798      f_hidden (void)
 799 {
 800 }
 801 void
 802 __attribute__ ((visibility ("internal")))
 803      f_internal (void)
 804 {
 805 }
 806 void
 807 __attribute__ ((visibility ("protected")))
 808      f_protected (void)
 809 {
 810 }
 811 void
 812 __attribute__ ((visibility ("default")))
 813      f_default (void)
 814 {
 815 }
 816 int main (int argc, char **argv)
 817 {
 818         f_hidden();
 819         f_internal();
 820         f_protected();
 821         f_default();
 822         return 0;
 823 }
 824 ],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
 825 AC_MSG_RESULT($g_have_gnuc_visibility)
 826 AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
 827
 828 AC_MSG_CHECKING([whether using Sun Studio C compiler])
 829 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#if defined(__SUNPRO_C) || (__SUNPRO_C >= 0x550)
 830 #else
 831 # include "error: this is not Sun Studio."
 832 #endif
 833 ]], [[]])], [ g_have_sunstudio_visibility=yes ], [ g_have_sunstudio_visibility=no ])
 834 AC_MSG_RESULT($g_have_sunstudio_visibility)
 835 AM_CONDITIONAL(HAVE_SUNSTUDIO_VISIBILITY, [test x$g_have_sunstudio_visibility = xyes])
 836
 837 # check for bytesex stuff
 838 AC_C_BIGENDIAN
 839 if test x$ac_cv_c_bigendian = xuniversal ; then
 840 AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __BIG_ENDIAN
 841 #else
 842 #error Not a big endian.
 843 #endif],
 844     ac_cv_c_bigendian=yes
 845     ,AC_TRY_COMPILE([#include <endian.h>], [#if __BYTE_ORDER == __LITTLE_ENDIAN
 846 #else
 847 #error Not a little endian.
 848 #endif],
 849     ac_cv_c_bigendian=no
 850     ,AC_MSG_WARN([Could not determine endianness.])))
 851 fi
 852
 853
 854 # check for header files
 855 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h grp.h sys/param.h sys/poll.h sys/resource.h])
 856 AC_CHECK_HEADERS([sys/time.h sys/times.h sys/wait.h unistd.h values.h])
 857 AC_CHECK_HEADERS([sys/select.h sys/types.h stdint.h sched.h malloc.h])
 858 AC_CHECK_HEADERS([sys/vfs.h sys/mount.h sys/vmount.h sys/statfs.h sys/statvfs.h])
 859 AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h sys/sysctl.h fstab.h])
 860
 861 # check for structure fields
 862 AC_CHECK_MEMBERS([struct stat.st_mtimensec, struct stat.st_mtim.tv_nsec, struct stat.st_atimensec, struct stat.st_atim.tv_nsec, struct stat.st_ctimensec, struct stat.st_ctim.tv_nsec])
 863 AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct statfs.f_fstypename, struct statfs.f_bavail],,, [#include <sys/types.h>
 864 #include <sys/stat.h>
 865 #include <unistd.h>
 866 #ifdef HAVE_SYS_STATFS_H
 867 #include <sys/statfs.h>
 868 #endif
 869 #ifdef HAVE_SYS_PARAM_H
 870 #include <sys/param.h>
 871 #endif
 872 #ifdef HAVE_SYS_MOUNT_H
 873 #include <sys/mount.h>
 874 #endif])
 875 # struct statvfs.f_basetype is available on Solaris but not for Linux.
 876 AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
 877
 878 # Checks for libcharset
 879 AM_LANGINFO_CODESET
 880 gl_GLIBC21
 881 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
 882 AC_CHECK_FUNCS(setlocale)
 883
 884 # check additional type sizes
 885 AC_CHECK_SIZEOF(size_t)
 886
 887 dnl Try to figure out whether gsize, gssize should be long or int
 888 AC_MSG_CHECKING([for the appropriate definition for size_t])
 889
 890 case $ac_cv_sizeof_size_t in
 891   $ac_cv_sizeof_short)
 892       glib_size_type=short
 893       ;;
 894   $ac_cv_sizeof_int)
 895       glib_size_type=int
 896       ;;
 897   $ac_cv_sizeof_long)
 898       glib_size_type=long
 899       ;;
 900   $ac_cv_sizeof_long_long)
 901       glib_size_type='long long'
 902       ;;
 903   $ac_cv_sizeof__int64)
 904       glib_size_type='__int64'
 905       ;;
 906   *)  AC_MSG_ERROR([No type matching size_t in size])
 907       ;;
 908 esac
 909
 910 dnl If int/long are the same size, we see which one produces
 911 dnl warnings when used in the location as size_t. (This matters
 912 dnl on AIX with xlc)
 913 dnl
 914 if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
 915    test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
 916   GLIB_CHECK_COMPILE_WARNINGS([
 917 #if defined(_AIX) && !defined(__GNUC__)
 918 #pragma options langlvl=stdc89
 919 #endif
 920 #include <stddef.h>
 921 int main ()
 922 {
 923   size_t s = 1;
 924   unsigned int *size_int = &s;
 925   return (int)*size_int;
 926 }
 927     ],glib_size_type=int,
 928       [GLIB_CHECK_COMPILE_WARNINGS([
 929 #if defined(_AIX) && !defined(__GNUC__)
 930 #pragma options langlvl=stdc89
 931 #endif
 932 #include <stddef.h>
 933 int main ()
 934 {
 935    size_t s = 1;
 936    unsigned long *size_long = &s;
 937    return (int)*size_long;
 938 }
 939         ],glib_size_type=long)])
 940 fi
 941
 942 AC_MSG_RESULT(unsigned $glib_size_type)
 943
 944 # Check for some functions
 945 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk)
 946 AC_CHECK_FUNCS(chown lchown fchmod fchown link statvfs statfs utimes getgrgid getpwuid)
 947 AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getmntinfo)
 948 # Check for high-resolution sleep functions
 949 AC_CHECK_FUNCS(nanosleep nsleep)
 950
 951 AC_CHECK_HEADERS(crt_externs.h)
 952 AC_CHECK_FUNCS(_NSGetEnviron)
 953
 954 AC_FUNC_VSNPRINTF_C99
 955 AC_FUNC_PRINTF_UNIX98
 956
 957 # Internet address families
 958 if test $glib_native_win32 = yes; then
 959   glib_inet_includes=["
 960 #include <winsock2.h>
 961   "]
 962 else
 963   glib_inet_includes=["
 964 #include <sys/socket.h>
 965   "]
 966 fi
 967
 968 glib_failed=false
 969 GLIB_CHECK_VALUE(AF_INET, $glib_inet_includes, glib_failed=true)
 970 GLIB_CHECK_VALUE(AF_INET6, $glib_inet_includes, glib_failed=true)
 971 # winsock defines this even though it doesn't support it
 972 GLIB_CHECK_VALUE(AF_UNIX, $glib_inet_includes, glib_failed=true)
 973 if $glib_failed ; then
 974   AC_MSG_ERROR([Could not determine values for AF_INET* constants])
 975 fi
 976
 977 dnl
 978 dnl if statfs() takes 2 arguments (Posix) or 4 (Solaris)
 979 dnl
 980 if test "$ac_cv_func_statfs" = yes ; then
 981   AC_MSG_CHECKING([number of arguments to statfs()])
 982   AC_TRY_COMPILE([#include <unistd.h>
 983   #ifdef HAVE_SYS_PARAM_H
 984   #include <sys/param.h>
 985   #endif
 986   #ifdef HAVE_SYS_VFS_H
 987   #include <sys/vfs.h>
 988   #endif
 989   #ifdef HAVE_SYS_MOUNT_H
 990   #include <sys/mount.h>
 991   #endif
 992   #ifdef HAVE_SYS_STATFS_H
 993   #include <sys/statfs.h>
 994   #endif], [struct statfs st;
 995   statfs(NULL, &st);],[
 996     AC_MSG_RESULT([2])
 997     AC_DEFINE(STATFS_ARGS, 2, [Number of arguments to statfs()])],[
 998     AC_TRY_COMPILE([#include <unistd.h>
 999   #ifdef HAVE_SYS_PARAM_H
1000   #include <sys/param.h>
1001   #endif
1002   #ifdef HAVE_SYS_VFS_H
1003   #include <sys/vfs.h>
1004   #endif
1005   #ifdef HAVE_SYS_MOUNT_H
1006   #include <sys/mount.h>
1007   #endif
1008   #ifdef HAVE_SYS_STATFS_H
1009   #include <sys/statfs.h>
1010   #endif], [struct statfs st;
1011   statfs(NULL, &st, sizeof (st), 0);],[
1012       AC_MSG_RESULT([4])
1013       AC_DEFINE(STATFS_ARGS, 4, [Number of arguments to statfs()])],[
1014       AC_MSG_RESULT(unknown)
1015       AC_MSG_ERROR([unable to determine number of arguments to statfs()])])])
1016 fi
1017
1018 #
1019 # Check whether to use an included printf
1020 #
1021
1022 AC_ARG_ENABLE(included-printf,
1023               [AC_HELP_STRING([--enable-included-printf],
1024                               [use included printf [default=auto]])],
1025               enable_included_printf="$enableval")
1026
1027 need_included_printf=no
1028 if test "x$enable_included_printf" = "xyes" ; then
1029   need_included_printf=yes
1030 fi
1031 if test "$ac_cv_func_vsnprintf_c99" != "yes" ; then
1032   need_included_printf=yes
1033 fi
1034 if test "$ac_cv_func_printf_unix98" != "yes" ; then
1035   need_included_printf=yes
1036 fi
1037 if test "x$ac_cv_sizeof_long_long" = "x8" &&
1038    test -z "$glib_cv_long_long_format" ; then
1039   need_included_printf=yes
1040 fi
1041
1042 if test "x$enable_included_printf" = "xno" &&
1043    test "x$need_included_printf" = "xyes" ; then
1044   AC_MSG_ERROR([
1045 *** Your C library's printf doesn't appear to have the features that
1046 *** GLib needs, but you specified --enable-included-printf=no.])
1047 fi
1048
1049 enable_included_printf=$need_included_printf
1050
1051 AM_CONDITIONAL(HAVE_GOOD_PRINTF, test "$enable_included_printf" != "yes")
1052 if test "$enable_included_printf" != "yes" ; then
1053   AC_DEFINE(HAVE_GOOD_PRINTF,1,[define to use system printf])
1054 else
1055   if test -z "$glib_cv_long_long_format" ; then
1056     glib_cv_long_long_format="ll"
1057   fi
1058   AC_DEFINE(HAVE_VASPRINTF,1)
1059 fi
1060
1061 # Checks needed for gnulib vasnprintf
1062 bh_C_SIGNED
1063 jm_AC_TYPE_LONG_LONG
1064 gt_TYPE_LONGDOUBLE
1065 gt_TYPE_WCHAR_T
1066 gt_TYPE_WINT_T
1067 AC_TYPE_SIZE_T
1068 AC_CHECK_TYPES(ptrdiff_t)
1069 jm_AC_TYPE_INTMAX_T
1070 AC_CHECK_FUNCS([snprintf wcslen])
1071 AC_FUNC_SNPRINTF_C99
1072
1073 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
1074 # The check is borrowed from the PERL Configure script.
1075 if test "$ac_cv_func_memmove" != "yes"; then
1076   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
1077     glib_cv_working_bcopy,[AC_TRY_RUN([
1078       int main() {
1079         char buf[128], abc[128], *b;
1080         int len, off, align;
1081         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
1082         for (align = 7; align >= 0; align--) {
1083           for (len = 36; len; len--) {
1084             b = buf+align; bcopy(abc, b, len);
1085             for (off = 1; off <= len; off++) {
1086               bcopy(b, b+off, len); bcopy(b+off, b, len);
1087                 if (bcmp(b, abc, len)) return(1);
1088             }
1089           }
1090         }
1091         return(0);
1092       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
1093
1094   GLIB_ASSERT_SET(glib_cv_working_bcopy)
1095   if test "$glib_cv_working_bcopy" = "yes"; then
1096     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
1097   fi
1098 fi
1099
1100 # Check for sys_errlist
1101 AC_MSG_CHECKING(for sys_errlist)
1102 AC_TRY_LINK(, [
1103 extern char *sys_errlist[];
1104 extern int sys_nerr;
1105 sys_errlist[sys_nerr-1][0] = 0;
1106 ], glib_ok=yes, glib_ok=no)
1107 AC_MSG_RESULT($glib_ok)
1108 if test "$glib_ok" = "no"; then
1109     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
1110 fi
1111
1112 # Check for sys_siglist
1113 AC_MSG_CHECKING(for sys_siglist)
1114 AC_TRY_LINK(, [
1115 extern char *sys_siglist[];
1116 exit (sys_siglist[0]);
1117 ], glib_ok=yes, glib_ok=no)
1118 AC_MSG_RESULT($glib_ok)
1119 if test "$glib_ok" = "no"; then
1120     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
1121 fi
1122
1123 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
1124 AC_MSG_CHECKING(for sys_siglist declaration)
1125 AC_TRY_COMPILE([#include <signal.h>], [
1126 strlen (sys_siglist[0]);
1127 ], glib_ok=yes, glib_ok=no)
1128 AC_MSG_RESULT($glib_ok)
1129 if test "$glib_ok" = "no"; then
1130     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
1131 fi
1132
1133 # Check if <sys/select.h> needs to be included for fd_set
1134 AC_MSG_CHECKING([for fd_set])
1135 AC_TRY_COMPILE([#include <sys/types.h>],
1136         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
1137 if test "$gtk_ok" = "yes"; then
1138     AC_MSG_RESULT([yes, found in sys/types.h])
1139 else
1140     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
1141     if test "$gtk_ok" = "yes"; then
1142         # *** FIXME: give it a different name
1143         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
1144         AC_MSG_RESULT([yes, found in sys/select.h])
1145     else
1146         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
1147         AC_MSG_RESULT(no)
1148     fi
1149 fi
1150
1151 dnl *** check for sane realloc() ***
1152 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
1153         AC_TRY_RUN([#include <stdlib.h>
1154         int main() {
1155           return realloc (0, sizeof (int)) == 0;
1156         }],
1157         [glib_cv_sane_realloc=yes],
1158         [glib_cv_sane_realloc=no],
1159         [glib_cv_sane_realloc=yes])
1160 ])
1161 if test x$glib_cv_sane_realloc = xyes; then
1162   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
1163 fi
1164
1165 dnl Check for nl_langinfo and CODESET
1166 AC_CACHE_CHECK([for nl_langinfo (CODESET)],glib_cv_langinfo_codeset,[
1167         AC_TRY_COMPILE([#include <langinfo.h>],
1168                 [char *codeset = nl_langinfo (CODESET);],
1169                 [glib_cv_langinfo_codeset=yes],
1170                 [glib_cv_langinfo_codeset=no])])
1171 if test x$glib_cv_langinfo_codeset = xyes; then
1172   AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
1173 fi
1174
1175 dnl ****************************************
1176 dnl *** posix_memalign                   ***
1177 dnl ****************************************
1178 AC_MSG_CHECKING(for a compliant posix_memalign() implementation)
1179 AC_CACHE_VAL(glib_cv_compliant_posix_memalign,[
1180     glib_cv_compliant_posix_memalign=0
1181     if test "$ac_cv_func_posix_memalign" = "yes" ; then
1182         AC_TRY_RUN([
1183                 #define _XOPEN_SOURCE 600
1184                 #include <stdlib.h> /* posix_memalign() should be defined here */
1185                 /* some systems break if #include <malloc.h> used */
1186                 static void test_memalign (size_t boundary, size_t size) {
1187                     void *mem = 0;
1188                     if (posix_memalign (&mem, boundary, size) != 0 || !mem)
1189                         exit (1);
1190                     else
1191                       free (mem);
1192                 }
1193                 int main() {
1194                     test_memalign (  128,   128 - 2 * sizeof (void*));
1195                     test_memalign (  256,   256 - 2 * sizeof (void*));
1196                     test_memalign (  512,   512 - 2 * sizeof (void*));
1197                     test_memalign ( 1024,  1024 - 2 * sizeof (void*));
1198                     test_memalign ( 2048,  2048 - 2 * sizeof (void*));
1199                     test_memalign ( 4096,  4096 - 2 * sizeof (void*));
1200                     test_memalign ( 8192,  8192 - 2 * sizeof (void*));
1201                     test_memalign (16384, 16384 - 2 * sizeof (void*));
1202                     test_memalign (32768, 32768 - 2 * sizeof (void*));
1203                     exit (0); /* success */
1204                 }
1205                 ],
1206             [glib_cv_compliant_posix_memalign=1], [], [:])
1207       :
1208     fi
1209     ])
1210 if test "$glib_cv_compliant_posix_memalign" = "1"; then
1211     AC_MSG_RESULT(yes)
1212     AC_DEFINE(POSIX_MEMALIGN_WITH_COMPLIANT_ALLOCS, 1, [define if posix_memalign() can allocate any size])
1213 else
1214     AC_MSG_RESULT(no)
1215 fi
1216
1217
1218 dnl ****************************************
1219 dnl *** strlcpy/strlcat                  ***
1220 dnl ****************************************
1221 # Check for strlcpy
1222 AC_CACHE_CHECK([for OpenBSD strlcpy/strlcat],glib_cv_have_strlcpy,[
1223 AC_TRY_RUN([#include <stdlib.h>
1224 #include <string.h>
1225 int main() {
1226   char p[10];
1227   (void) strlcpy (p, "hi", 10);
1228   if (strlcat (p, "bye", 0) != 3)
1229     return 1;
1230   return 0;
1231 }], glib_cv_have_strlcpy=yes,
1232     glib_cv_have_strlcpy=no,
1233     glib_cv_have_strlcpy=no)])
1234 if test "$glib_cv_have_strlcpy" = "yes"; then
1235     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
1236 fi
1237
1238
1239 dnl **********************
1240 dnl *** va_copy checks ***
1241 dnl **********************
1242 dnl we currently check for all three va_copy possibilities, so we get
1243 dnl all results in config.log for bug reports.
1244 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
1245         AC_LINK_IFELSE([#include <stdarg.h>
1246 #include <stdlib.h>
1247         void f (int i, ...) {
1248         va_list args1, args2;
1249         va_start (args1, i);
1250         va_copy (args2, args1);
1251         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1252           exit (1);
1253         va_end (args1); va_end (args2);
1254         }
1255         int main() {
1256           f (0, 42);
1257           return 0;
1258         }],
1259         [glib_cv_va_copy=yes],
1260         [glib_cv_va_copy=no])
1261 ])
1262 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
1263         AC_LINK_IFELSE([#include <stdarg.h>
1264 #include <stdlib.h>
1265         void f (int i, ...) {
1266         va_list args1, args2;
1267         va_start (args1, i);
1268         __va_copy (args2, args1);
1269         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1270           exit (1);
1271         va_end (args1); va_end (args2);
1272         }
1273         int main() {
1274           f (0, 42);
1275           return 0;
1276         }],
1277         [glib_cv___va_copy=yes],
1278         [glib_cv___va_copy=no])
1279 ])
1280
1281 if test "x$glib_cv_va_copy" = "xyes"; then
1282   g_va_copy_func=va_copy
1283 else if test "x$glib_cv___va_copy" = "xyes"; then
1284   g_va_copy_func=__va_copy
1285 fi
1286 fi
1287
1288 if test -n "$g_va_copy_func"; then
1289   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
1290 fi
1291
1292 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
1293         AC_TRY_RUN([#include <stdarg.h>
1294 #include <stdlib.h>
1295         void f (int i, ...) {
1296         va_list args1, args2;
1297         va_start (args1, i);
1298         args2 = args1;
1299         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
1300           exit (1);
1301         va_end (args1); va_end (args2);
1302         }
1303         int main() {
1304           f (0, 42);
1305           return 0;
1306         }],
1307         [glib_cv_va_val_copy=yes],
1308         [glib_cv_va_val_copy=no],
1309         [glib_cv_va_val_copy=yes])
1310 ])
1311
1312 if test "x$glib_cv_va_val_copy" = "xno"; then
1313   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
1314 fi
1315
1316 dnl ***********************
1317 dnl *** g_module checks ***
1318 dnl ***********************
1319 G_MODULE_LIBS=
1320 G_MODULE_LIBS_EXTRA=
1321 G_MODULE_PLUGIN_LIBS=
1322 if test x"$glib_native_win32" = xyes; then
1323   dnl No use for this on Win32
1324   G_MODULE_LDFLAGS=
1325 else
1326   export SED
1327   G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
1328 fi
1329 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
1330 G_MODULE_NEED_USCORE=0
1331 G_MODULE_BROKEN_RTLD_GLOBAL=0
1332 G_MODULE_HAVE_DLERROR=0
1333 dnl *** force native WIN32 shared lib loader
1334 if test -z "$G_MODULE_IMPL"; then
1335   case "$host" in
1336   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
1337   esac
1338 fi
1339 dnl *** force native AIX library loader
1340 dnl *** dlopen() filepath must be of the form /path/libname.a(libname.so)
1341 if test -z "$G_MODULE_IMPL"; then
1342   case "$host" in
1343   *-*-aix*) G_MODULE_IMPL=G_MODULE_IMPL_AR ;;
1344   esac
1345 fi
1346 dnl *** dlopen() and dlsym() in system libraries
1347 if test -z "$G_MODULE_IMPL"; then
1348         AC_CHECK_FUNC(dlopen,
1349                       [AC_CHECK_FUNC(dlsym,
1350                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1351                       [])
1352 fi
1353 dnl *** load_image (BeOS)
1354 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
1355   AC_CHECK_LIB(root, load_image,
1356       [G_MODULE_LIBS="-lbe -lroot -lglib-2.0 "
1357       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1358       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
1359       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
1360       [])
1361 fi
1362 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
1363 if test -z "$G_MODULE_IMPL"; then
1364         AC_CHECK_FUNC(NSLinkModule,
1365                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
1366                        G_MODULE_NEED_USCORE=1],
1367                       [])
1368 fi
1369 dnl *** dlopen() and dlsym() in libdl
1370 if test -z "$G_MODULE_IMPL"; then
1371         AC_CHECK_LIB(dl, dlopen,
1372                      [AC_CHECK_LIB(dl, dlsym,
1373                                    [G_MODULE_LIBS=-ldl
1374                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
1375                      [])
1376 fi
1377 dnl *** shl_load() in libdld (HP-UX)
1378 if test -z "$G_MODULE_IMPL"; then
1379         AC_CHECK_LIB(dld, shl_load,
1380                 [G_MODULE_LIBS=-ldld
1381                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
1382                 [])
1383 fi
1384 dnl *** additional checks for G_MODULE_IMPL_DL
1385 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
1386         LIBS_orig="$LIBS"
1387         LDFLAGS_orig="$LDFLAGS"
1388         LIBS="$G_MODULE_LIBS $LIBS"
1389         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
1390 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
1391         echo "void glib_plugin_test(void) { }" > plugin.c
1392         ${SHELL} ./libtool --mode=compile ${CC} -shared \
1393                 -export-dynamic -o plugin.o plugin.c 2>&1 >/dev/null
1394         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
1395                 glib_cv_rtldglobal_broken,[
1396                 AC_TRY_RUN([
1397 #include <dlfcn.h>
1398 #ifndef RTLD_GLOBAL
1399 #  define RTLD_GLOBAL 0
1400 #endif
1401 #ifndef RTLD_LAZY
1402 #  define RTLD_LAZY 0
1403 #endif
1404 int glib_plugin_test;
1405 int main () {
1406     void *handle, *global, *local;
1407     global = &glib_plugin_test;
1408     handle = dlopen ("./.libs/plugin.o", RTLD_GLOBAL | RTLD_LAZY);
1409     if (!handle) return 0;
1410     local = dlsym (handle, "glib_plugin_test");
1411     return global == local;
1412 }                       ],
1413                         [glib_cv_rtldglobal_broken=no],
1414                         [glib_cv_rtldglobal_broken=yes],
1415                         [glib_cv_rtldglobal_broken=no])
1416                 rm -f plugin.c plugin.o plugin.lo .libs/plugin.o
1417                 rmdir .libs 2>/dev/null
1418         ])
1419         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
1420                 G_MODULE_BROKEN_RTLD_GLOBAL=1
1421         else
1422                 G_MODULE_BROKEN_RTLD_GLOBAL=0
1423         fi
1424 dnl *** check whether we need preceeding underscores
1425         AC_CACHE_CHECK([for preceeding underscore in symbols],
1426                 glib_cv_uscore,[
1427                 AC_TRY_RUN([#include <dlfcn.h>
1428                 int glib_underscore_test (void) { return 42; }
1429                 int main() {
1430                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
1431                   handle = dlopen ((void*)0, 0);
1432                   if (handle) {
1433                     f1 = dlsym (handle, "glib_underscore_test");
1434                     f2 = dlsym (handle, "_glib_underscore_test");
1435                   } return (!f2 || f1);
1436                 }],
1437                         [glib_cv_uscore=yes],
1438                         [glib_cv_uscore=no],
1439                         [])
1440                 rm -f plugin.c plugin.$ac_objext plugin.lo
1441         ])
1442         GLIB_ASSERT_SET(glib_cv_uscore)
1443         if test "x$glib_cv_uscore" = "xyes"; then
1444                 G_MODULE_NEED_USCORE=1
1445         else
1446                 G_MODULE_NEED_USCORE=0
1447         fi
1448
1449         LDFLAGS="$LDFLAGS_orig"
1450 dnl *** check for having dlerror()
1451         AC_CHECK_FUNC(dlerror,
1452                 [G_MODULE_HAVE_DLERROR=1],
1453                 [G_MODULE_HAVE_DLERROR=0])
1454         LIBS="$LIBS_orig"
1455 fi
1456 dnl *** done, have we got an implementation?
1457 if test -z "$G_MODULE_IMPL"; then
1458         G_MODULE_IMPL=0
1459         G_MODULE_SUPPORTED=false
1460 else
1461         G_MODULE_SUPPORTED=true
1462 fi
1463
1464 AC_MSG_CHECKING(for the suffix of module shared libraries)
1465 export SED
1466 shrext_cmds=`./libtool --config | grep '^shrext_cmds='`
1467 eval $shrext_cmds
1468 module=yes eval std_shrext=$shrext_cmds
1469 # chop the initial dot
1470 glib_gmodule_suffix=`echo $std_shrext | sed 's/^\.//'`
1471 AC_MSG_RESULT(.$glib_gmodule_suffix)
1472 # any reason it may fail?
1473 if test "x$glib_gmodule_suffix" = x; then
1474         AC_MSG_ERROR(Cannot determine shared library suffix from libtool)
1475 fi
1476
1477 AC_SUBST(G_MODULE_SUPPORTED)
1478 AC_SUBST(G_MODULE_IMPL)
1479 AC_SUBST(G_MODULE_LIBS)
1480 AC_SUBST(G_MODULE_LIBS_EXTRA)
1481 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1482 AC_SUBST(G_MODULE_LDFLAGS)
1483 AC_SUBST(G_MODULE_HAVE_DLERROR)
1484 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1485 AC_SUBST(G_MODULE_NEED_USCORE)
1486 AC_SUBST(GLIB_DEBUG_FLAGS)
1487
1488 dnl **********************
1489 dnl *** g_spawn checks ***
1490 dnl **********************
1491
1492 AC_MSG_CHECKING(for gspawn implementation)
1493 case "$host" in
1494   *-*-mingw*)
1495     GSPAWN=gspawn-win32.lo
1496     ;;
1497   *)
1498     GSPAWN=gspawn.lo
1499     ;;
1500 esac
1501 AC_MSG_RESULT($GSPAWN)
1502 AC_SUBST(GSPAWN)
1503
1504 dnl *************************
1505 dnl *** GIOChannel checks ***
1506 dnl *************************
1507
1508 AC_MSG_CHECKING(for GIOChannel implementation)
1509 case "$host" in
1510   *-*-mingw*)
1511     GIO=giowin32.lo
1512     ;;
1513   *)
1514     GIO=giounix.lo
1515     ;;
1516 esac
1517 AC_MSG_RESULT($GIO)
1518 AC_SUBST(GIO)
1519
1520 dnl *********************************
1521 dnl *** Directory for GIO modules ***
1522 dnl *********************************
1523
1524 AC_ARG_WITH(gio-module-dir,
1525            [AC_HELP_STRING([--with-gio-module-dir=PATH],
1526                            [Load gio modules from this directory [LIBDIR/gio/modules]])],
1527            [],
1528            [with_gio_module_dir='${libdir}/gio/modules'])
1529 GIO_MODULE_DIR=$with_gio_module_dir
1530 AC_SUBST(GIO_MODULE_DIR)
1531
1532 dnl **********************************
1533 dnl *** Check for libselinux (GIO) ***
1534 dnl **********************************
1535 AC_ARG_ENABLE(selinux, [  --disable-selinux       build without selinux support])
1536 msg_selinux=no
1537 SELINUX_LIBS=
1538 if test "x$enable_selinux" != "xno"; then
1539
1540  AC_CHECK_LIB(selinux, is_selinux_enabled,
1541    [AC_CHECK_HEADERS(selinux/selinux.h,
1542      [AC_CHECK_LIB(selinux, lgetfilecon_raw,
1543        [AC_DEFINE(HAVE_SELINUX, 1, [Define to 1 if libselinux is available])
1544         SELINUX_LIBS="-lselinux"
1545         msg_selinux=yes])
1546      ])
1547    ])
1548 fi
1549 AC_SUBST(SELINUX_LIBS)
1550
1551 dnl *****************************
1552 dnl ** Check for inotify (GIO) **
1553 dnl *****************************
1554 inotify_support=no
1555 AC_CHECK_HEADERS([sys/inotify.h],
1556 [
1557         inotify_support=yes
1558 ])
1559
1560 AM_CONDITIONAL(HAVE_INOTIFY, [test "$inotify_support" = "yes"])
1561
1562 dnl *********************************
1563 dnl ** Check for Solaris FEN (GIO) **
1564 dnl *********************************
1565 fen_support=no
1566 AC_COMPILE_IFELSE([
1567 #include <port.h>
1568 #ifndef PORT_SOURCE_FILE
1569 #error "Please upgrade to Nevada 72 or above to suppoert FEN"
1570 #endif
1571 int main() { return 0; } ],
1572 [
1573         fen_support=yes
1574 ],)
1575
1576 AM_CONDITIONAL(HAVE_FEN, [test "$fen_support" = "yes"])
1577
1578 dnl ****************************
1579 dnl *** Checks for FAM (GIO) ***
1580 dnl ****************************
1581
1582 should_disable_fam=no
1583
1584 AC_ARG_ENABLE(fam, [  --disable-fam          build without enabling fam for file system monitoring],
1585                          [
1586                                 if test "x$enable_fam" = "xno"; then
1587                                         should_disable_fam=yes
1588                                         echo "Not building FAM support"
1589                                 fi
1590                          ]
1591                          )
1592 fam_support=no
1593 FAM_LIBS=
1594 if test "x$should_disable_fam" = "xno"; then
1595 AC_CHECK_LIB(fam, FAMOpen,
1596   [AC_CHECK_HEADERS(fam.h,
1597     [AC_DEFINE(HAVE_FAM, [], [Define if we have FAM])
1598      AC_CHECK_LIB(fam, FAMNoExists,
1599                   AC_DEFINE(HAVE_FAM_NO_EXISTS, [], [Define if we have FAMNoExists in fam]))
1600      FAM_LIBS="-lfam"]
1601      fam_support=yes,
1602     AC_MSG_WARN(*** FAM support will not be built (header files not found) ***))],
1603   AC_MSG_WARN(*** FAM support will not be built (FAM library not found) ***))
1604 AC_SUBST(FAM_LIBS)
1605 fi
1606 AM_CONDITIONAL(HAVE_FAM, [test "$fam_support" = "yes"])
1607
1608
1609 dnl *****************************
1610 dnl *** Check for xattr (GIO) ***
1611 dnl *****************************
1612 AC_ARG_ENABLE(xattr, [  --disable-xattr           build without xattr support])
1613 msg_xattr=no
1614 XATTR_LIBS=
1615 if test "x$enable_xattr" != "xno"; then
1616
1617 dnl either glibc or libattr can provide xattr support
1618
1619 dnl for both of them, we check for getxattr being in
1620 dnl the library and a valid xattr header.
1621
1622 dnl try glibc
1623  AC_CHECK_LIB(c, getxattr,
1624    [AC_CHECK_HEADERS(sys/xattr.h,
1625      [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1626       msg_xattr=yes])
1627    ])
1628
1629   if test "x$msg_xattr" != "xyes"; then
1630 dnl   failure. try libattr
1631    AC_CHECK_LIB(attr, getxattr,
1632       [AC_CHECK_HEADERS(attr/xattr.h,
1633        [AC_DEFINE(HAVE_XATTR, 1, [Define to 1 if xattr is available])
1634         XATTR_LIBS="-lattr"
1635         msg_xattr=yes])
1636       ])
1637   fi
1638
1639   if test "x$msg_xattr" = "xyes"; then
1640     AC_MSG_CHECKING([for XATTR_NOFOLLOW])
1641     AC_TRY_COMPILE([
1642       #include <stdio.h>
1643       #ifdef HAVE_SYS_TYPES_H
1644       #include <sys/types.h>
1645       #endif
1646       #ifdef HAVE_SYS_XATTR_H
1647       #include <sys/xattr.h>
1648       #elif HAVE_ATTR_XATTR_H
1649       #include <attr/xattr.h>
1650       #endif
1651     ],
1652     [ssize_t len = getxattr("", "", NULL, 0, 0, XATTR_NOFOLLOW);],
1653     [
1654       AC_DEFINE([HAVE_XATTR_NOFOLLOW], [1], [Define to 1 if xattr API uses XATTR_NOFOLLOW])
1655       AC_MSG_RESULT([yes])
1656     ],
1657     [AC_MSG_RESULT([no])]
1658     )
1659   fi
1660
1661 fi
1662 AC_SUBST(XATTR_LIBS)
1663
1664 dnl ****************************************
1665 dnl *** platform dependent source checks ***
1666 dnl ****************************************
1667
1668 AC_MSG_CHECKING(for platform-dependent source)
1669 case "$host" in
1670   *-*-cygwin*|*-*-mingw*)
1671     PLATFORMDEP=gwin32.lo
1672     ;;
1673   *)
1674     PLATFORMDEP=
1675     ;;
1676 esac
1677 AC_MSG_RESULT($PLATFORMDEP)
1678 AC_SUBST(PLATFORMDEP)
1679
1680 AC_MSG_CHECKING([whether to compile timeloop])
1681 case "$host" in
1682   *-*-cygwin*|*-*-mingw*|*-*-minix)
1683     enable_timeloop=no
1684     ;;
1685   *)
1686     enable_timeloop=yes
1687     ;;
1688 esac
1689 AC_MSG_RESULT($enable_timeloop)
1690 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1691
1692 AC_MSG_CHECKING([if building for some Win32 platform])
1693 case "$host" in
1694   *-*-mingw*|*-*-cygwin*)
1695     platform_win32=yes
1696     ;;
1697   *)
1698     platform_win32=no
1699     ;;
1700 esac
1701 AC_MSG_RESULT($platform_win32)
1702 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1703
1704 dnl ***********************
1705 dnl *** g_thread checks ***
1706 dnl ***********************
1707
1708 AC_ARG_WITH(threads,
1709            [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
1710                            [specify a thread implementation to use])],
1711            [if test "x$with_threads" = x; then
1712                 want_threads=yes
1713             else
1714                 want_threads=$with_threads
1715             fi],
1716            [want_threads=yes])
1717 if test "x$enable_threads" = "xno"; then
1718         want_threads=no
1719 fi
1720
1721 dnl error and warning message
1722 dnl *************************
1723
1724 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1725                 computer. GLib will not have a default thread implementation."
1726
1727 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1728                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1729                 compilation now, but then your programs might not work.
1730                 Please provide information on how it is done on your system."
1731
1732 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1733                 "
1734
1735 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1736                 provide information on your thread implementation.
1737                 You can also run 'configure --disable-threads'
1738                 to compile without thread support."
1739
1740 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1741                 functions will not be MT-safe during their first call because
1742                 there is no working 'getpwuid_r' on your system."
1743
1744 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1745                 because there is no 'localtime_r' on your system."
1746
1747 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1748                 crude surrogate will be used. If you happen to know a
1749                 yield function for your system, please inform the GLib
1750                 developers."
1751
1752 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1753                 threads on your system. Thus threads can only have the default
1754                 priority. If you happen to know these main/max
1755                 priorities, please inform the GLib developers."
1756
1757 AIX_COMPILE_INFO="AIX's C compiler needs to be called by a different name, when
1758                 linking threaded applications. As GLib cannot do that
1759                 automatically, you will get an linkg error everytime you are
1760                 not using the right compiler. In that case you have to relink
1761                 with the right compiler. Ususally just '_r' is appended
1762                 to the compiler name."
1763
1764 dnl determination of thread implementation
1765 dnl ***************************************
1766
1767 # have_threads=no   means no thread support
1768 # have_threads=none means no default thread implementation
1769
1770 have_threads=no
1771 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1772                                 || test "x$want_threads" = xdce; then
1773         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1774         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1775         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1776         glib_save_CPPFLAGS="$CPPFLAGS"
1777         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1778         if test "x$have_threads" = xno; then
1779                 AC_TRY_COMPILE([#include <pthread.h>],
1780                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1781                         have_threads=posix)
1782         fi
1783         if test "x$have_threads" = xno; then
1784                 AC_TRY_COMPILE([#include <pthread.h>],
1785                         [pthread_mutex_t m;
1786                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1787                         have_threads=dce)
1788         fi
1789         # Tru64Unix requires -pthread to find pthread.h. See #103020
1790         CPPFLAGS="$CPPFLAGS -pthread"
1791         if test "x$have_threads" = xno; then
1792         AC_TRY_COMPILE([#include <pthread.h>],
1793                        [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1794                        have_threads=posix)
1795         fi
1796         CPPFLAGS="$glib_save_CPPFLAGS"
1797 fi
1798 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1799         case $host in
1800                 *-*-mingw*)
1801                 have_threads=win32
1802                 ;;
1803         esac
1804 fi
1805 if test "x$want_threads" = xnone; then
1806         have_threads=none
1807 fi
1808
1809 AC_MSG_CHECKING(for thread implementation)
1810
1811 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1812         AC_MSG_RESULT(none available)
1813         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1814 else
1815         AC_MSG_RESULT($have_threads)
1816 fi
1817
1818
1819 dnl determination of G_THREAD_CFLAGS
1820 dnl ********************************
1821
1822 G_THREAD_LIBS=
1823 G_THREAD_LIBS_EXTRA=
1824 G_THREAD_CFLAGS=
1825
1826 dnl
1827 dnl Test program for basic POSIX threads functionality
1828 dnl
1829 m4_define([glib_thread_test],[
1830 #include <pthread.h>
1831 int check_me = 0;
1832 void* func(void* data) {check_me = 42; return &check_me;}
1833 int main()
1834  { pthread_t t;
1835    void *ret;
1836    pthread_create (&t, $1, func, 0);
1837    pthread_join (t, &ret);
1838    return (check_me != 42 || ret != &check_me);
1839 }])
1840
1841 dnl
1842 dnl Test program for sched_get_priority_min()
1843 dnl
1844 m4_define([glib_sched_priority_test],[
1845 #include <sched.h>
1846 #include <errno.h>
1847 int main() {
1848     errno = 0;
1849     return sched_get_priority_min(SCHED_OTHER)==-1
1850            && errno != 0;
1851 }])
1852
1853 if test x"$have_threads" != xno; then
1854
1855   if test x"$have_threads" = xposix; then
1856     # First we test for posix, whether -pthread or -pthreads do the trick as
1857     # both CPPFLAG and LIBS.
1858     # One of them does for most gcc versions and some other platforms/compilers
1859     # too and could be considered as the canonical way to go.
1860     case $host in
1861       *-*-cygwin*|*-*-darwin*)
1862          # skip cygwin and darwin -pthread or -pthreads test
1863          ;;
1864       *-solaris*)
1865         # These compiler/linker flags work with both Sun Studio and gcc
1866         # Sun Studio expands -mt to -D_REENTRANT and -lthread
1867         # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
1868         G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
1869         G_THREAD_LIBS="-lpthread -lthread"
1870         ;;
1871       *)
1872         for flag in pthread pthreads mt; do
1873           glib_save_CFLAGS="$CFLAGS"
1874           CFLAGS="$CFLAGS -$flag"
1875           AC_TRY_RUN(glib_thread_test(0),
1876                      glib_flag_works=yes,
1877                      glib_flag_works=no,
1878                      [AC_LINK_IFELSE(glib_thread_test(0),
1879                                      glib_flag_works=yes,
1880                                      glib_flag_works=no)])
1881           CFLAGS="$glib_save_CFLAGS"
1882           if test $glib_flag_works = yes ; then
1883              G_THREAD_CFLAGS=-$flag
1884              G_THREAD_LIBS=-$flag
1885              break;
1886           fi
1887         done
1888          ;;
1889     esac
1890   fi
1891
1892   if test x"$G_THREAD_CFLAGS" = x; then
1893
1894     # The canonical -pthread[s] does not work. Try something different.
1895
1896     case $host in
1897         *-aix*)
1898                 if test x"$GCC" = xyes; then
1899                         # GCC 3.0 and above needs -pthread.
1900                         # Should be coverd by the case above.
1901                         # GCC 2.x and below needs -mthreads
1902                         G_THREAD_CFLAGS="-mthreads"
1903                         G_THREAD_LIBS=$G_THREAD_CFLAGS
1904                 else
1905                         # We are probably using the aix compiler. Normaly a
1906                         # program would have to be compiled with the _r variant
1907                         # of the corresponding compiler, but we as GLib cannot
1908                         # do that: but the good news is that for compiling the
1909                         # only difference is the added -D_THREAD_SAFE compile
1910                         # option. This is according to the "C for AIX User's
1911                         # Guide".
1912                         G_THREAD_CFLAGS="-D_THREAD_SAFE"
1913                 fi
1914                 ;;
1915         *-dg-dgux*)  # DG/UX
1916                 G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
1917                 ;;
1918         *-osf*)
1919                 # So we are using dce threads. posix threads are already
1920                 # catched above.
1921                 G_THREAD_CFLAGS="-threads"
1922                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1923                 ;;
1924         *-sysv5uw7*) # UnixWare 7
1925                 # We are not using gcc with -pthread. Catched above.
1926                 G_THREAD_CFLAGS="-Kthread"
1927                 G_THREAD_LIBS=$G_THREAD_CFLAGS
1928                 ;;
1929         *-mingw*)
1930                 # No flag needed when using MSVCRT.DLL
1931                 G_THREAD_CFLAGS=""
1932                 ;;
1933         *)
1934                 G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
1935                 ;;
1936     esac
1937
1938   fi
1939
1940     # if we are not finding the localtime_r function, then we probably are
1941     # not using the proper multithread flag
1942
1943     glib_save_CPPFLAGS="$CPPFLAGS"
1944     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1945
1946     # First we test, whether localtime_r is declared in time.h
1947     # directly. Then we test whether a macro localtime_r exists, in
1948     # which case localtime_r in the test program is replaced and thus
1949     # if we still find localtime_r in the output, it is not defined as
1950     # a macro.
1951
1952     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1953       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1954                                                            localtime_r(a,b)],
1955                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1956
1957     CPPFLAGS="$glib_save_CPPFLAGS"
1958
1959     AC_MSG_CHECKING(thread related cflags)
1960     AC_MSG_RESULT($G_THREAD_CFLAGS)
1961     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1962 fi
1963
1964 dnl determination of G_THREAD_LIBS
1965 dnl ******************************
1966
1967 mutex_has_default=no
1968 case $have_threads in
1969         posix|dce)
1970           glib_save_CPPFLAGS="$CPPFLAGS"
1971           CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1972           if test x"$G_THREAD_LIBS" = x; then
1973             case $host in
1974               *-aix*)
1975                 # We are not using gcc (would have set G_THREAD_LIBS) and thus
1976                 # probably using the aix compiler.
1977                 AC_MSG_WARN($AIX_COMPILE_INFO)
1978                 ;;
1979               *)
1980                 G_THREAD_LIBS=error
1981                 glib_save_LIBS="$LIBS"
1982                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1983                         if test x"$thread_lib" = x; then
1984                                 add_thread_lib=""
1985                                 IN=""
1986                         else
1987                                 add_thread_lib="-l$thread_lib"
1988                                 IN=" in -l$thread_lib"
1989                         fi
1990                         if test x"$have_threads" = xposix; then
1991                                 defattr=0
1992                         else
1993                                 defattr=pthread_attr_default
1994                         fi
1995
1996                         LIBS="$add_thread_lib $glib_save_LIBS"
1997
1998                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1999                         AC_TRY_RUN(glib_thread_test($defattr),
2000                                    glib_result=yes,
2001                                    glib_result=no,
2002                                    [AC_LINK_IFELSE(glib_thread_test($defattr),
2003                                                    glib_result=yes,
2004                                                    glib_result=no)])
2005                         AC_MSG_RESULT($glib_result)
2006
2007                         if test "$glib_result" = "yes" ; then
2008                           G_THREAD_LIBS="$add_thread_lib"
2009                           break
2010                         fi
2011                 done
2012                 if test "x$G_THREAD_LIBS" = xerror; then
2013                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2014                 fi
2015                 LIBS="$glib_save_LIBS"
2016                 ;;
2017             esac
2018           fi
2019
2020           glib_save_LIBS="$LIBS"
2021           for thread_lib in "" rt rte; do
2022             if test x"$thread_lib" = x; then
2023               add_thread_lib=""
2024               IN=""
2025             else
2026               add_thread_lib="-l$thread_lib"
2027               IN=" in -l$thread_lib"
2028             fi
2029             LIBS="$add_thread_lib $glib_save_LIBS"
2030
2031             AC_MSG_CHECKING(for sched_get_priority_min$IN)
2032             AC_TRY_RUN(glib_sched_priority_test,
2033                        glib_result=yes,
2034                        glib_result=no,
2035                        [AC_LINK_IFELSE(glib_sched_priority_test,
2036                                        glib_result=yes,
2037                                        glib_result=no)])
2038             AC_MSG_RESULT($glib_result)
2039
2040             if test "$glib_result" = "yes" ; then
2041                G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
2042                posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
2043                posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
2044                break
2045             fi
2046           done
2047           LIBS="$glib_save_LIBS"
2048           mutex_has_default=yes
2049           mutex_default_type='pthread_mutex_t'
2050           mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
2051           mutex_header_file='pthread.h'
2052           if test "x$have_threads" = "xposix"; then
2053             g_threads_impl="POSIX"
2054           else
2055             g_threads_impl="DCE"
2056             have_threads="posix"
2057           fi
2058           AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
2059           CPPFLAGS="$glib_save_CPPFLAGS"
2060           ;;
2061         win32)
2062            g_threads_impl="WIN32"
2063            ;;
2064         none|no)
2065            g_threads_impl="NONE"
2066            ;;
2067         *)
2068            g_threads_impl="NONE"
2069            G_THREAD_LIBS=error
2070            ;;
2071 esac
2072
2073 if test "x$G_THREAD_LIBS" = xerror; then
2074         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
2075 fi
2076
2077 case $host in
2078   *-*-beos*)
2079     G_THREAD_LIBS="-lbe -lroot -lglib-2.0 "
2080     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
2081     ;;
2082   *)
2083     ;;
2084 esac
2085
2086 AC_MSG_CHECKING(thread related libraries)
2087 AC_MSG_RESULT($G_THREAD_LIBS)
2088
2089 dnl check for mt safe function variants and some posix functions
2090 dnl ************************************************************
2091
2092 if test x"$have_threads" != xno; then
2093         glib_save_LIBS="$LIBS"
2094         # we are not doing the following for now, as this might require glib
2095         # to always be linked with the thread libs on some platforms.
2096         # LIBS="$LIBS $G_THREAD_LIBS"
2097         AC_CHECK_FUNCS(localtime_r gmtime_r)
2098         if test "$ac_cv_header_pwd_h" = "yes"; then
2099                 AC_CACHE_CHECK([for posix getpwuid_r],
2100                         ac_cv_func_posix_getpwuid_r,
2101                         [AC_TRY_RUN([
2102 #include <errno.h>
2103 #include <pwd.h>
2104 int main () {
2105     char buffer[10000];
2106     struct passwd pwd, *pwptr = &pwd;
2107     int error;
2108     errno = 0;
2109     error = getpwuid_r (0, &pwd, buffer,
2110                         sizeof (buffer), &pwptr);
2111    return (error < 0 && errno == ENOSYS)
2112            || error == ENOSYS;
2113 }                               ],
2114                                 [ac_cv_func_posix_getpwuid_r=yes],
2115                                 [ac_cv_func_posix_getpwuid_r=no])])
2116                 GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
2117                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
2118                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
2119                                 [Have POSIX function getpwuid_r])
2120                 else
2121                         AC_CACHE_CHECK([for nonposix getpwuid_r],
2122                                 ac_cv_func_nonposix_getpwuid_r,
2123                                 [AC_TRY_LINK([#include <pwd.h>],
2124                                         [char buffer[10000];
2125                                         struct passwd pwd;
2126                                         getpwuid_r (0, &pwd, buffer,
2127                                                         sizeof (buffer));],
2128                                         [ac_cv_func_nonposix_getpwuid_r=yes],
2129                                         [ac_cv_func_nonposix_getpwuid_r=no])])
2130                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
2131                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
2132                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
2133                                         [Have non-POSIX function getpwuid_r])
2134                         fi
2135                 fi
2136         fi
2137         if test "$ac_cv_header_grp_h" = "yes"; then
2138                 AC_CACHE_CHECK([for posix getgrgid_r],
2139                         ac_cv_func_posix_getgrgid_r,
2140                         [AC_TRY_RUN([
2141 #include <errno.h>
2142 #include <grp.h>
2143 int main () {
2144     char buffer[10000];
2145     struct group grp, *grpptr = &grp;
2146     int error;
2147     errno = 0;
2148     error = getgrgid_r (0, &grp, buffer,
2149                         sizeof (buffer), &grpptr);
2150    return (error < 0 && errno == ENOSYS)
2151            || error == ENOSYS;
2152 }                              ],
2153                                [ac_cv_func_posix_getgrgid_r=yes],
2154                                [ac_cv_func_posix_getgrgid_r=no])])
2155                 GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
2156                 if test "$ac_cv_func_posix_getgrgid_r" = yes; then
2157                         AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
2158                                 [Have POSIX function getgrgid_r])
2159                 else
2160                         AC_CACHE_CHECK([for nonposix getgrgid_r],
2161                                 ac_cv_func_nonposix_getgrgid_r,
2162                                 [AC_TRY_LINK([#include <grp.h>],
2163                                         [char buffer[10000];
2164                                         struct group grp;
2165                                         getgrgid_r (0, &grp, buffer,
2166                                         sizeof (buffer));],
2167                                 [ac_cv_func_nonposix_getgrgid_r=yes],
2168                                 [ac_cv_func_nonposix_getgrgid_r=no])])
2169                         GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
2170                         if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
2171                                 AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
2172                                         [Have non-POSIX function getgrgid_r])
2173                         fi
2174                 fi
2175         fi
2176         LIBS="$G_THREAD_LIBS $LIBS"
2177         if test x"$have_threads" = xposix; then
2178                 glib_save_CPPFLAGS="$CPPFLAGS"
2179                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2180                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
2181                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
2182                 # This is not AC_CHECK_FUNC to also work with function
2183                 # name mangling in header files.
2184                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
2185                 AC_TRY_LINK([#include <pthread.h>],
2186                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
2187                         [AC_MSG_RESULT(yes)
2188                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
2189                                   [Have function pthread_attr_setstacksize])],
2190                         [AC_MSG_RESULT(no)])
2191                 AC_MSG_CHECKING(for minimal/maximal thread priority)
2192                 if test x"$posix_priority_min" = x; then
2193                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
2194                                 PX_PRIO_MIN],,[
2195                                 posix_priority_min=PX_PRIO_MIN
2196                                 posix_priority_max=PX_PRIO_MAX])
2197                 fi
2198                 if test x"$posix_priority_min" = x; then
2199                         # AIX
2200                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
2201                                 PTHREAD_PRIO_MIN],,[
2202                                 posix_priority_min=PTHREAD_PRIO_MIN
2203                                 posix_priority_max=PTHREAD_PRIO_MAX])
2204                 fi
2205                 if test x"$posix_priority_min" = x; then
2206                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
2207                                 PRI_OTHER_MIN],,[
2208                                 posix_priority_min=PRI_OTHER_MIN
2209                                 posix_priority_max=PRI_OTHER_MAX])
2210                 fi
2211                 if test x"$posix_priority_min" = x; then
2212                         AC_MSG_RESULT(none found)
2213                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
2214                         posix_priority_min=-1
2215                         posix_priority_max=-1
2216                 else
2217                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
2218                         AC_MSG_CHECKING(for pthread_setschedparam)
2219                         AC_TRY_LINK([#include <pthread.h>],
2220                           [pthread_t t; pthread_setschedparam(t, 0, NULL)],
2221                           [AC_MSG_RESULT(yes)
2222                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
2223                            AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
2224                           [AC_MSG_RESULT(no)
2225                            AC_MSG_WARN($POSIX_NO_PRIORITIES)])
2226                 fi
2227                 posix_yield_func=none
2228                 AC_MSG_CHECKING(for posix yield function)
2229                 for yield_func in sched_yield pthread_yield_np pthread_yield \
2230                                                         thr_yield; do
2231                         AC_TRY_LINK([#include <pthread.h>],
2232                                 [$yield_func()],
2233                                 [posix_yield_func="$yield_func"
2234                                 break])
2235                 done
2236                 if test x"$posix_yield_func" = xnone; then
2237                         AC_MSG_RESULT(none found)
2238                         AC_MSG_WARN($POSIX_NO_YIELD)
2239                         posix_yield_func="g_usleep(1000)"
2240                 else
2241                         AC_MSG_RESULT($posix_yield_func)
2242                         posix_yield_func="$posix_yield_func()"
2243                 fi
2244                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
2245                 CPPFLAGS="$glib_save_CPPFLAGS"
2246
2247         elif test x"$have_threads" = xwin32; then
2248                 # It's a pointer to a private struct
2249                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
2250         fi
2251
2252         LIBS="$glib_save_LIBS"
2253
2254         # now spit out all the warnings.
2255         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
2256            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
2257                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
2258         fi
2259         if test "$ac_cv_func_localtime_r" != "yes"; then
2260                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
2261         fi
2262 fi
2263
2264 if test x"$glib_cv_sizeof_system_thread" = x; then
2265    # use a pointer as a fallback.
2266    GLIB_SIZEOF(,void *, system_thread)
2267 fi
2268
2269 #
2270 # Hack to deal with:
2271 #
2272 #  a) GCC < 3.3 for Linux doesn't include -lpthread when
2273 #     building shared libraries with linux.
2274 #  b) FreeBSD doesn't do this either.
2275 #
2276 case $host in
2277   *-*-freebsd*|*-*-linux*)
2278     G_THREAD_LIBS_FOR_GTHREAD="`echo $G_THREAD_LIBS | sed s/-pthread/-lpthread/`"
2279     ;;
2280   *)
2281     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS"
2282     ;;
2283 esac
2284
2285 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
2286                    [Source file containing theread implementation])
2287 AC_SUBST(G_THREAD_CFLAGS)
2288 AC_SUBST(G_THREAD_LIBS)
2289 AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
2290 AC_SUBST(G_THREAD_LIBS_EXTRA)
2291
2292 dnl **********************************************
2293 dnl *** GDefaultMutex setup and initialization ***
2294 dnl **********************************************
2295 dnl
2296 dnl if mutex_has_default = yes, we also got
2297 dnl mutex_default_type, mutex_default_init and mutex_header_file
2298 if test $mutex_has_default = yes ; then
2299         glib_save_CPPFLAGS="$CPPFLAGS"
2300         glib_save_LIBS="$LIBS"
2301         LIBS="$G_THREAD_LIBS $LIBS"
2302         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
2303         GLIB_SIZEOF([#include <$mutex_header_file>],
2304                     $mutex_default_type,
2305                     gmutex)
2306         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
2307                            $mutex_default_type,
2308                            gmutex,
2309                            $glib_cv_sizeof_gmutex,
2310                            $mutex_default_init)
2311         if test x"$glib_cv_byte_contents_gmutex" = xno; then
2312                 mutex_has_default=no
2313         fi
2314         CPPFLAGS="$glib_save_CPPFLAGS"
2315         LIBS="$glib_save_LIBS"
2316 fi
2317
2318 AC_CHECK_FUNCS(clock_gettime, [], [
2319   AC_CHECK_LIB(rt, clock_gettime, [
2320     AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
2321     G_THREAD_LIBS="$G_THREAD_LIBS -lrt"
2322     G_THREAD_LIBS_FOR_GTHREAD="$G_THREAD_LIBS_FOR_GTHREAD -lrt"
2323   ])
2324 ])
2325
2326 AC_CACHE_CHECK(for monotonic clocks,
2327     glib_cv_monotonic_clock,AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
2328 #include <time.h>
2329 #include <unistd.h>
2330 int main() {
2331 #if !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 && defined(CLOCK_MONOTONIC))
2332         #error No monotonic clock
2333 #endif
2334         return 0;
2335 }
2336 ]])],glib_cv_monotonic_clock=yes,glib_cv_monotonic_clock=no))
2337 if test "$glib_cv_monotonic_clock" = "yes"; then
2338   AC_DEFINE(HAVE_MONOTONIC_CLOCK,1,[Have a monotonic clock])
2339 fi
2340
2341
2342 dnl ********************************
2343 dnl *** g_atomic_* tests for gcc ***
2344 dnl ********************************
2345
2346 AC_MSG_CHECKING([whether to use assembler code for atomic operations])
2347
2348 if test x"$GCC" = xyes; then
2349   case $host_cpu in
2350     i386)
2351       AC_MSG_RESULT([none])
2352       glib_memory_barrier_needed=no
2353       ;;
2354     i?86)
2355       AC_MSG_RESULT([i486])
2356       AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
2357                          [i486 atomic implementation])
2358       glib_memory_barrier_needed=no
2359       ;;
2360     sparc*)
2361       SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
2362                 when you are using a sparc with v9 instruction set (most
2363                 sparcs nowadays). This will make the code for atomic
2364                 operations much faster. The resulting code will not run
2365                 on very old sparcs though."
2366
2367       AC_LINK_IFELSE([[
2368         main ()
2369         {
2370           int tmp1, tmp2, tmp3;
2371           __asm__ __volatile__("casx [%2], %0, %1"
2372                                : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
2373         }]],
2374         AC_MSG_RESULT([sparcv9])
2375         AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
2376                            [sparcv9 atomic implementation]),
2377         AC_MSG_RESULT([no])
2378         AC_MSG_WARN([[$SPARCV9_WARNING]]))
2379       glib_memory_barrier_needed=yes
2380       ;;
2381     alpha*)
2382       AC_MSG_RESULT([alpha])
2383       AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
2384                          [alpha atomic implementation])
2385       glib_memory_barrier_needed=yes
2386       ;;
2387     x86_64)
2388       AC_MSG_RESULT([x86_64])
2389       AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
2390                          [x86_64 atomic implementation])
2391       glib_memory_barrier_needed=no
2392      ;;
2393     powerpc*)
2394       AC_MSG_RESULT([powerpc])
2395       AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
2396                          [powerpc atomic implementation])
2397       glib_memory_barrier_needed=yes
2398       AC_MSG_CHECKING([whether asm supports numbered local labels])
2399       AC_TRY_COMPILE(
2400                 ,[
2401                         __asm__ __volatile__ ("1:       nop\n"
2402                                               "         bne-    1b")
2403                 ],[
2404                         AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
2405                         AC_MSG_RESULT([yes])
2406                 ],[
2407                         AC_MSG_RESULT([no])
2408                 ])
2409       ;;
2410     ia64)
2411       AC_MSG_RESULT([ia64])
2412       AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
2413                          [ia64 atomic implementation])
2414       glib_memory_barrier_needed=yes
2415       ;;
2416     s390|s390x)
2417       AC_MSG_RESULT([s390])
2418       AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
2419                          [s390 atomic implementation])
2420       glib_memory_barrier_needed=no
2421       ;;
2422     arm*)
2423       AC_MSG_RESULT([arm])
2424       AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
2425                          [arm atomic implementation])
2426       glib_memory_barrier_needed=no
2427       ;;
2428     crisv32*|etraxfs*)
2429       AC_MSG_RESULT([crisv32])
2430       AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
2431                          [crisv32 atomic implementation])
2432       glib_memory_barrier_needed=no
2433       ;;
2434     cris*|etrax*)
2435       AC_MSG_RESULT([cris])
2436       AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
2437                          [cris atomic implementation])
2438       glib_memory_barrier_needed=no
2439       ;;
2440     *)
2441       AC_MSG_RESULT([none])
2442       glib_memory_barrier_needed=yes
2443       ;;
2444   esac
2445 else
2446   if test $glib_native_win32 = yes; then
2447     # For Windows but not using gcc. No barriers needed then either.
2448     glib_memory_barrier_needed=no
2449   fi
2450 fi
2451
2452 dnl ****************************************
2453 dnl *** GLib POLL* compatibility defines ***
2454 dnl ****************************************
2455
2456 glib_poll_includes=["
2457 #include <sys/types.h>
2458 #include <sys/poll.h>
2459 "]
2460
2461 if test $ac_cv_header_sys_types_h = yes &&
2462    test $ac_cv_header_sys_poll_h = yes ; then
2463   glib_failed=false
2464   GLIB_CHECK_VALUE(POLLIN, $glib_poll_includes, glib_failed=true)
2465   GLIB_CHECK_VALUE(POLLOUT, $glib_poll_includes, glib_failed=true)
2466   GLIB_CHECK_VALUE(POLLPRI, $glib_poll_includes, glib_failed=true)
2467   GLIB_CHECK_VALUE(POLLERR, $glib_poll_includes, glib_failed=true)
2468   GLIB_CHECK_VALUE(POLLHUP, $glib_poll_includes, glib_failed=true)
2469   GLIB_CHECK_VALUE(POLLNVAL, $glib_poll_includes, glib_failed=true)
2470   if $glib_failed ; then
2471     AC_MSG_ERROR([Could not determine values for POLL* constants])
2472   fi
2473 else
2474   glib_cv_value_POLLIN=1
2475   glib_cv_value_POLLOUT=4
2476   glib_cv_value_POLLPRI=2
2477   glib_cv_value_POLLERR=8
2478   glib_cv_value_POLLHUP=16
2479   glib_cv_value_POLLNVAL=32
2480 fi
2481
2482 AC_MSG_CHECKING([for broken poll])
2483 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2484         #include <stdlib.h>
2485         #include <fcntl.h>
2486         #include <poll.h>
2487         #ifdef HAVE_SYS_POLL_H
2488         #include <sys/poll.h>
2489         #endif
2490         int main(void) {
2491           struct pollfd fds[1];
2492           int fd;
2493           fd = open("/dev/null", 1);
2494           fds[0].fd = fd;
2495           fds[0].events = POLLIN;
2496           fds[0].revents = 0;
2497           if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) {
2498                 exit(1);  /* Does not work for devices -- fail */
2499           }
2500           exit(0);
2501         }]])],
2502   [broken_poll=no],
2503   [broken_poll=yes
2504    AC_DEFINE(BROKEN_POLL,1,[poll doesn't work on devices])],
2505   [broken_poll="no (cross compiling)"])
2506 AC_MSG_RESULT($broken_poll)
2507
2508 dnl *********************
2509 dnl *** GRegex checks ***
2510 dnl *********************
2511 PCRE_REQUIRED_VERSION=7.2
2512
2513 # Check if we should compile GRegex
2514 AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
2515               [disable the compilation of GRegex]),
2516 [case "${enableval}" in
2517   yes) enable_regex=true ;;
2518   no)  enable_regex=false ;;
2519   *) AC_MSG_ERROR(bad value ${enableval} for --enable-regex) ;;
2520 esac],
2521 [enable_regex=true])
2522
2523 AM_CONDITIONAL(ENABLE_REGEX, $enable_regex)
2524
2525 if test x$enable_regex = xtrue; then
2526   AC_DEFINE(ENABLE_REGEX, [], [include GRegex])
2527   # Check if we should use the internal or the system-supplied pcre
2528   AC_ARG_WITH(pcre,
2529              [AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
2530                              [specify whether to use the internal or the
2531                               system-supplied PCRE library])])
2532
2533   AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
2534
2535   if test "x$with_pcre" = xsystem; then
2536     PKG_CHECK_MODULES(PCRE,
2537                       libpcre >= $PCRE_REQUIRED_VERSION)
2538     AC_CACHE_CHECK([for Unicode support in PCRE],glib_cv_pcre_has_unicode,[
2539                    glib_save_CFLAGS="$CFLAGS"
2540                    glib_save_LIBS="$LIBS"
2541                    CFLAGS="$CFLAGS $PCRE_CFLAGS" LIBS="$PCRE_LIBS"
2542                    AC_TRY_RUN([#include <pcre.h>
2543                                int main () {
2544                                  int support;
2545                                  pcre_config (PCRE_CONFIG_UTF8, &support);
2546                                  if (!support)
2547                                    return 1;
2548                                  pcre_config (PCRE_CONFIG_UNICODE_PROPERTIES, &support);
2549                                  if (!support)
2550                                    return 1;
2551                                  return 0;
2552                                }],
2553                    glib_cv_pcre_has_unicode=yes,
2554                    glib_cv_pcre_has_unicode=no,
2555                    glib_cv_pcre_has_unicode=yes)
2556                    CFLAGS="$glib_save_CFLAGS"
2557                    LIBS="$glib_save_LIBS"
2558         ])
2559     if test "$glib_cv_pcre_has_unicode" = "no"; then
2560       AC_MSG_ERROR([*** The system-supplied PCRE does not support Unicode properties or UTF-8.])
2561     fi
2562     AC_SUBST(PCRE_CFLAGS)
2563     AC_SUBST(PCRE_LIBS)
2564     AC_DEFINE(USE_SYSTEM_PCRE, [], [using the system-supplied PCRE library])
2565     PCRE_REQUIRES=libpcre
2566     AC_SUBST(PCRE_REQUIRES)
2567   else
2568     # If using gcc 4 pass -Wno-pointer-sign when compiling the internal PCRE
2569     if test x"$GCC" = xyes; then
2570       AC_MSG_CHECKING([whether compiler understands -Wno-pointer-sign])
2571       save_CFLAGS="$CFLAGS"
2572       CFLAGS="$CFLAGS -Wno-pointer-sign"
2573       AC_TRY_COMPILE([],[],[PCRE_WARN_CFLAGS="$PCRE_WARN_CFLAGS -Wno-pointer-sign"
2574                             AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
2575       CFLAGS="$save_CFLAGS"
2576     fi
2577   fi
2578   AC_SUBST(PCRE_WARN_CFLAGS)
2579 else
2580   AM_CONDITIONAL(USE_SYSTEM_PCRE, false])
2581 fi
2582
2583 dnl **********************
2584 dnl *** Win32 API libs ***
2585 dnl **********************
2586
2587 case $host in
2588   *-*-cygwin*)
2589         G_LIBS_EXTRA="-luser32 -lkernel32"
2590     ;;
2591   *-*-mingw*)
2592         G_LIBS_EXTRA="-lws2_32 -lole32"
2593     ;;
2594   *)
2595         G_LIBS_EXTRA=""
2596     ;;
2597 esac
2598 AC_SUBST(G_LIBS_EXTRA)
2599
2600 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
2601 dnl since we need it for g_iconv()
2602
2603 AC_MSG_CHECKING([for EILSEQ])
2604 AC_TRY_COMPILE([
2605 #include <errno.h>
2606 ],
2607 [
2608 int error = EILSEQ;
2609 ], have_eilseq=yes, have_eilseq=no);
2610 AC_MSG_RESULT($have_eilseq)
2611
2612 dnl ******************************************************************
2613 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
2614 dnl ******************************************************************
2615
2616 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
2617
2618 if test $cross_compiling = yes; then
2619   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
2620   if test x$GLIB_GENMARSHAL = xno; then
2621     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
2622   fi
2623 fi
2624
2625 dnl **************************
2626 dnl *** Checks for gtk-doc ***
2627 dnl **************************
2628
2629 GTK_DOC_CHECK([1.11])
2630
2631 AC_ARG_ENABLE(man,
2632               [AC_HELP_STRING([--enable-man],
2633                               [regenerate man pages from Docbook [default=no]])],enable_man=yes,
2634               enable_man=no)
2635
2636 if test "${enable_man}" != no; then
2637 dnl
2638 dnl Check for xsltproc
2639 dnl
2640 AC_PATH_PROG([XSLTPROC], [xsltproc])
2641   if test -z "$XSLTPROC"; then
2642     enable_man=no
2643   fi
2644
2645   dnl check for DocBook DTD and stylesheets in the local catalog.
2646   JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
2647      [DocBook XML DTD V4.1.2],,enable_man=no)
2648   JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
2649      [DocBook XSL Stylesheets],,enable_man=no)
2650 fi
2651
2652 AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)
2653
2654 dnl ******************************
2655 dnl *** output the whole stuff ***
2656 dnl ******************************
2657
2658 dnl this section will only be run if config.status is invoked with no
2659 dnl arguments, or with "glibconfig.h" as an argument.
2660 AC_CONFIG_COMMANDS([glibconfig.h],
2661 [
2662         outfile=glibconfig.h-tmp
2663         cat > $outfile <<\_______EOF
2664 /* glibconfig.h
2665  *
2666  * This is a generated file.  Please modify 'configure.in'
2667  */
2668
2669 #ifndef __G_LIBCONFIG_H__
2670 #define __G_LIBCONFIG_H__
2671
2672 #include <glib/gmacros.h>
2673
2674 _______EOF
2675
2676         if test x$glib_limits_h = xyes; then
2677           echo '#include <limits.h>' >> $outfile
2678         fi
2679         if test x$glib_float_h = xyes; then
2680           echo '#include <float.h>' >> $outfile
2681         fi
2682         if test x$glib_values_h = xyes; then
2683           echo '#include <values.h>' >> $outfile
2684         fi
2685         if test "$glib_header_alloca_h" = "yes"; then
2686           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
2687         fi
2688         if test x$glib_sys_poll_h = xyes; then
2689           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
2690         fi
2691         if test x$glib_included_printf != xyes; then
2692           echo "
2693 /* Specifies that GLib's g_print*() functions wrap the
2694  * system printf functions.  This is useful to know, for example,
2695  * when using glibc's register_printf_function().
2696  */" >> $outfile
2697           echo '#define GLIB_USING_SYSTEM_PRINTF' >> $outfile
2698         fi
2699
2700         cat >> $outfile <<_______EOF
2701
2702 G_BEGIN_DECLS
2703
2704 #define G_MINFLOAT      $glib_mf
2705 #define G_MAXFLOAT      $glib_Mf
2706 #define G_MINDOUBLE     $glib_md
2707 #define G_MAXDOUBLE     $glib_Md
2708 #define G_MINSHORT      $glib_ms
2709 #define G_MAXSHORT      $glib_Ms
2710 #define G_MAXUSHORT     $glib_Mus
2711 #define G_MININT        $glib_mi
2712 #define G_MAXINT        $glib_Mi
2713 #define G_MAXUINT       $glib_Mui
2714 #define G_MINLONG       $glib_ml
2715 #define G_MAXLONG       $glib_Ml
2716 #define G_MAXULONG      $glib_Mul
2717
2718 _______EOF
2719
2720
2721         ### this should always be true in a modern C/C++ compiler
2722         cat >>$outfile <<_______EOF
2723 typedef signed char gint8;
2724 typedef unsigned char guint8;
2725 _______EOF
2726
2727
2728         if test -n "$gint16"; then
2729           cat >>$outfile <<_______EOF
2730 typedef signed $gint16 gint16;
2731 typedef unsigned $gint16 guint16;
2732 #define G_GINT16_MODIFIER $gint16_modifier
2733 #define G_GINT16_FORMAT $gint16_format
2734 #define G_GUINT16_FORMAT $guint16_format
2735 _______EOF
2736         fi
2737
2738
2739         if test -n "$gint32"; then
2740           cat >>$outfile <<_______EOF
2741 typedef signed $gint32 gint32;
2742 typedef unsigned $gint32 guint32;
2743 #define G_GINT32_MODIFIER $gint32_modifier
2744 #define G_GINT32_FORMAT $gint32_format
2745 #define G_GUINT32_FORMAT $guint32_format
2746 _______EOF
2747         fi
2748
2749         cat >>$outfile <<_______EOF
2750 #define G_HAVE_GINT64 1          /* deprecated, always true */
2751
2752 ${glib_extension}typedef signed $gint64 gint64;
2753 ${glib_extension}typedef unsigned $gint64 guint64;
2754
2755 #define G_GINT64_CONSTANT(val)  $gint64_constant
2756 #define G_GUINT64_CONSTANT(val) $guint64_constant
2757 _______EOF
2758
2759         if test x$gint64_format != x ; then
2760           cat >>$outfile <<_______EOF
2761 #define G_GINT64_MODIFIER $gint64_modifier
2762 #define G_GINT64_FORMAT $gint64_format
2763 #define G_GUINT64_FORMAT $guint64_format
2764 _______EOF
2765         else
2766           cat >>$outfile <<_______EOF
2767 #undef G_GINT64_MODIFIER
2768 #undef G_GINT64_FORMAT
2769 #undef G_GUINT64_FORMAT
2770 _______EOF
2771         fi
2772
2773         cat >>$outfile <<_______EOF
2774
2775 #define GLIB_SIZEOF_VOID_P $glib_void_p
2776 #define GLIB_SIZEOF_LONG   $glib_long
2777 #define GLIB_SIZEOF_SIZE_T $glib_size_t
2778
2779 _______EOF
2780
2781         cat >>$outfile <<_______EOF
2782 typedef signed $glib_size_type_define gssize;
2783 typedef unsigned $glib_size_type_define gsize;
2784 #define G_GSIZE_MODIFIER $gsize_modifier
2785 #define G_GSSIZE_FORMAT $gssize_format
2786 #define G_GSIZE_FORMAT $gsize_format
2787
2788 #define G_MAXSIZE       G_MAXU$glib_msize_type
2789 #define G_MINSSIZE      G_MIN$glib_msize_type
2790 #define G_MAXSSIZE      G_MAX$glib_msize_type
2791
2792 typedef gint64 goffset;
2793 #define G_MINOFFSET     G_MININT64
2794 #define G_MAXOFFSET     G_MAXINT64
2795
2796 #define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
2797 #define G_GOFFSET_FORMAT        G_GINT64_FORMAT
2798 #define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
2799
2800 _______EOF
2801
2802         if test -z "$glib_unknown_void_p"; then
2803           cat >>$outfile <<_______EOF
2804
2805 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
2806 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
2807
2808 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
2809 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
2810
2811 typedef signed $glib_intptr_type_define gintptr;
2812 typedef unsigned $glib_intptr_type_define guintptr;
2813 _______EOF
2814         else
2815           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
2816         fi
2817
2818
2819
2820         cat >>$outfile <<_______EOF
2821 $glib_atexit
2822 $glib_memmove
2823 $glib_defines
2824 $glib_os
2825 $glib_static_compilation
2826
2827 $glib_vacopy
2828
2829 #ifdef  __cplusplus
2830 #define G_HAVE_INLINE   1
2831 #else   /* !__cplusplus */
2832 $glib_inline
2833 #endif  /* !__cplusplus */
2834
2835 #ifdef  __cplusplus
2836 #define G_CAN_INLINE    1
2837 _______EOF
2838
2839         if test x$g_can_inline = xyes ; then
2840                 cat >>$outfile <<_______EOF
2841 #else   /* !__cplusplus */
2842 #define G_CAN_INLINE    1
2843 _______EOF
2844         fi
2845
2846         cat >>$outfile <<_______EOF
2847 #endif
2848
2849 _______EOF
2850
2851         if test x$g_have_iso_c_varargs = xyes ; then
2852                 cat >>$outfile <<_______EOF
2853 #ifndef __cplusplus
2854 # define G_HAVE_ISO_VARARGS 1
2855 #endif
2856 _______EOF
2857         fi
2858         if test x$g_have_iso_cxx_varargs = xyes ; then
2859                 cat >>$outfile <<_______EOF
2860 #ifdef __cplusplus
2861 # define G_HAVE_ISO_VARARGS 1
2862 #endif
2863 _______EOF
2864         fi
2865         if test x$g_have_gnuc_varargs = xyes ; then
2866                 cat >>$outfile <<_______EOF
2867
2868 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
2869  * is passed ISO vararg support is turned off, and there is no work
2870  * around to turn it on, so we unconditionally turn it off.
2871  */
2872 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
2873 #  undef G_HAVE_ISO_VARARGS
2874 #endif
2875
2876 #define G_HAVE_GNUC_VARARGS 1
2877 _______EOF
2878         fi
2879
2880         case x$g_stack_grows in
2881         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
2882         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
2883         esac
2884
2885
2886         echo >>$outfile
2887         if test x$g_have_eilseq = xno; then
2888                 cat >>$outfile <<_______EOF
2889 #ifndef EILSEQ
2890 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
2891  * The correspondence between this and the corresponding definition
2892  * in libiconv is essential.
2893  */
2894 #  define EILSEQ ENOENT
2895 #endif
2896 _______EOF
2897
2898         fi
2899
2900         if test x$g_have_gnuc_visibility = xyes; then
2901                 cat >>$outfile <<_______EOF
2902 #define G_HAVE_GNUC_VISIBILITY 1
2903 _______EOF
2904         fi
2905                 cat >>$outfile <<_______EOF
2906 #if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
2907 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2908 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
2909 #define G_GNUC_INTERNAL __hidden
2910 #elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
2911 #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
2912 #else
2913 #define G_GNUC_INTERNAL
2914 #endif
2915 _______EOF
2916
2917
2918         echo >>$outfile
2919         if test x$g_mutex_has_default = xyes; then
2920                 cat >>$outfile <<_______EOF
2921 $g_enable_threads_def G_THREADS_ENABLED
2922 #define G_THREADS_IMPL_$g_threads_impl_def
2923 typedef struct _GStaticMutex GStaticMutex;
2924 struct _GStaticMutex
2925 {
2926   struct _GMutex *runtime_mutex;
2927   union {
2928     char   pad[[$g_mutex_sizeof]];
2929     double dummy_double;
2930     void  *dummy_pointer;
2931     long   dummy_long;
2932   } static_mutex;
2933 };
2934 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
2935 #define g_static_mutex_get_mutex(mutex) \\
2936   (g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
2937    g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
2938 _______EOF
2939         else
2940                 cat >>$outfile <<_______EOF
2941 $g_enable_threads_def G_THREADS_ENABLED
2942 #define G_THREADS_IMPL_$g_threads_impl_def
2943 typedef struct _GMutex* GStaticMutex;
2944 #define G_STATIC_MUTEX_INIT NULL
2945 #define g_static_mutex_get_mutex(mutex) \\
2946   (g_static_mutex_get_mutex_impl_shortcut (mutex))
2947 _______EOF
2948         fi
2949
2950         cat >>$outfile <<_______EOF
2951 /* This represents a system thread as used by the implementation. An
2952  * alien implementaion, as loaded by g_thread_init can only count on
2953  * "sizeof (gpointer)" bytes to store their info. We however need more
2954  * for some of our native implementations. */
2955 typedef union _GSystemThread GSystemThread;
2956 union _GSystemThread
2957 {
2958   char   data[[$g_system_thread_sizeof]];
2959   double dummy_double;
2960   void  *dummy_pointer;
2961   long   dummy_long;
2962 };
2963 _______EOF
2964         if test x"$g_memory_barrier_needed" != xno; then
2965           echo >>$outfile
2966           echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
2967         fi
2968
2969         echo >>$outfile
2970         g_bit_sizes="16 32 64"
2971         for bits in $g_bit_sizes; do
2972           cat >>$outfile <<_______EOF
2973 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
2974 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
2975 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
2976 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
2977 _______EOF
2978         done
2979
2980         cat >>$outfile <<_______EOF
2981 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
2982 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
2983 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
2984 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
2985 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
2986 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
2987 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
2988 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
2989 #define G_BYTE_ORDER $g_byte_order
2990
2991 #define GLIB_SYSDEF_POLLIN =$g_pollin
2992 #define GLIB_SYSDEF_POLLOUT =$g_pollout
2993 #define GLIB_SYSDEF_POLLPRI =$g_pollpri
2994 #define GLIB_SYSDEF_POLLHUP =$g_pollhup
2995 #define GLIB_SYSDEF_POLLERR =$g_pollerr
2996 #define GLIB_SYSDEF_POLLNVAL =$g_pollnval
2997
2998 #define G_MODULE_SUFFIX "$g_module_suffix"
2999
3000 /* A GPid is an abstraction for a process "handle". It is *not* an
3001  * abstraction for a process identifier in general. GPid is used in
3002  * GLib only for descendant processes spawned with the g_spawn*
3003  * functions. On POSIX there is no "process handle" concept as such,
3004  * but on Windows a GPid is a handle to a process, a kind of pointer,
3005  * not a process identifier.
3006  */
3007 typedef $g_pid_type GPid;
3008
3009 #define GLIB_SYSDEF_AF_UNIX $g_af_unix
3010 #define GLIB_SYSDEF_AF_INET $g_af_inet
3011 #define GLIB_SYSDEF_AF_INET6 $g_af_inet6
3012
3013 G_END_DECLS
3014
3015 #endif /* GLIBCONFIG_H */
3016 _______EOF
3017
3018
3019         if cmp -s $outfile glibconfig.h; then
3020           AC_MSG_NOTICE([glibconfig.h is unchanged])
3021           rm -f $outfile
3022         else
3023           mv $outfile glibconfig.h
3024         fi
3025 ],[
3026
3027 # Note that if two cases are the same, case goes with the first one.
3028 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
3029 # on variable expansion in case labels.  Look at the generated config.status
3030 # for a hint.
3031
3032 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
3033   glib_header_alloca_h="$ac_cv_working_alloca_h"
3034 else
3035   glib_header_alloca_h="$ac_cv_header_alloca_h"
3036 fi
3037
3038 case xyes in
3039 x$ac_cv_header_float_h)
3040   glib_float_h=yes
3041   glib_mf=FLT_MIN glib_Mf=FLT_MAX
3042   glib_md=DBL_MIN glib_Md=DBL_MAX
3043   ;;
3044 x$ac_cv_header_values_h)
3045   glib_values_h=yes
3046   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
3047   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
3048   ;;
3049 esac
3050
3051 case xyes in
3052 x$ac_cv_header_limits_h)
3053   glib_limits_h=yes
3054   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
3055   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
3056   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
3057   ;;
3058 x$ac_cv_header_values_h)
3059   glib_values_h=yes
3060   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
3061   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
3062   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
3063   ;;
3064 esac
3065
3066 if test x$ac_cv_header_sys_poll_h = xyes ; then
3067   glib_sys_poll_h=yes
3068 fi
3069
3070 if test x$enable_included_printf = xyes ; then
3071   glib_included_printf=yes
3072 fi
3073
3074 case 2 in
3075 $ac_cv_sizeof_short)
3076   gint16=short
3077   gint16_modifier='"h"'
3078   gint16_format='"hi"'
3079   guint16_format='"hu"'
3080   ;;
3081 $ac_cv_sizeof_int)
3082   gint16=int
3083   gint16_modifier='""'
3084   gint16_format='"i"'
3085   guint16_format='"u"'
3086   ;;
3087 esac
3088 case 4 in
3089 $ac_cv_sizeof_short)
3090   gint32=short
3091   gint32_modifier='"h"'
3092   gint32_format='"hi"'
3093   guint32_format='"hu"'
3094   ;;
3095 $ac_cv_sizeof_int)
3096   gint32=int
3097   gint32_modifier='""'
3098   gint32_format='"i"'
3099   guint32_format='"u"'
3100   ;;
3101 $ac_cv_sizeof_long)
3102   gint32=long
3103   gint32_modifier='"l"'
3104   gint32_format='"li"'
3105   guint32_format='"lu"'
3106   ;;
3107 esac
3108 case 8 in
3109 $ac_cv_sizeof_int)
3110   gint64=int
3111   gint64_modifier='""'
3112   gint64_format='"i"'
3113   guint64_format='"u"'
3114   glib_extension=
3115   gint64_constant='(val)'
3116   guint64_constant='(val)'
3117   ;;
3118 $ac_cv_sizeof_long)
3119   gint64=long
3120   gint64_modifier='"l"'
3121   gint64_format='"li"'
3122   guint64_format='"lu"'
3123   glib_extension=
3124   gint64_constant='(val##L)'
3125   guint64_constant='(val##UL)'
3126   ;;
3127 $ac_cv_sizeof_long_long)
3128   gint64='long long'
3129   if test -n "$glib_cv_long_long_format"; then
3130     gint64_modifier='"'$glib_cv_long_long_format'"'
3131     gint64_format='"'$glib_cv_long_long_format'i"'
3132     guint64_format='"'$glib_cv_long_long_format'u"'
3133   fi
3134   glib_extension='G_GNUC_EXTENSION '
3135   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
3136   guint64_constant='(G_GNUC_EXTENSION (val##ULL))'
3137   ;;
3138 $ac_cv_sizeof___int64)
3139   gint64='__int64'
3140   if test -n "$glib_cv_long_long_format"; then
3141     gint64_modifier='"'$glib_cv_long_long_format'"'
3142     gint64_format='"'$glib_cv_long_long_format'i"'
3143     guint64_format='"'$glib_cv_long_long_format'u"'
3144   fi
3145   glib_extension=
3146   gint64_constant='(val##i64)'
3147   guint64_constant='(val##ui64)'
3148   ;;
3149 esac
3150 glib_size_t=$ac_cv_sizeof_size_t
3151 glib_size_type_define="$glib_size_type"
3152 glib_void_p=$ac_cv_sizeof_void_p
3153 glib_long=$ac_cv_sizeof_long
3154
3155 case "$glib_size_type" in
3156 short)
3157   gsize_modifier='"h"'
3158   gsize_format='"hu"'
3159   gssize_format='"hi"'
3160   glib_msize_type='SHRT'
3161   ;;
3162 int)
3163   gsize_modifier='""'
3164   gsize_format='"u"'
3165   gssize_format='"i"'
3166   glib_msize_type='INT'
3167   ;;
3168 long)
3169   gsize_modifier='"l"'
3170   gsize_format='"lu"'
3171   gssize_format='"li"'
3172   glib_msize_type='LONG'
3173   ;;
3174 "long long"|__int64)
3175   gsize_modifier='"I64"'
3176   gsize_format='"I64u"'
3177   gssize_format='"I64i"'
3178   glib_msize_type='INT64'
3179   ;;
3180 esac
3181
3182 gintbits=`expr $ac_cv_sizeof_int \* 8`
3183 glongbits=`expr $ac_cv_sizeof_long \* 8`
3184
3185 case $ac_cv_sizeof_void_p in
3186 $ac_cv_sizeof_int)
3187   glib_intptr_type_define=int
3188   glib_gpi_cast=''
3189   glib_gpui_cast=''
3190   ;;
3191 $ac_cv_sizeof_long)
3192   glib_intptr_type_define=long
3193   glib_gpi_cast='(glong)'
3194   glib_gpui_cast='(gulong)'
3195   ;;
3196 $ac_cv_sizeof_long_long)
3197   glib_intptr_type_define='long long'
3198   glib_gpi_cast='(gint64)'
3199   glib_gpui_cast='(guint64)'
3200   ;;
3201 $ac_cv_sizeof___int64)
3202   glib_intptr_type_define=__int64
3203   glib_gpi_cast='(gint64)'
3204   glib_gpui_cast='(guint64)'
3205   ;;
3206 *)
3207   glib_unknown_void_p=yes
3208   ;;
3209 esac
3210
3211
3212 case xyes in
3213 x$ac_cv_func_atexit)
3214   glib_atexit="
3215 #ifdef NeXT /* @#%@! NeXTStep */
3216 # define g_ATEXIT(proc) (!atexit (proc))
3217 #else
3218 # define g_ATEXIT(proc) (atexit (proc))
3219 #endif"
3220   ;;
3221 x$ac_cv_func_on_exit)
3222   glib_atexit="
3223 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
3224   ;;
3225 esac
3226
3227 case xyes in
3228 x$ac_cv_func_memmove)
3229   glib_memmove='
3230 #define g_memmove(dest,src,len) G_STMT_START { memmove ((dest), (src), (len)); } G_STMT_END'
3231   ;;
3232 x$glib_cv_working_bcopy)
3233   glib_memmove="
3234 /* memmove isn't available, but bcopy can copy overlapping memory regions */
3235 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
3236   ;;
3237 *)
3238   glib_memmove="
3239 /* memmove isn't found and bcopy can't copy overlapping memory regions,
3240  * so we have to roll our own copy routine. */
3241 void g_memmove (void* dest, const void * src, unsigned long len);"
3242   ;;
3243 esac
3244
3245 glib_defines="
3246 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
3247 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
3248 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
3249 "
3250
3251 case xyes in
3252 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
3253 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
3254 *)                      glib_vacopy=''
3255 esac
3256
3257 if test x$glib_cv_va_val_copy = xno; then
3258   glib_vacopy="\$glib_vacopy
3259 #define G_VA_COPY_AS_ARRAY 1"
3260 fi
3261
3262 if test x$glib_cv_hasinline = xyes; then
3263     glib_inline='#define G_HAVE_INLINE 1'
3264 fi
3265 if test x$glib_cv_has__inline = xyes; then
3266     glib_inline="\$glib_inline
3267 #define G_HAVE___INLINE 1"
3268 fi
3269 if test x$glib_cv_has__inline__ = xyes; then
3270     glib_inline="\$glib_inline
3271 #define G_HAVE___INLINE__ 1"
3272 fi
3273
3274 g_have_gnuc_varargs=$g_have_gnuc_varargs
3275 g_have_iso_c_varargs=$g_have_iso_c_varargs
3276 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
3277
3278 g_can_inline=$g_can_inline
3279 g_have_gnuc_visibility=$g_have_gnuc_visibility
3280 g_have_sunstudio_visibility=$g_have_sunstudio_visibility
3281
3282 if test x$ac_cv_c_bigendian = xyes; then
3283   g_byte_order=G_BIG_ENDIAN
3284   g_bs_native=BE
3285   g_bs_alien=LE
3286 else
3287   g_byte_order=G_LITTLE_ENDIAN
3288   g_bs_native=LE
3289   g_bs_alien=BE
3290 fi
3291
3292 g_pollin=$glib_cv_value_POLLIN
3293 g_pollout=$glib_cv_value_POLLOUT
3294 g_pollpri=$glib_cv_value_POLLPRI
3295 g_pollhup=$glib_cv_value_POLLHUP
3296 g_pollerr=$glib_cv_value_POLLERR
3297 g_pollnval=$glib_cv_value_POLLNVAL
3298
3299 g_af_unix=$glib_cv_value_AF_UNIX
3300 g_af_inet=$glib_cv_value_AF_INET
3301 g_af_inet6=$glib_cv_value_AF_INET6
3302
3303 g_stack_grows=$glib_cv_stack_grows
3304
3305 g_have_eilseq=$have_eilseq
3306
3307 case x$have_threads in
3308 xno)    g_enable_threads_def="#undef";;
3309 *)      g_enable_threads_def="#define";;
3310 esac
3311
3312 g_threads_impl_def=$g_threads_impl
3313
3314 g_mutex_has_default="$mutex_has_default"
3315 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
3316 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
3317 g_mutex_contents="$glib_cv_byte_contents_gmutex"
3318
3319 g_memory_barrier_needed="$glib_memory_barrier_needed"
3320
3321 g_module_suffix="$glib_gmodule_suffix"
3322
3323 g_pid_type="$glib_pid_type"
3324 case $host in
3325   *-*-beos*)
3326     glib_os="#define G_OS_BEOS"
3327     ;;
3328   *-*-cygwin*)
3329     glib_os="#define G_OS_UNIX
3330 #define G_PLATFORM_WIN32
3331 #define G_WITH_CYGWIN"
3332     ;;
3333   *-*-mingw*)
3334     glib_os="#define G_OS_WIN32
3335 #define G_PLATFORM_WIN32"
3336     ;;
3337   *)
3338     glib_os="#define G_OS_UNIX"
3339     ;;
3340 esac
3341 glib_static_compilation=""
3342 if test x$glib_win32_static_compilation = xyes; then
3343   glib_static_compilation="#define GLIB_STATIC_COMPILATION 1
3344 #define GOBJECT_STATIC_COMPILATION 1"
3345 fi
3346 ])
3347
3348 AC_CONFIG_FILES([
3349 glib-2.0.pc
3350 glib-2.0-uninstalled.pc
3351 gmodule-2.0.pc
3352 gmodule-export-2.0.pc
3353 gmodule-no-export-2.0.pc
3354 gmodule-2.0-uninstalled.pc
3355 gmodule-no-export-2.0-uninstalled.pc
3356 gthread-2.0.pc
3357 gthread-2.0-uninstalled.pc
3358 gobject-2.0.pc
3359 gobject-2.0-uninstalled.pc
3360 gio-2.0.pc
3361 gio-unix-2.0.pc
3362 gio-2.0-uninstalled.pc
3363 gio-unix-2.0-uninstalled.pc
3364 glib-zip
3365 glib-gettextize
3366 Makefile
3367 build/Makefile
3368 build/win32/Makefile
3369 build/win32/dirent/Makefile
3370 build/win32/vs8/Makefile
3371 build/win32/vs9/Makefile
3372 glib/Makefile
3373 glib/libcharset/Makefile
3374 glib/gnulib/Makefile
3375 glib/pcre/Makefile
3376 glib/update-pcre/Makefile
3377 glib/tests/Makefile
3378 gmodule/Makefile
3379 gmodule/gmoduleconf.h
3380 gobject/Makefile
3381 gobject/glib-mkenums
3382 gobject/tests/Makefile
3383 gthread/Makefile
3384 gio/Makefile
3385 gio/xdgmime/Makefile
3386 gio/inotify/Makefile
3387 gio/fen/Makefile
3388 gio/fam/Makefile
3389 gio/win32/Makefile
3390 gio/tests/Makefile
3391 po/Makefile.in
3392 docs/Makefile
3393 docs/reference/Makefile
3394 docs/reference/glib/Makefile
3395 docs/reference/glib/version.xml
3396 docs/reference/gobject/Makefile
3397 docs/reference/gobject/version.xml
3398 docs/reference/gio/Makefile
3399 docs/reference/gio/version.xml
3400 tests/Makefile
3401 tests/gobject/Makefile
3402 tests/refcount/Makefile
3403 m4macros/Makefile
3404 ])
3405
3406 AC_CONFIG_COMMANDS([chmod-scripts],
3407 [chmod 0755 glib-zip
3408 chmod 0755 glib-gettextize
3409 chmod 0755 gobject/glib-mkenums])
3410
3411 # we want to invoke this macro solely so that the config.status script
3412 # and automake generated makefiles know about these generated files.
3413 # They are only needed to distcheck the package
3414 if false; then
3415   AC_CONFIG_FILES([
3416     INSTALL
3417     README
3418     config.h.win32
3419     glibconfig.h.win32
3420     glib/makefile.msc
3421     glib/glib.rc
3422     gmodule/makefile.msc
3423     gmodule/gmodule.rc
3424     gobject/makefile.msc
3425     gobject/gobject.rc
3426     gthread/makefile.msc
3427     gthread/gthread.rc
3428     tests/makefile.msc
3429   ])
3430 fi
3431
3432 AC_OUTPUT