configure.in

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