configure.in

   1 dnl ***********************************
   2 dnl *** include special GLib macros ***
   3 dnl ***********************************
   4 builtin(include, acglib.m4)dnl
   5 builtin(include, glib/libcharset/codeset.m4)dnl
   6 builtin(include, glib/libcharset/glibc21.m4)dnl
   7
   8 # require autoconf 2.52
   9 AC_PREREQ(2.52)
  10
  11 # Process this file with autoconf to produce a configure script.
  12 AC_INIT(glib/glib.h)
  13
  14 # Save this value here, since automake will set cflags later
  15 cflags_set=${CFLAGS+set}
  16
  17 # we rewrite this file
  18 rm -f glibconfig-sysdefs.h
  19
  20 GLIB_AC_DIVERT_BEFORE_HELP([
  21 #
  22 # The following version number definitions apply to GLib, GModule, GObject
  23 # and GThread as a whole, so if changes occoured in any of them, they are all
  24 # treated with the same interface and binary age.
  25 #
  26 # Making releases:
  27 #   GLIB_MICRO_VERSION += 1;
  28 #   GLIB_INTERFACE_AGE += 1;
  29 #   GLIB_BINARY_AGE += 1;
  30 # if any functions have been added, set GLIB_INTERFACE_AGE to 0.
  31 # if backwards compatibility has been broken,
  32 # set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0.
  33 #
  34 GLIB_MAJOR_VERSION=2
  35 GLIB_MINOR_VERSION=1
  36 GLIB_MICRO_VERSION=0
  37 GLIB_INTERFACE_AGE=0
  38 GLIB_BINARY_AGE=0
  39 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
  40 ])dnl
  41
  42 AC_SUBST(GLIB_MAJOR_VERSION)
  43 AC_SUBST(GLIB_MINOR_VERSION)
  44 AC_SUBST(GLIB_MICRO_VERSION)
  45 AC_SUBST(GLIB_VERSION)
  46 AC_SUBST(GLIB_INTERFACE_AGE)
  47 AC_SUBST(GLIB_BINARY_AGE)
  48
  49 # libtool versioning
  50 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
  51 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
  52 LT_REVISION=$GLIB_INTERFACE_AGE
  53 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
  54 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
  55 AC_SUBST(LT_RELEASE)
  56 AC_SUBST(LT_CURRENT)
  57 AC_SUBST(LT_REVISION)
  58 AC_SUBST(LT_AGE)
  59 AC_SUBST(LT_CURRENT_MINUS_AGE)
  60
  61 VERSION=$GLIB_VERSION
  62 PACKAGE=glib
  63
  64 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  65
  66 # Specify a configuration file
  67 AM_CONFIG_HEADER(config.h)
  68
  69 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION,
  70                    [Define to the GLIB major version])
  71 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION,
  72                    [Define to the GLIB minor version])
  73 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION,
  74                    [Define to the GLIB micro version])
  75 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE,
  76                    [Define to the GLIB interface age])
  77 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE,
  78                    [Define to the GLIB binary age])
  79
  80 dnl Initialize maintainer mode
  81 AM_MAINTAINER_MODE
  82
  83 AC_CANONICAL_HOST
  84
  85 AC_MSG_CHECKING(for the BeOS)
  86 case $host in
  87   *-*-beos*)
  88     glib_native_beos="yes"
  89     ;;
  90   *)
  91     glib_native_beos="no"
  92     ;;
  93 esac
  94 AC_MSG_RESULT([$glib_native_beos])
  95
  96 dnl
  97
  98 AC_MSG_CHECKING([for Win32])
  99 case "$host" in
 100   *-*-mingw*)
 101     glib_native_win32=yes
 102     G_LIB_WIN32_RESOURCE=glib-win32res.lo
 103     G_MODULE_WIN32_RESOURCE=gmodule-win32res.lo
 104     G_OBJECT_WIN32_RESOURCE=gobject-win32res.lo
 105     G_THREAD_WIN32_RESOURCE=gthread-win32res.lo
 106     GLIB_DEF=glib.def
 107     GMODULE_DEF=gmodule.def
 108     GOBJECT_DEF=gobject.def
 109     GTHREAD_DEF=gthread.def
 110     TESTGMODULE_EXP=testgmodule.exp
 111     ;;
 112   *)
 113     glib_native_win32=no
 114     G_LIB_WIN32_RESOURCE=
 115     G_MODULE_WIN32_RESOURCE=
 116     G_OBJECT_WIN32_RESOURCE=
 117     G_THREAD_WIN32_RESOURCE=
 118     GLIB_DEF=
 119     GMODULE_DEF=
 120     GOBJECT_DEF=
 121     GTHREAD_DEF=
 122     TESTGMODULE_EXP=
 123     ;;
 124 esac
 125 AC_MSG_RESULT([$glib_native_win32])
 126 AM_CONDITIONAL(OS_WIN32, test "$glib_native_win32" = "yes")
 127 AC_SUBST(G_LIB_WIN32_RESOURCE)
 128 AC_SUBST(G_MODULE_WIN32_RESOURCE)
 129 AC_SUBST(G_OBJECT_WIN32_RESOURCE)
 130 AC_SUBST(G_THREAD_WIN32_RESOURCE)
 131 AC_SUBST(GLIB_DEF)
 132 AC_SUBST(GMODULE_DEF)
 133 AC_SUBST(GOBJECT_DEF)
 134 AC_SUBST(GTHREAD_DEF)
 135 AC_SUBST(TESTGMODULE_EXP)
 136
 137 if test "$glib_native_win32" = "yes"; then
 138   AC_CHECK_PROG(ms_librarian, lib.exe, yes, no)
 139 fi
 140 AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes)
 141
 142 GLIB_AC_DIVERT_BEFORE_HELP([
 143 # figure debugging default, prior to $ac_help setup
 144 case $GLIB_MINOR_VERSION in
 145 *[[13579]]) debug_default=yes ;;
 146 *)          debug_default=minimum ;;
 147 esac[]dnl
 148 ])
 149
 150 dnl declare --enable-* args and collect ac_help strings
 151 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
 152 AC_ARG_ENABLE(gc_friendly, [  --enable-gc-friendly    turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
 153 AC_ARG_ENABLE(mem_pools, [  --disable-mem-pools     disable all glib memory pools],,disable_mem_pools=no)
 154 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
 155                     , enable_ansi=no)
 156 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
 157                           ([=no] will override --with-threads)],,enable_threads=yes)
 158 AC_ARG_ENABLE(rebuilds, [  --disable-rebuilds      disable all source autogeneration rules],,enable_rebuilds=yes)
 159
 160 if test "x$enable_threads" != "xyes"; then
 161   enable_threads=no
 162 fi
 163
 164 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}",
 165         [Whether glib was compiled with debugging enabled])
 166
 167 AC_MSG_CHECKING(whether to enable garbage collector friendliness)
 168 if test "x$enable_gc_friendly" = "xyes"; then
 169   AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
 170   AC_SUBST(ENABLE_GC_FRIENDLY)
 171   AC_MSG_RESULT(yes)
 172 else
 173   AC_MSG_RESULT(no)
 174 fi
 175
 176 AC_MSG_CHECKING(whether to disable memory pools)
 177 if test "x$disable_mem_pools" = "xno"; then
 178   AC_MSG_RESULT(no)
 179 else
 180   AC_DEFINE(DISABLE_MEM_POOLS, 1, [Whether to disable memory pools])
 181   AC_SUBST(DISABLE_MEM_POOLS)
 182   AC_MSG_RESULT(yes)
 183 fi
 184
 185 dnl Checks for programs.
 186 AC_PROG_CC
 187
 188 dnl Check for a working C++ compiler, but do not bail out, if none is found.
 189 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, gcc)
 190 AC_LANG_SAVE
 191 AC_LANG_CPLUSPLUS
 192 AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
 193 AM_CONDITIONAL(HAVE_CXX, test "$CXX" != "")
 194 AC_LANG_RESTORE
 195
 196 AM_PROG_CC_STDC
 197 AC_PROG_INSTALL
 198
 199 AC_SYS_LARGEFILE
 200
 201 #
 202 # Find pkg-config
 203 #
 204 AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
 205 if test x$PKG_CONFIG = xno ; then
 206   AC_MSG_ERROR([*** pkg-config not found. See http://www.freedesktop.org/software/pkgconfig/])
 207 fi
 208
 209 if $PKG_CONFIG --atleast-pkgconfig-version 0.5 ; then
 210   :
 211 else
 212   AC_MSG_ERROR([*** pkg-config too old; version 0.5 or better required.])
 213 fi
 214
 215 if test "x$enable_debug" = "xyes"; then
 216   if test x$cflags_set != xset ; then
 217       case " $CFLAGS " in
 218       *[[\ \    ]]-g[[\ \       ]]*) ;;
 219       *) CFLAGS="$CFLAGS -g" ;;
 220       esac
 221   fi
 222
 223   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 224 else
 225   if test "x$enable_debug" = "xno"; then
 226     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 227   fi
 228 fi
 229
 230 # Ensure -fnative-struct is used when compiling for Win32
 231 if test "x$glib_native_win32" = "xyes"; then
 232   if test "x$GCC" = "xyes"; then
 233     case " $CFLAGS " in
 234     *[[\ \      ]]-fnative-struct[[\ \  ]]*) ;;
 235     *) CFLAGS="$CFLAGS -fnative-struct" ;;
 236     esac
 237   fi
 238 fi
 239
 240 AC_CYGWIN
 241 AC_EXEEXT
 242
 243 # define a MAINT-like variable REBUILD which is set if Perl
 244 # and awk are found, so autogenerated sources can be rebuilt
 245 AC_PROG_AWK
 246 AC_CHECK_PROGS(PERL, perl5 perl)
 247 # We would like indent, but don't require it.
 248 AC_CHECK_PROG(INDENT, indent, indent)
 249 REBUILD=\#
 250 if test "x$enable_rebuilds" = "xyes" && \
 251      test -n "$PERL" && \
 252      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 253      test -n "$AWK" ; then
 254   REBUILD=
 255 fi
 256 AC_SUBST(REBUILD)
 257
 258 # Need full path to Perl for glib-mkenums
 259 #
 260 if test "x$PERL" != x ; then
 261   AC_PATH_PROG(PERL_PATH, $PERL)
 262 else
 263   PERL_PATH="/usr/bin/env perl"
 264 fi
 265 AC_SUBST(PERL_PATH)
 266
 267 dnl ***********************
 268 dnl *** Tests for iconv ***
 269 dnl ***********************
 270 dnl
 271 dnl We do this before the gettext checks, to avoid distortion
 272
 273 AC_ARG_WITH(libiconv, [  --with-libiconv=[no/gnu/native] use the libiconv library ],,with_libiconv=maybe)
 274
 275 found_iconv=no
 276 case $with_libiconv in
 277   maybe)
 278     # Check in the C library first
 279     AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes)
 280     # Check if we have GNU libiconv
 281     if test $found_iconv = "no"; then
 282       AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=gnu; found_iconv=yes)
 283     fi
 284     # Check if we have a iconv in -liconv, possibly from vendor
 285     if test $found_iconv = "no"; then
 286       AC_CHECK_LIB(iconv, iconv_open, with_libiconv=native; found_iconv=yes)
 287     fi
 288     ;;
 289   no)
 290     AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes)
 291     ;;
 292   gnu|yes)
 293     AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=gnu; found_iconv=yes)
 294     ;;
 295   native)
 296     AC_CHECK_LIB(iconv, iconv_open, with_libiconv=native; found_iconv=yes)
 297     ;;
 298 esac
 299
 300 if test "x$found_iconv" = "xno" ; then
 301    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
 302 fi
 303
 304 dnl
 305 dnl gettext support
 306 dnl
 307
 308 ALL_LINGUAS="az bg ca cs de el es eu fr gl hi ja ko ms nl nn no pl pt ro ru sk sl sv ta tr uk vi zh_CN zh_TW"
 309 AM_GLIB_GNU_GETTEXT
 310
 311 if test "$gt_cv_func_dgettext_libc" = "yes" || test "$gt_cv_func_dgettext_libintl" = "yes"; then
 312   :
 313 else
 314   AC_MSG_ERROR([
 315 *** You must have either have gettext support in your C library, or use the
 316 *** GNU gettext library. (http://www.gnu.org/software/gettext/gettext.html
 317 ])
 318 fi
 319
 320 LIBS="$LIBS $INTLLIBS"
 321
 322 GETTEXT_PACKAGE=glib20
 323 AC_SUBST(GETTEXT_PACKAGE)
 324 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE")
 325
 326 # AM_GLIB_GNU_GETTEXT above substs $DATADIRNAME
 327 # this is the directory where the *.{mo,gmo} files are installed
 328 GLIB_LOCALE_DIR="${prefix}/${DATADIRNAME}/locale"
 329 AC_DEFINE_UNQUOTED(GLIB_LOCALE_DIR,"$GLIB_LOCALE_DIR")
 330
 331 AC_CHECK_FUNCS(bind_textdomain_codeset)
 332
 333 dnl
 334 dnl Now we are done with gettext checks, figure out ICONV_LIBS
 335 dnl
 336
 337 if test x$with_libiconv != xno ; then
 338   case " $INTLLIBS " in
 339   *[[\ \        ]]-liconv[[\ \  ]]*) ;;
 340   *) ICONV_LIBS="-liconv" ;;
 341   esac
 342 fi
 343 AC_SUBST(ICONV_LIBS)
 344
 345 case $with_libiconv in
 346   gnu)
 347     AC_DEFINE(USE_LIBICONV_GNU, [Using GNU libiconv])
 348     ;;
 349   native)
 350     AC_DEFINE(USE_LIBICONV_NATIVE, [Using a native implementation of iconv in a separate library])
 351     ;;
 352 esac
 353
 354 dnl Initialize libtool
 355 AM_DISABLE_STATIC
 356 AC_LIBTOOL_WIN32_DLL
 357 AM_PROG_LIBTOOL
 358
 359 if test "x$GCC" = "xyes"; then
 360   case " $CFLAGS " in
 361   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 362   *) CFLAGS="$CFLAGS -Wall" ;;
 363   esac
 364
 365   if test "x$enable_ansi" = "xyes"; then
 366     case " $CFLAGS " in
 367     *[[\ \      ]]-ansi[[\ \    ]]*) ;;
 368     *) CFLAGS="$CFLAGS -ansi" ;;
 369     esac
 370
 371     case " $CFLAGS " in
 372     *[[\ \      ]]-pedantic[[\ \        ]]*) ;;
 373     *) CFLAGS="$CFLAGS -pedantic" ;;
 374     esac
 375   fi
 376 fi
 377
 378 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 379 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 380 glib_save_LIBS=$LIBS
 381 LIBS="$LIBS -lm"
 382 AC_TRY_RUN([#include <math.h>
 383              int main (void) { return (log(1) != log(1.)); }],
 384      AC_MSG_RESULT(none needed),
 385      glib_save_CFLAGS=$CFLAGS
 386      CFLAGS="$CFLAGS -std1"
 387      AC_TRY_RUN([#include <math.h>
 388                  int main (void) { return (log(1) != log(1.)); }],
 389          AC_MSG_RESULT(-std1),
 390          AC_MSG_RESULT()
 391          CFLAGS=$glib_save_CFLAGS
 392          AC_MSG_WARN(
 393                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 394      )
 395 )
 396 LIBS=$glib_save_LIBS
 397
 398 dnl NeXTStep cc seems to need this
 399 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 400 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 401   AC_MSG_RESULT(none needed),
 402   glib_save_CFLAGS=$CFLAGS
 403   CFLAGS="$CFLAGS -posix"
 404   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 405     AC_MSG_RESULT(-posix),
 406     AC_MSG_RESULT()
 407     CFLAGS=$glib_save_CFLAGS
 408     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 409
 410 # Checks for header files.
 411 AC_HEADER_STDC
 412
 413 # Checks for library functions.
 414 AC_FUNC_VPRINTF
 415
 416 AC_FUNC_ALLOCA
 417
 418 AC_CHECK_FUNCS(atexit on_exit)
 419
 420 AC_CHECK_SIZEOF(char)
 421 AC_CHECK_SIZEOF(short)
 422 AC_CHECK_SIZEOF(long)
 423 AC_CHECK_SIZEOF(int)
 424 AC_CHECK_SIZEOF(void *)
 425 AC_CHECK_SIZEOF(long long)
 426 AC_CHECK_SIZEOF(__int64)
 427
 428 if test x$ac_cv_sizeof_long = x8 || test x$ac_cv_sizeof_long_long = x8 || test x$ac_cv_sizeof___int64 = x8 ; then
 429   :
 430 else
 431   AC_MSG_ERROR([
 432 *** GLib requires a 64 bit type. You might want to consider
 433 *** using the GNU C compiler.
 434 ])
 435 fi
 436
 437 if test x$ac_cv_sizeof_long_long = x8; then
 438         # long long is a 64 bit integer.
 439         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 440         AC_CACHE_VAL(glib_cv_long_long_format,[
 441                 for format in ll q I64; do
 442                   AC_TRY_RUN([#include <stdio.h>
 443                         int main()
 444                         {
 445                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 446                           char buffer[1000];
 447                           sprintf (buffer, "%${format}u", a);
 448                           sscanf (buffer, "%${format}u", &b);
 449                           exit (b!=a);
 450                         }
 451                         ],
 452                         glib_cv_long_long_format=${format}
 453                         break)
 454                 done])
 455         if test -n "$glib_cv_long_long_format"; then
 456           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 457         else
 458           AC_MSG_RESULT(none)
 459         fi
 460 elif test x$ac_cv_sizeof___int64 = x8; then
 461         # __int64 is a 64 bit integer.
 462         AC_MSG_CHECKING(for format to printf and scanf a guint64)
 463         # We know this is MSVC, and what the formats are
 464         glib_cv_long_long_format=I64
 465         AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 466 fi
 467
 468 dnl long doubles were not used, and a portability problem
 469 dnl AC_C_LONG_DOUBLE
 470 AC_C_CONST
 471
 472 dnl ok, here we try to check whether the systems prototypes for
 473 dnl malloc and friends actually match the prototypes provided
 474 dnl by gmem.h (keep in sync). i currently only know how to check
 475 dnl this reliably with gcc (-Werror), improvements for other
 476 dnl compilers are apprechiated.
 477 SANE_MALLOC_PROTOS=no
 478 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 479 glib_save_CFLAGS=$CFLAGS
 480 if test "x$GCC" = "xyes"; then
 481   CFLAGS="$CFLAGS -Werror"
 482   AC_TRY_COMPILE([#include <stdlib.h>], [
 483     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 484     void* (*my_malloc_p)  (size_t)         = malloc;
 485     void  (*my_free_p)    (void*)          = free;
 486     void* (*my_realloc_p) (void*, size_t)  = realloc;
 487     my_calloc_p = 0;
 488     my_malloc_p = 0;
 489     my_free_p = 0;
 490     my_realloc_p = 0;
 491   ],
 492     AC_DEFINE(SANE_MALLOC_PROTOS)
 493     SANE_MALLOC_PROTOS=yes)
 494 fi
 495 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 496 CFLAGS=$glib_save_CFLAGS
 497
 498 dnl
 499 dnl check in which direction the stack grows
 500 dnl
 501 AC_CACHE_CHECK([for growing stack pointer],glib_cv_stack_grows,[
 502         AC_TRY_RUN([
 503         volatile int *a = 0, *b = 0;
 504         void foo (void);
 505         int main () { volatile int y = 7; a = &y; foo (); return b > a; }
 506         void foo (void) { volatile int x = 5; b = &x; }
 507         ],
 508         glib_cv_stack_grows=no
 509         ,
 510         glib_cv_stack_grows=yes
 511         ,)
 512 ])
 513
 514 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 515 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 516 dnl actually supported.
 517 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 518         AC_TRY_RUN([
 519         __inline int foo () { return 0; }
 520         int main () { return foo (); }
 521         ],
 522         glib_cv_has__inline=yes
 523         ,
 524         glib_cv_has__inline=no
 525         ,)
 526 ])
 527 case x$glib_cv_has__inline in
 528 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 529 esac
 530 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 531         AC_TRY_RUN([
 532         __inline__ int foo () { return 0; }
 533         int main () { return foo (); }
 534         ],
 535         glib_cv_has__inline__=yes
 536         ,
 537         glib_cv_has__inline__=no
 538         ,)
 539 ])
 540 case x$glib_cv_has__inline__ in
 541 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 542 esac
 543 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 544         AC_TRY_RUN([
 545         #undef inline
 546         inline int foo () { return 0; }
 547         int main () { return foo (); }
 548         ],
 549         glib_cv_hasinline=yes
 550         ,
 551         glib_cv_hasinline=no
 552         ,)
 553 ])
 554 case x$glib_cv_hasinline in
 555 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 556 esac
 557
 558 # check for flavours of varargs macros
 559 AC_MSG_CHECKING(for ISO C99 varargs macros in C)
 560 AC_TRY_COMPILE([],[
 561 int a(int p1, int p2, int p3);
 562 #define call_a(...) a(1,__VA_ARGS__)
 563 call_a(2,3);
 564 ],g_have_iso_c_varargs=yes,g_have_iso_c_varargs=no)
 565 AC_MSG_RESULT($g_have_iso_c_varargs)
 566
 567 AC_MSG_CHECKING(for ISO C99 varargs macros in C++)
 568 if test "$CXX" = ""; then
 569 dnl No C++ compiler
 570   g_have_iso_cxx_varargs=no
 571 else
 572   AC_LANG_CPLUSPLUS
 573   AC_TRY_COMPILE([],[
 574 int a(int p1, int p2, int p3);
 575 #define call_a(...) a(1,__VA_ARGS__)
 576 call_a(2,3);
 577 ],g_have_iso_cxx_varargs=yes,g_have_iso_cxx_varargs=no)
 578   AC_LANG_C
 579 fi
 580 AC_MSG_RESULT($g_have_iso_cxx_varargs)
 581
 582 AC_MSG_CHECKING(for GNUC varargs macros)
 583 AC_TRY_COMPILE([],[
 584 int a(int p1, int p2, int p3);
 585 #define call_a(params...) a(1,params)
 586 call_a(2,3);
 587 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
 588 AC_MSG_RESULT($g_have_gnuc_varargs)
 589
 590 # check for bytesex stuff
 591 AC_C_BIGENDIAN
 592
 593 # check for header files
 594 AC_CHECK_HEADERS([dirent.h float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h])
 595 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
 596
 597 # Checks for libcharset
 598 jm_LANGINFO_CODESET
 599 jm_GLIBC21
 600 AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
 601 AC_CHECK_FUNCS(setlocale)
 602
 603 AC_MSG_CHECKING(whether make is GNU Make)
 604 STRIP_BEGIN=
 605 STRIP_END=
 606 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
 607         STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 608         STRIP_END=')'
 609         AC_MSG_RESULT(yes)
 610 else
 611         AC_MSG_RESULT(no)
 612 fi
 613 STRIP_DUMMY=
 614 AC_SUBST(STRIP_DUMMY)
 615 AC_SUBST(STRIP_BEGIN)
 616 AC_SUBST(STRIP_END)
 617
 618 # check additional type sizes
 619 size_includes=["
 620 #include <stdarg.h>
 621 #include <stdio.h>
 622 #include <ctype.h>
 623 #include <string.h>
 624 "]
 625 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 626   size_includes=["$size_includes
 627 #include <stdint.h>
 628 "]
 629 fi
 630 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 631   size_includes=["$size_includes
 632 #include <unistd.h>
 633 "]
 634 fi
 635 GLIB_SIZEOF([$size_includes], size_t, size_t)
 636 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 637 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 638
 639 dnl Try to figure out whether gsize, gssize should be long or int
 640 AC_MSG_CHECKING([for the appropriate definition for size_t])
 641
 642 case $glib_cv_sizeof_size_t in
 643   $ac_cv_sizeof_short)
 644       glib_size_type=short
 645       ;;
 646   $ac_cv_sizeof_int)
 647       glib_size_type=int
 648       ;;
 649   $ac_cv_sizeof_long)
 650       glib_size_type=long
 651       ;;
 652   *)  AC_MSG_ERROR([No type matching size_t in size])
 653       ;;
 654 esac
 655
 656 dnl If int/long are the same size, we see which one produces
 657 dnl warnings when used in the location as size_t. (This matters
 658 dnl on AIX with xlc)
 659 dnl
 660 if test $glib_cv_sizeof_size_t = $ac_cv_sizeof_int &&
 661    test $glib_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
 662   GLIB_CHECK_COMPILE_WARNINGS([
 663 #include <stddef.h>
 664 int main ()
 665 {
 666   size_t s = 1;
 667   unsigned int *size_int = &s;
 668   return (int)*size_int;
 669 }
 670     ],glib_size_type=int,
 671       [GLIB_CHECK_COMPILE_WARNINGS([
 672 #include <stddef.h>
 673 int main ()
 674 {
 675    size_t s = 1;
 676    unsigned long *size_long = &s;
 677    return (int)*size_long;
 678 }
 679         ],glib_size_type=long)])
 680 fi
 681
 682 AC_MSG_RESULT(unsigned $glib_size_type)
 683
 684 # Check for some functions
 685 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd nanosleep vasprintf unsetenv getc_unlocked)
 686
 687 AC_FUNC_VSNPRINTF_C99
 688
 689 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 690 # The check is borrowed from the PERL Configure script.
 691 if test "$ac_cv_func_memmove" != "yes"; then
 692   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 693     glib_cv_working_bcopy,[AC_TRY_RUN([
 694       int main() {
 695         char buf[128], abc[128], *b;
 696         int len, off, align;
 697         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 698         for (align = 7; align >= 0; align--) {
 699           for (len = 36; len; len--) {
 700             b = buf+align; bcopy(abc, b, len);
 701             for (off = 1; off <= len; off++) {
 702               bcopy(b, b+off, len); bcopy(b+off, b, len);
 703                 if (bcmp(b, abc, len)) return(1);
 704             }
 705           }
 706         }
 707         return(0);
 708       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 709   if test "$glib_cv_working_bcopy" = "yes"; then
 710     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
 711   fi
 712 fi
 713
 714 # Check for sys_errlist
 715 AC_MSG_CHECKING(for sys_errlist)
 716 AC_TRY_LINK(, [
 717 extern char *sys_errlist[];
 718 extern int sys_nerr;
 719 sys_errlist[sys_nerr-1][0] = 0;
 720 ], glib_ok=yes, glib_ok=no)
 721 AC_MSG_RESULT($glib_ok)
 722 if test "$glib_ok" = "no"; then
 723     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
 724 fi
 725
 726 # Check for sys_siglist
 727 AC_MSG_CHECKING(for sys_siglist)
 728 AC_TRY_LINK(, [
 729 extern char *sys_siglist[];
 730 exit (sys_siglist[0]);
 731 ], glib_ok=yes, glib_ok=no)
 732 AC_MSG_RESULT($glib_ok)
 733 if test "$glib_ok" = "no"; then
 734     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
 735 fi
 736
 737 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 738 AC_MSG_CHECKING(for sys_siglist declaration)
 739 AC_TRY_COMPILE([#include <signal.h>], [
 740 strlen (sys_siglist[0]);
 741 ], glib_ok=yes, glib_ok=no)
 742 AC_MSG_RESULT($glib_ok)
 743 if test "$glib_ok" = "no"; then
 744     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
 745 fi
 746
 747 # Check if <sys/select.h> needs to be included for fd_set
 748 AC_MSG_CHECKING([for fd_set])
 749 AC_TRY_COMPILE([#include <sys/types.h>],
 750         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 751 if test "$gtk_ok" = "yes"; then
 752     AC_MSG_RESULT([yes, found in sys/types.h])
 753 else
 754     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
 755     if test "$gtk_ok" = "yes"; then
 756         # *** FIXME: give it a different name
 757         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
 758         AC_MSG_RESULT([yes, found in sys/select.h])
 759     else
 760         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
 761         AC_MSG_RESULT(no)
 762     fi
 763 fi
 764
 765 dnl *** check for sane realloc() ***
 766 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
 767         AC_TRY_RUN([
 768         #include <stdlib.h>
 769         int main() {
 770           return realloc (0, sizeof (int)) == 0;
 771         }],
 772         [glib_cv_sane_realloc=yes],
 773         [glib_cv_sane_realloc=no],
 774         [])
 775 ])
 776 if test x$glib_cv_sane_realloc = xyes; then
 777   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
 778 fi
 779
 780 dnl Check for nl_langinfo and CODESET
 781
 782 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 783 AC_TRY_COMPILE([#include <langinfo.h>],
 784         [char *codeset = nl_langinfo (CODESET);],
 785    AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
 786    have_codeset=yes,
 787    have_codeset=no)
 788 AC_MSG_RESULT($have_codeset)
 789
 790
 791 dnl ****************************************
 792 dnl *** strlcpy/strlcat                  ***
 793 dnl ****************************************
 794 # Check for strlcpy
 795 AC_MSG_CHECKING(for strlcpy/strlcat)
 796 AC_TRY_LINK([#include <stdlib.h>
 797 #include <string.h>], [
 798 char *p = malloc(10);
 799 (void) strlcpy(p, "hi", 10);
 800 (void) strlcat(p, "bye", 10);
 801 ], glib_ok=yes, glib_ok=no)
 802 AC_MSG_RESULT($glib_ok)
 803 if test "$glib_ok" = "yes"; then
 804     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
 805 fi
 806
 807
 808 dnl **********************
 809 dnl *** va_copy checks ***
 810 dnl **********************
 811 dnl we currently check for all three va_copy possibilities, so we get
 812 dnl all results in config.log for bug reports.
 813 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
 814         AC_TRY_RUN([
 815         #include <stdarg.h>
 816         void f (int i, ...) {
 817         va_list args1, args2;
 818         va_start (args1, i);
 819         va_copy (args2, args1);
 820         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 821           exit (1);
 822         va_end (args1); va_end (args2);
 823         }
 824         int main() {
 825           f (0, 42);
 826           return 0;
 827         }],
 828         [glib_cv_va_copy=yes],
 829         [glib_cv_va_copy=no],
 830         [])
 831 ])
 832 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
 833         AC_TRY_RUN([
 834         #include <stdarg.h>
 835         void f (int i, ...) {
 836         va_list args1, args2;
 837         va_start (args1, i);
 838         __va_copy (args2, args1);
 839         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 840           exit (1);
 841         va_end (args1); va_end (args2);
 842         }
 843         int main() {
 844           f (0, 42);
 845           return 0;
 846         }],
 847         [glib_cv___va_copy=yes],
 848         [glib_cv___va_copy=no],
 849         [])
 850 ])
 851
 852 if test "x$glib_cv_va_copy" = "xyes"; then
 853   g_va_copy_func=va_copy
 854 else if test "x$glib_cv___va_copy" = "xyes"; then
 855   g_va_copy_func=__va_copy
 856 fi
 857 fi
 858
 859 if test -n "$g_va_copy_func"; then
 860   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
 861 fi
 862
 863 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
 864         AC_TRY_RUN([
 865         #include <stdarg.h>
 866         void f (int i, ...) {
 867         va_list args1, args2;
 868         va_start (args1, i);
 869         args2 = args1;
 870         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 871           exit (1);
 872         va_end (args1); va_end (args2);
 873         }
 874         int main() {
 875           f (0, 42);
 876           return 0;
 877         }],
 878         [glib_cv_va_val_copy=yes],
 879         [glib_cv_va_val_copy=no],
 880         [])
 881 ])
 882
 883 if test "x$glib_cv_va_val_copy" = "xno"; then
 884   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
 885 fi
 886
 887 dnl ***********************
 888 dnl *** g_module checks ***
 889 dnl ***********************
 890 G_MODULE_LIBS=
 891 G_MODULE_LIBS_EXTRA=
 892 G_MODULE_PLUGIN_LIBS=
 893 G_MODULE_LDFLAGS=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
 894 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 895 G_MODULE_NEED_USCORE=0
 896 G_MODULE_BROKEN_RTLD_GLOBAL=0
 897 G_MODULE_HAVE_DLERROR=0
 898 dnl *** force native WIN32 shared lib loader
 899 if test -z "$G_MODULE_IMPL"; then
 900   case "$host" in
 901   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
 902   esac
 903 fi
 904 dnl *** dlopen() and dlsym() in system libraries
 905 if test -z "$G_MODULE_IMPL"; then
 906         AC_CHECK_FUNC(dlopen,
 907                       [AC_CHECK_FUNC(dlsym,
 908                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 909                       [])
 910 fi
 911 dnl *** load_image (BeOS)
 912 if test -z "$G_MODULE_IMPL" && test "x$glib_native_beos" = "xyes"; then
 913   AC_CHECK_LIB(root, load_image,
 914       [G_MODULE_LIBS="-lbe -lroot -lglib"
 915       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 916       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 917       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
 918       [])
 919 fi
 920 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
 921 if test -z "$G_MODULE_IMPL"; then
 922         AC_CHECK_FUNC(NSLinkModule,
 923                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
 924                        G_MODULE_NEED_USCORE=1],
 925                       [])
 926 fi
 927 dnl *** dlopen() and dlsym() in libdl
 928 if test -z "$G_MODULE_IMPL"; then
 929         AC_CHECK_LIB(dl, dlopen,
 930                      [AC_CHECK_LIB(dl, dlsym,
 931                                    [G_MODULE_LIBS=-ldl
 932                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 933                      [])
 934 fi
 935 dnl *** shl_load() in libdld (HP-UX)
 936 if test -z "$G_MODULE_IMPL"; then
 937         AC_CHECK_LIB(dld, shl_load,
 938                 [G_MODULE_LIBS=-ldld
 939                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
 940                 [])
 941 fi
 942 dnl *** additional checks for G_MODULE_IMPL_DL
 943 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 944         LIBS_orig="$LIBS"
 945         LDFLAGS_orig="$LDFLAGS"
 946         LIBS="$LIBS $G_MODULE_LIBS"
 947         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 948 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
 949         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
 950                 glib_cv_rtldglobal_broken,[
 951                 AC_TRY_RUN([
 952                 #include <dlfcn.h>
 953                 #ifndef RTLD_GLOBAL
 954                 #define RTLD_GLOBAL 0
 955                 #endif
 956                 #ifndef RTLD_LAZY
 957                 #define RTLD_LAZY 0
 958                 #endif
 959                 int pthread_create;
 960                 int main () {
 961                 void *handle, *global, *local;
 962                 global = &pthread_create;
 963                 handle = dlopen ("libpthread.so", RTLD_GLOBAL | RTLD_LAZY);
 964                 if (!handle) return 0;
 965                 local = dlsym (handle, "pthread_create");
 966                 return global == local;
 967                 }],
 968                         [glib_cv_rtldglobal_broken=no],
 969                         [glib_cv_rtldglobal_broken=yes],
 970                         [])
 971                 rm -f plugin.c plugin.o plugin.lo
 972         ])
 973         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
 974                 G_MODULE_BROKEN_RTLD_GLOBAL=1
 975         else
 976                 G_MODULE_BROKEN_RTLD_GLOBAL=0
 977         fi
 978 dnl *** check whether we need preceeding underscores
 979         AC_CACHE_CHECK([for preceeding underscore in symbols],
 980                 glib_cv_uscore,[
 981                 AC_TRY_RUN([
 982                 #include <dlfcn.h>
 983                 int glib_underscore_test (void) { return 42; }
 984                 int main() {
 985                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 986                   handle = dlopen ((void*)0, 0);
 987                   if (handle) {
 988                     f1 = dlsym (handle, "glib_underscore_test");
 989                     f2 = dlsym (handle, "_glib_underscore_test");
 990                   } return (!f2 || f1);
 991                 }],
 992                         [glib_cv_uscore=yes],
 993                         [glib_cv_uscore=no],
 994                         [])
 995                 rm -f plugin.c plugin.$ac_objext plugin.lo
 996         ])
 997         if test "x$glib_cv_uscore" = "xyes"; then
 998                 G_MODULE_NEED_USCORE=1
 999         else
1000                 G_MODULE_NEED_USCORE=0
1001         fi
1002
1003         LDFLAGS="$LDFLAGS_orig"
1004 dnl *** check for having dlerror()
1005         AC_CHECK_FUNC(dlerror,
1006                 [G_MODULE_HAVE_DLERROR=1],
1007                 [G_MODULE_HAVE_DLERROR=0])
1008         LIBS="$LIBS_orig"
1009 fi
1010 dnl *** done, have we got an implementation?
1011 if test -z "$G_MODULE_IMPL"; then
1012         G_MODULE_IMPL=0
1013         G_MODULE_SUPPORTED=false
1014 else
1015         G_MODULE_SUPPORTED=true
1016 fi
1017
1018 AC_MSG_CHECKING(for the suffix of shared libraries)
1019 case "$host_os" in
1020   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
1021     glib_gmodule_suffix='sl'
1022     ;;
1023   cygwin* | mingw*)
1024     glib_gmodule_suffix='dll'
1025     ;;
1026   *)
1027     glib_gmodule_suffix='so'
1028     ;;
1029 esac
1030 AC_MSG_RESULT(.$glib_gmodule_suffix)
1031
1032 AC_SUBST(G_MODULE_SUPPORTED)
1033 AC_SUBST(G_MODULE_IMPL)
1034 AC_SUBST(G_MODULE_LIBS)
1035 AC_SUBST(G_MODULE_LIBS_EXTRA)
1036 AC_SUBST(G_MODULE_PLUGIN_LIBS)
1037 AC_SUBST(G_MODULE_LDFLAGS)
1038 AC_SUBST(G_MODULE_HAVE_DLERROR)
1039 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
1040 AC_SUBST(G_MODULE_NEED_USCORE)
1041 AC_SUBST(GLIB_DEBUG_FLAGS)
1042
1043 dnl **********************
1044 dnl *** g_spawn checks ***
1045 dnl **********************
1046
1047 AC_MSG_CHECKING(for gspawn implementation)
1048 case "$host" in
1049   *-*-mingw*)
1050     GSPAWN=gspawn-win32.lo
1051     ;;
1052   *)
1053     GSPAWN=gspawn.lo
1054     ;;
1055 esac
1056 AC_MSG_RESULT($GSPAWN)
1057 AC_SUBST(GSPAWN)
1058
1059 dnl *************************
1060 dnl *** GIOChannel checks ***
1061 dnl *************************
1062
1063 AC_MSG_CHECKING(for GIOChannel implementation)
1064 case "$host" in
1065   *-*-mingw*)
1066     GIO=giowin32.lo
1067     ;;
1068   *)
1069     GIO=giounix.lo
1070     ;;
1071 esac
1072 AC_MSG_RESULT($GIO)
1073 AC_SUBST(GIO)
1074
1075 dnl ****************************************
1076 dnl *** platform dependent source checks ***
1077 dnl ****************************************
1078
1079 AC_MSG_CHECKING(for platform-dependent source)
1080 case "$host" in
1081   *-*-cygwin*|*-*-mingw*)
1082     PLATFORMDEP=gwin32.lo
1083     ;;
1084   *)
1085     PLATFORMDEP=
1086     ;;
1087 esac
1088 AC_MSG_RESULT($PLATFORMDEP)
1089 AC_SUBST(PLATFORMDEP)
1090
1091 AC_MSG_CHECKING([whether to compile timeloop])
1092 case "$host" in
1093   *-*-cygwin*|*-*-mingw*)
1094     enable_timeloop=no
1095     ;;
1096   *)
1097     enable_timeloop=yes
1098     ;;
1099 esac
1100 AC_MSG_RESULT($enable_timeloop)
1101 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
1102
1103 AC_MSG_CHECKING([if building for some Win32 platform])
1104 case "$host" in
1105   *-*-mingw*|*-*-cygwin*)
1106     platform_win32=yes
1107     ;;
1108   *)
1109     platform_win32=no
1110     ;;
1111 esac
1112 AC_MSG_RESULT($platform_win32)
1113 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
1114
1115 dnl ***********************
1116 dnl *** g_thread checks ***
1117 dnl ***********************
1118
1119 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris/win32] specify a thread implementation to use],
1120         if test "x$with_threads" = x; then
1121                 want_threads=yes
1122         else
1123                 want_threads=$with_threads
1124         fi,
1125         want_threads=yes)
1126 if test "x$enable_threads" = "xno"; then
1127         want_threads=no
1128 fi
1129
1130 dnl error and warning message
1131 dnl *************************
1132
1133 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
1134                 computer. GLib will not have a default thread implementation."
1135
1136 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
1137                 platform (normally it's "_REENTRANT"). I'll not use any flag on
1138                 compilation now, but then your programs might not work.
1139                 Please provide information on how it is done on your system."
1140
1141 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
1142                 "
1143
1144 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
1145                 provide information on your thread implementation.
1146                 You can also run 'configure --disable-threads'
1147                 to compile without thread support."
1148
1149 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
1150                 functions will not be MT-safe during their first call because
1151                 there is no working 'getpwuid_r' on your system."
1152
1153 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
1154                 because there is no 'localtime_r' on your system."
1155
1156 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
1157                 crude surrogate will be used. If you happen to know a
1158                 yield function for your system, please inform the GLib
1159                 developers."
1160
1161 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
1162                 threads on your system. Thus threads can only have the default
1163                 priority. If you happen to know these main/max
1164                 priorities, please inform the GLib developers."
1165
1166
1167 dnl determination of thread implementation
1168 dnl ***************************************
1169
1170 # have_threads=no   means no thread support
1171 # have_threads=none means no default thread implementation
1172
1173 have_threads=no
1174 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
1175         case $host in
1176                 *-*-solaris*)
1177                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
1178                 ;;
1179         esac
1180 fi
1181 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
1182                                 || test "x$want_threads" = xdce; then
1183         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
1184         # -U_OSF_SOURCE is for Digital UNIX 4.0d
1185         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
1186         glib_save_CPPFLAGS="$CPPFLAGS"
1187         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1188         if test "x$have_threads" = xno; then
1189                 AC_TRY_COMPILE([#include <pthread.h>],
1190                         [pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
1191                         have_threads=posix)
1192         fi
1193         if test "x$have_threads" = xno; then
1194                 AC_TRY_COMPILE([#include <pthread.h>],
1195                         [pthread_mutex_t m;
1196                          pthread_mutex_init (&m, pthread_mutexattr_default);],
1197                         have_threads=dce)
1198         fi
1199         CPPFLAGS="$glib_save_CPPFLAGS"
1200 fi
1201 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1202         case $host in
1203                 *-*-mingw*)
1204                 have_threads=win32
1205                 ;;
1206         esac
1207 fi
1208 if test "x$want_threads" = xnone; then
1209         have_threads=none
1210 fi
1211
1212 AC_MSG_CHECKING(for thread implementation)
1213
1214 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1215         AC_MSG_RESULT(none available)
1216         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1217 else
1218         AC_MSG_RESULT($have_threads)
1219 fi
1220
1221
1222 dnl determination of G_THREAD_CFLAGS
1223 dnl ********************************
1224
1225 G_THREAD_LIBS=
1226 G_THREAD_LIBS_EXTRA=
1227 G_THREAD_CFLAGS=
1228
1229 if test x"$have_threads" != xno; then
1230
1231     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
1232
1233     case $host in
1234         *-aix*)
1235                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1236                 if test x"$GCC" = xyes; then
1237                         # GCC 3.0 and above needs -pthread
1238                         # GCC 2.x and below needs -mthreads
1239                         AC_TRY_COMPILE(,[#if __GNUC__ <= 2
1240                                         bail out here
1241                                         #endif],
1242                                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread",
1243                                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads")
1244                 fi
1245                 ;;
1246         *-freebsd2.2*)
1247                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1248
1249                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
1250                 # -mthreads flag.
1251                 ;;
1252         *-sysv5uw7*)  # UnixWare 7
1253                 if test "$GCC" != "yes"; then
1254                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
1255                 else
1256                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
1257                 fi
1258                 ;;
1259         *-dg-dgux*)  # DG/UX
1260                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
1261     esac
1262
1263     # if we are not finding the localtime_r function, then we probably are
1264     # not using the proper multithread flag
1265
1266     glib_save_CPPFLAGS="$CPPFLAGS"
1267     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1268
1269     # First we test, whether localtime_r is declared in time.h
1270     # directly. Then we test whether a macro localtime_r exists, in
1271     # which case localtime_r in the test program is replaced and thus
1272     # if we still find localtime_r in the output, it is not defined as
1273     # a macro.
1274
1275     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1276       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1277                                                            localtime_r(a,b)],
1278                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1279
1280     CPPFLAGS="$glib_save_CPPFLAGS"
1281
1282     AC_MSG_CHECKING(thread related cflags)
1283     AC_MSG_RESULT($G_THREAD_CFLAGS)
1284     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1285 fi
1286
1287 dnl determination of G_THREAD_LIBS
1288 dnl ******************************
1289
1290 mutex_has_default=no
1291 case $have_threads in
1292         posix|dce)
1293            glib_save_CPPFLAGS="$CPPFLAGS"
1294            CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1295            G_THREAD_LIBS=error
1296            glib_save_LIBS="$LIBS"
1297            case $host in
1298              *-sysv5uw7*) # UnixWare 7
1299                 if test "$GCC" != "yes"; then
1300                         G_THREAD_LIBS="-Kthread"
1301                 else
1302                         G_THREAD_LIBS="-pthread"
1303                 fi
1304                 ;;
1305              *-*-openbsd* | *-*-freebsd*)
1306                 # FreeBSD and OpenBSD want us to use the -pthread flag
1307                 # instead of linking to -lc_r and libtool enforces that.
1308                 G_THREAD_LIBS="-pthread"
1309                 ;;
1310              *)
1311                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1312                         if test x"$thread_lib" = x; then
1313                                 add_thread_lib=""
1314                                 IN=""
1315                         else
1316                                 add_thread_lib="-l$thread_lib"
1317                                 IN=" in -l$thread_lib"
1318                         fi
1319                         if test x"$have_threads" = xposix; then
1320                                 defattr=0
1321                         else
1322                                 defattr=pthread_attr_default
1323                         fi
1324
1325                         LIBS="$glib_save_LIBS $add_thread_lib"
1326
1327                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1328                         AC_TRY_RUN([#include <pthread.h>
1329                                 int check_me = 0;
1330                                 void* func(void* data) {check_me = 42;}
1331                                 main()
1332                                 { pthread_t t;
1333                                   void *ret;
1334                                   pthread_create (&t, $defattr, func, 0);
1335                                   pthread_join (t, &ret);
1336                                   exit (check_me != 42);
1337                                 }],
1338                                 [AC_MSG_RESULT(yes)
1339                                 G_THREAD_LIBS="$add_thread_lib"
1340                                 break],
1341                                 [AC_MSG_RESULT(no)])
1342                 done
1343                 ;;
1344            esac
1345            if test "x$G_THREAD_LIBS" = xerror; then
1346              AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1347            fi
1348            for thread_lib in "" rt rte; do
1349              if test x"$thread_lib" = x; then
1350                add_thread_lib=""
1351                IN=""
1352              else
1353                add_thread_lib="-l$thread_lib"
1354                IN=" in -l$thread_lib"
1355              fi
1356              LIBS="$glib_save_LIBS $add_thread_lib"
1357
1358              AC_MSG_CHECKING(for sched_get_priority_min$IN)
1359              AC_TRY_RUN([#include <sched.h>
1360                          #include <errno.h>
1361                          int main() {
1362                          errno = 0;
1363                          return sched_get_priority_min(SCHED_OTHER)==-1
1364                                 && errno != 0;}],
1365                         [AC_MSG_RESULT(yes)
1366                          G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1367                          posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1368                          posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1369                          break],
1370                         [AC_MSG_RESULT(no)])
1371            done
1372            LIBS="$glib_save_LIBS"
1373            mutex_has_default=yes
1374            mutex_default_type='pthread_mutex_t'
1375            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1376            mutex_header_file='pthread.h'
1377            if test "x$have_threads" = "xposix"; then
1378              g_threads_impl="POSIX"
1379            else
1380              g_threads_impl="DCE"
1381              have_threads="posix"
1382            fi
1383            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1384            CPPFLAGS="$glib_save_CPPFLAGS"
1385            ;;
1386         solaris)
1387            G_THREAD_LIBS=error
1388            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
1389            mutex_has_default=yes
1390            mutex_default_type='mutex_t'
1391            mutex_default_init="DEFAULTMUTEX"
1392            mutex_header_file='thread.h'
1393            g_threads_impl="SOLARIS"
1394            ;;
1395         win32)
1396            g_threads_impl="WIN32"
1397            G_THREAD_LIBS=""
1398            ;;
1399         none|no)
1400            g_threads_impl="NONE"
1401            ;;
1402         *)
1403            g_threads_impl="NONE"
1404            G_THREAD_LIBS=error
1405            ;;
1406 esac
1407
1408 if test "x$G_THREAD_LIBS" = xerror; then
1409         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1410 fi
1411
1412 case $host in
1413   *-*-beos*)
1414     G_THREAD_LIBS="-lbe -lroot -lglib "
1415     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1416     ;;
1417   *)
1418     ;;
1419 esac
1420
1421 AC_MSG_CHECKING(thread related libraries)
1422 AC_MSG_RESULT($G_THREAD_LIBS)
1423
1424 dnl check for mt safe function variants and some posix functions
1425 dnl ************************************************************
1426
1427 if test x"$have_threads" != xno; then
1428         glib_save_LIBS="$LIBS"
1429         # we are not doing the following for now, as this might require glib
1430         # to always be linked with the thread libs on some platforms.
1431         # LIBS="$LIBS $G_THREAD_LIBS"
1432         AC_CHECK_FUNCS(localtime_r)
1433         if test "$ac_cv_header_pwd_h" = "yes"; then
1434                 AC_CACHE_CHECK([for posix getpwuid_r],
1435                         ac_cv_func_posix_getpwuid_r,
1436                         [AC_TRY_RUN([#include <errno.h>
1437                                 #include <pwd.h>
1438                                 int main () { char buffer[10000];
1439                                 struct passwd pwd, *pwptr = &pwd;
1440                                 int error;
1441                                 errno = 0;
1442                                 error = getpwuid_r (0, &pwd, buffer,
1443                                         sizeof (buffer), &pwptr);
1444                                 return (error < 0 && errno == ENOSYS)
1445                                         || error == ENOSYS; }],
1446                                 [ac_cv_func_posix_getpwuid_r=yes],
1447                                 [ac_cv_func_posix_getpwuid_r=no])])
1448                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1449                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1450                                 [Have POSIX function getpwuid_r])
1451                 else
1452                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1453                                 ac_cv_func_nonposix_getpwuid_r,
1454                                 [AC_TRY_LINK([#include <pwd.h>],
1455                                         [char buffer[10000];
1456                                         struct passwd pwd;
1457                                         getpwuid_r (0, &pwd, buffer,
1458                                                         sizeof (buffer));],
1459                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1460                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1461                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1462                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1463                                         [Have non-POSIX function getpwuid_r])
1464                         fi
1465                 fi
1466         fi
1467         LIBS="$LIBS $G_THREAD_LIBS"
1468         if test x"$have_threads" = xposix; then
1469                 glib_save_CPPFLAGS="$CPPFLAGS"
1470                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1471                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1472                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1473                 # This is not AC_CHECK_FUNC to also work with function
1474                 # name mangling in header files.
1475                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1476                 AC_TRY_LINK([#include <pthread.h>],
1477                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1478                         [AC_MSG_RESULT(yes)
1479                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1480                                   [Have function pthread_attr_setstacksize])],
1481                         [AC_MSG_RESULT(no)])
1482                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1483                 if test x"$posix_priority_min" = xnone; then
1484                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1485                                 PX_PRIO_MIN],,[
1486                                 posix_priority_min=PX_PRIO_MIN
1487                                 posix_priority_max=PX_PRIO_MAX])
1488                 fi
1489                 if test x"$posix_priority_min" = xnone; then
1490                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1491                                 PRI_OTHER_MIN],,[
1492                                 posix_priority_min=PRI_OTHER_MIN
1493                                 posix_priority_max=PRI_OTHER_MAX])
1494                 fi
1495                 if test x"$posix_priority_min" = x; then
1496                         AC_MSG_RESULT(none found)
1497                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1498                         posix_priority_min=-1
1499                         posix_priority_max=-1
1500                 else
1501                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1502                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1503                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1504                 fi
1505                 posix_yield_func=none
1506                 AC_MSG_CHECKING(for posix yield function)
1507                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1508                                                         thr_yield; do
1509                         AC_TRY_LINK([#include <pthread.h>],
1510                                 [$yield_func()],
1511                                 [posix_yield_func="$yield_func"
1512                                 break])
1513                 done
1514                 if test x"$posix_yield_func" = xnone; then
1515                         AC_MSG_RESULT(none found)
1516                         AC_MSG_WARN($POSIX_NO_YIELD)
1517                         posix_yield_func="g_usleep(1000)"
1518                 else
1519                         AC_MSG_RESULT($posix_yield_func)
1520                         posix_yield_func="$posix_yield_func()"
1521                 fi
1522                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1523                 CPPFLAGS="$glib_save_CPPFLAGS"
1524
1525                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1526                 AC_TRY_RUN([#include <pthread.h>
1527                         #include <sys/types.h>
1528                         #include <unistd.h>
1529                         pid_t other_pid = 0;
1530
1531                         void* func(void* data) {other_pid = getpid();}
1532                         main()
1533                         { pthread_t t;
1534                           void *ret;
1535                           pthread_create (&t, $defattr, func, NULL);
1536                           pthread_join (t, &ret);
1537                           exit (getpid()==other_pid ||
1538                                 $posix_priority_min != $posix_priority_max);
1539                         }],
1540                         [AC_MSG_RESULT(yes)
1541                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1542                         ],
1543                         [AC_MSG_RESULT(no)])
1544         elif test x"$have_threads" = xwin32; then
1545                 # It's a pointer to a private struct
1546                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1547         elif test x"$have_threads" = xsolaris; then
1548                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1549         fi
1550
1551         LIBS="$glib_save_LIBS"
1552
1553         # now spit out all the warnings.
1554         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1555            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1556                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1557         fi
1558         if test "$ac_cv_func_localtime_r" != "yes"; then
1559                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1560         fi
1561 fi
1562
1563 if test x"$glib_cv_sizeof_system_thread" = x; then
1564    # use a pointer as a fallback.
1565    GLIB_SIZEOF(,void *, system_thread)
1566 fi
1567
1568 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1569                    [Source file containing theread implementation])
1570 AC_SUBST(G_THREAD_CFLAGS)
1571 AC_SUBST(G_THREAD_LIBS)
1572 AC_SUBST(G_THREAD_LIBS_EXTRA)
1573
1574 dnl **********************************************
1575 dnl *** GDefaultMutex setup and initialization ***
1576 dnl **********************************************
1577 dnl
1578 dnl if mutex_has_default = yes, we also got
1579 dnl mutex_default_type, mutex_default_init and mutex_header_file
1580 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1581         glib_save_CPPFLAGS="$CPPFLAGS"
1582         glib_save_LIBS="$LIBS"
1583         LIBS="$LIBS $G_THREAD_LIBS"
1584         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1585         GLIB_SIZEOF([#include <$mutex_header_file>],
1586                     $mutex_default_type,
1587                     gmutex,
1588                     )
1589         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1590                            $mutex_default_type,
1591                            gmutex,
1592                            $glib_cv_sizeof_gmutex,
1593                            $mutex_default_init)
1594         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1595                 mutex_has_default=no
1596         fi
1597         CPPFLAGS="$glib_save_CPPFLAGS"
1598         LIBS="$glib_save_LIBS"
1599         ,
1600 )
1601
1602
1603 dnl ****************************************
1604 dnl *** GLib POLL* compatibility defines ***
1605 dnl ****************************************
1606 GLIB_SYSDEFS(
1607 [#include <sys/types.h>
1608 #include <sys/poll.h>],
1609         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1610         glibconfig-sysdefs.h,
1611         =)
1612
1613 dnl **********************
1614 dnl *** Win32 API libs ***
1615 dnl **********************
1616
1617 case $host in
1618   *-*-cygwin*)
1619         G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32"
1620     ;;
1621   *-*-mingw*)
1622         G_LIBS_EXTRA="-lwsock32"
1623     ;;
1624   *)
1625         G_LIBS_EXTRA=""
1626     ;;
1627 esac
1628 AC_SUBST(G_LIBS_EXTRA)
1629
1630 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1631 dnl since we need it for g_iconv()
1632
1633 AC_MSG_CHECKING([for EILSEQ])
1634 AC_TRY_COMPILE([
1635 #include <errno.h>
1636 ],
1637 [
1638 int error = EILSEQ;
1639 ], have_eilseq=yes, have_eilseq=no);
1640 AC_MSG_RESULT($have_eilseq)
1641
1642 dnl ******************************************************************
1643 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1644 dnl ******************************************************************
1645
1646 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1647
1648 if test $cross_compiling = yes; then
1649   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1650   if test x$GLIB_GENMARSHAL = xno; then
1651     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1652   fi
1653 fi
1654
1655 dnl **************************
1656 dnl *** Checks for gtk-doc ***
1657 dnl **************************
1658
1659 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1660
1661 if test "x$with_html_dir" = "x" ; then
1662   HTML_DIR='${datadir}/gtk-doc/html'
1663 else
1664   HTML_DIR=$with_html_dir
1665 fi
1666
1667 AC_SUBST(HTML_DIR)
1668
1669 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1670
1671 gtk_doc_min_version=0.6
1672 if $GTKDOC ; then
1673     gtk_doc_version=`gtkdoc-mkdb --version`
1674     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1675     if perl <<EOF ; then
1676       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1677             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1678 EOF
1679       AC_MSG_RESULT(yes)
1680    else
1681       AC_MSG_RESULT(no)
1682       GTKDOC=false
1683    fi
1684 fi
1685
1686 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1687 AC_SUBST(HAVE_GTK_DOC)
1688
1689 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1690 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1691
1692 dnl Let people disable the gtk-doc stuff.
1693 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no)
1694
1695 if test x$enable_gtk_doc = xyes ; then
1696   if test x$GTKDOC = xtrue ; then
1697     enable_gtk_doc=yes
1698   else
1699     enable_gtk_doc=no
1700   fi
1701 fi
1702
1703 dnl NOTE: We need to use a separate automake conditional for this
1704 dnl       to make this work with the tarballs.
1705 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1706
1707 dnl ******************************
1708 dnl *** output the whole stuff ***
1709 dnl ******************************
1710
1711 AC_OUTPUT_COMMANDS([
1712
1713 ## Generate `glibconfig.h' in two cases
1714 ## 1. `config.status' is run either explicitly, or via configure.
1715 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1716 ##     config.h
1717 ## 2. CONFIG_OTHER is set explicitly
1718 ##
1719 ## Case 1 is difficult.  We know that `automake' sets one of
1720 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1721 ## only when AM_CONFIG_HEADER is set, however.
1722
1723 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1724   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1725   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1726 fi
1727 case "$CONFIG_OTHER" in
1728 *glibconfig.h*)
1729         echo creating glibconfig.h
1730         outfile=glibconfig.h-tmp
1731         cat > $outfile <<\_______EOF
1732 /* glibconfig.h
1733  *
1734  * This is a generated file.  Please modify 'configure.in'
1735  */
1736
1737 #ifndef __G_LIBCONFIG_H__
1738 #define __G_LIBCONFIG_H__
1739
1740 #include <glib/gmacros.h>
1741
1742 _______EOF
1743
1744         if test x$glib_limits_h = xyes; then
1745           echo '#include <limits.h>' >> $outfile
1746         fi
1747         if test x$glib_float_h = xyes; then
1748           echo '#include <float.h>' >> $outfile
1749         fi
1750         if test x$glib_values_h = xyes; then
1751           echo '#include <values.h>' >> $outfile
1752         fi
1753         if test "$glib_header_alloca_h" = "yes"; then
1754           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1755         fi
1756         if test x$glib_sys_poll_h = xyes; then
1757           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1758         fi
1759
1760         cat >> $outfile <<_______EOF
1761
1762 G_BEGIN_DECLS
1763
1764 #define G_MINFLOAT      $glib_mf
1765 #define G_MAXFLOAT      $glib_Mf
1766 #define G_MINDOUBLE     $glib_md
1767 #define G_MAXDOUBLE     $glib_Md
1768 #define G_MINSHORT      $glib_ms
1769 #define G_MAXSHORT      $glib_Ms
1770 #define G_MAXUSHORT     $glib_Mus
1771 #define G_MININT        $glib_mi
1772 #define G_MAXINT        $glib_Mi
1773 #define G_MAXUINT       $glib_Mui
1774 #define G_MINLONG       $glib_ml
1775 #define G_MAXLONG       $glib_Ml
1776 #define G_MAXULONG      $glib_Mul
1777
1778 #define G_MININT64      ((gint64)  0x8000000000000000)
1779 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1780 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1781
1782 _______EOF
1783
1784
1785         ### this should always be true in a modern C/C++ compiler
1786         cat >>$outfile <<_______EOF
1787 typedef signed char gint8;
1788 typedef unsigned char guint8;
1789 _______EOF
1790
1791
1792         if test -n "$gint16"; then
1793           cat >>$outfile <<_______EOF
1794 typedef signed $gint16 gint16;
1795 typedef unsigned $gint16 guint16;
1796 #define G_GINT16_FORMAT $gint16_format
1797 #define G_GUINT16_FORMAT $guint16_format
1798 _______EOF
1799         fi
1800
1801
1802         if test -n "$gint32"; then
1803           cat >>$outfile <<_______EOF
1804 typedef signed $gint32 gint32;
1805 typedef unsigned $gint32 guint32;
1806 #define G_GINT32_FORMAT $gint32_format
1807 #define G_GUINT32_FORMAT $guint32_format
1808 _______EOF
1809         fi
1810
1811         cat >>$outfile <<_______EOF
1812 #define G_HAVE_GINT64 1          /* deprecated, always true */
1813
1814 ${glib_extension}typedef signed $gint64 gint64;
1815 ${glib_extension}typedef unsigned $gint64 guint64;
1816
1817 #define G_GINT64_CONSTANT(val)  $gint64_constant
1818 _______EOF
1819
1820         if test x$gint64_format != x ; then
1821           cat >>$outfile <<_______EOF
1822 #define G_GINT64_FORMAT $gint64_format
1823 #define G_GUINT64_FORMAT $guint64_format
1824 _______EOF
1825         else
1826           cat >>$outfile <<_______EOF
1827 #undef G_GINT64_FORMAT
1828 #undef G_GUINT64_FORMAT
1829 _______EOF
1830         fi
1831
1832         cat >>$outfile <<_______EOF
1833
1834 #define GLIB_SIZEOF_VOID_P $glib_void_p
1835 #define GLIB_SIZEOF_LONG   $glib_long
1836 #define GLIB_SIZEOF_SIZE_T $glib_size_t
1837
1838 _______EOF
1839
1840 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
1841 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
1842
1843         if test -z "$glib_unknown_void_p"; then
1844           cat >>$outfile <<_______EOF
1845
1846 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1847 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1848
1849 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1850 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1851 _______EOF
1852         else
1853           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1854         fi
1855
1856
1857
1858         cat >>$outfile <<_______EOF
1859 $glib_atexit
1860 $glib_memmove
1861 $glib_defines
1862 $glib_os
1863
1864 $glib_vacopy
1865
1866 #ifdef  __cplusplus
1867 #define G_HAVE_INLINE   1
1868 #else   /* !__cplusplus */
1869 $glib_inline
1870 #endif  /* !__cplusplus */
1871
1872 _______EOF
1873
1874         if test x$g_have_iso_c_varargs = xyes ; then
1875                 cat >>$outfile <<_______EOF
1876 #ifndef __cplusplus
1877 # define G_HAVE_ISO_VARARGS 1
1878 #endif
1879 _______EOF
1880         fi
1881         if test x$g_have_iso_cxx_varargs = xyes ; then
1882                 cat >>$outfile <<_______EOF
1883 #ifdef __cplusplus
1884 # define G_HAVE_ISO_VARARGS 1
1885 #endif
1886 _______EOF
1887         fi
1888         if test x$g_have_gnuc_varargs = xyes ; then
1889                 cat >>$outfile <<_______EOF
1890
1891 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
1892  * is passed ISO vararg support is turned off, and there is no work
1893  * around to turn it on, so we unconditionally turn it off.
1894  */
1895 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
1896 #  undef G_HAVE_ISO_VARARGS
1897 #endif
1898
1899 #define G_HAVE_GNUC_VARARGS 1
1900 _______EOF
1901         fi
1902
1903         case x$g_stack_grows in
1904         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
1905         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
1906         esac
1907
1908
1909         echo >>$outfile
1910         if test x$g_have_eilseq = xno; then
1911                 cat >>$outfile <<_______EOF
1912 #ifndef EILSEQ
1913 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1914  * The correspondence between this and the corresponding definition
1915  * in libiconv is essential.
1916  */
1917 #  define EILSEQ ENOENT
1918 #endif
1919 _______EOF
1920
1921         fi
1922
1923         echo >>$outfile
1924         if test x$g_mutex_has_default = xyes; then
1925                 cat >>$outfile <<_______EOF
1926 $g_enable_threads_def G_THREADS_ENABLED
1927 #define G_THREADS_IMPL_$g_threads_impl_def
1928 typedef struct _GStaticMutex GStaticMutex;
1929 struct _GStaticMutex
1930 {
1931   struct _GMutex *runtime_mutex;
1932   union {
1933     char   pad[$g_mutex_sizeof];
1934     double dummy_double;
1935     void  *dummy_pointer;
1936     long   dummy_long;
1937   } static_mutex;
1938 };
1939 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1940 #define g_static_mutex_get_mutex(mutex) \
1941   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1942    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1943 _______EOF
1944         else
1945                 cat >>$outfile <<_______EOF
1946 $g_enable_threads_def G_THREADS_ENABLED
1947 #define G_THREADS_IMPL_$g_threads_impl_def
1948 typedef struct _GMutex* GStaticMutex;
1949 #define G_STATIC_MUTEX_INIT NULL
1950 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1951 _______EOF
1952         fi
1953
1954         cat >>$outfile <<_______EOF
1955 /* This represents a system thread as used by the implementation. An
1956  * alien implementaion, as loaded by g_thread_init can only count on
1957  * "sizeof (gpointer)" bytes to store their info. We however need more
1958  * for some of our native implementations. */
1959 typedef union _GSystemThread GSystemThread;
1960 union _GSystemThread
1961 {
1962   char   data[$g_system_thread_sizeof];
1963   double dummy_double;
1964   void  *dummy_pointer;
1965   long   dummy_long;
1966 };
1967 _______EOF
1968
1969         echo >>$outfile
1970         g_bit_sizes="16 32 64"
1971         for bits in $g_bit_sizes; do
1972           cat >>$outfile <<_______EOF
1973 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1974 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1975 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1976 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1977 _______EOF
1978         done
1979
1980         cat >>$outfile <<_______EOF
1981 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1982 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1983 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1984 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1985 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1986 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1987 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1988 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1989 #define G_BYTE_ORDER $g_byte_order
1990
1991 _______EOF
1992
1993         if test -r glibconfig-sysdefs.h; then
1994           cat glibconfig-sysdefs.h >>$outfile
1995         fi
1996
1997         cat >>$outfile <<_______EOF
1998
1999 #define G_MODULE_SUFFIX "$g_module_suffix"
2000
2001 G_END_DECLS
2002
2003 #endif /* GLIBCONFIG_H */
2004 _______EOF
2005
2006
2007         if cmp -s $outfile glibconfig.h; then
2008           echo glibconfig.h is unchanged
2009           rm -f $outfile
2010         else
2011           mv $outfile glibconfig.h
2012         fi ;;
2013 esac
2014 ],[
2015
2016 # Note that if two cases are the same, case goes with the first one.
2017 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2018 # on variable expansion in case labels.  Look at the generated config.status
2019 # for a hint.
2020
2021 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2022   glib_header_alloca_h="$ac_cv_working_alloca_h"
2023 else
2024   glib_header_alloca_h="$ac_cv_header_alloca_h"
2025 fi
2026
2027 case xyes in
2028 x$ac_cv_header_float_h)
2029   glib_float_h=yes
2030   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2031   glib_md=DBL_MIN glib_Md=DBL_MAX
2032   ;;
2033 x$ac_cv_header_values_h)
2034   glib_values_h=yes
2035   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2036   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2037   ;;
2038 esac
2039
2040 case xyes in
2041 x$ac_cv_header_limits_h)
2042   glib_limits_h=yes
2043   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2044   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2045   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2046   ;;
2047 x$ac_cv_header_values_h)
2048   glib_values_h=yes
2049   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2050   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2051   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2052   ;;
2053 esac
2054
2055 if test x$ac_cv_header_sys_poll_h = xyes ; then
2056   glib_sys_poll_h=yes
2057 fi
2058
2059 case 2 in
2060 $ac_cv_sizeof_short)
2061   gint16=short
2062   gint16_format='"hi"'
2063   guint16_format='"hu"'
2064   ;;
2065 $ac_cv_sizeof_int)
2066   gint16=int
2067   gint16_format='"i"'
2068   guint16_format='"u"'
2069   ;;
2070 esac
2071 case 4 in
2072 $ac_cv_sizeof_short)
2073   gint32=short
2074   gint32_format='"hi"'
2075   guint32_format='"hu"'
2076   ;;
2077 $ac_cv_sizeof_int)
2078   gint32=int
2079   gint32_format='"i"'
2080   guint32_format='"u"'
2081   ;;
2082 $ac_cv_sizeof_long)
2083   gint32=long
2084   gint32_format='"li"'
2085   guint32_format='"lu"'
2086   ;;
2087 esac
2088 case 8 in
2089 $ac_cv_sizeof_int)
2090   gint64=int
2091   gint64_format='"i"'
2092   guint64_format='"u"'
2093   glib_extension=
2094   gint64_constant='(val)'
2095   ;;
2096 $ac_cv_sizeof_long)
2097   gint64=long
2098   gint64_format='"li"'
2099   guint64_format='"lu"'
2100   glib_extension=
2101   gint64_constant='(val##L)'
2102   ;;
2103 $ac_cv_sizeof_long_long)
2104   gint64='long long'
2105   if test -n "$glib_cv_long_long_format"; then
2106     gint64_format='"'$glib_cv_long_long_format'i"'
2107     guint64_format='"'$glib_cv_long_long_format'u"'
2108   fi
2109   glib_extension='G_GNUC_EXTENSION '
2110   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2111   ;;
2112 $ac_cv_sizeof___int64)
2113   gint64='__int64'
2114   if test -n "$glib_cv_long_long_format"; then
2115     gint64_format='"'$glib_cv_long_long_format'i"'
2116     guint64_format='"'$glib_cv_long_long_format'u"'
2117   fi
2118   glib_extension=
2119   gint64_constant='(val##i64)'
2120   ;;
2121 esac
2122 glib_size_t=$glib_cv_sizeof_size_t
2123 glib_size_type_define=$glib_size_type
2124 glib_void_p=$ac_cv_sizeof_long
2125 glib_long=$ac_cv_sizeof_void_p
2126
2127 gintbits=`expr $ac_cv_sizeof_int \* 8`
2128 glongbits=`expr $ac_cv_sizeof_long \* 8`
2129
2130
2131 case $ac_cv_sizeof_void_p in
2132 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2133 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2134 *)                      glib_unknown_void_p=yes ;;
2135 esac
2136
2137
2138 case xyes in
2139 x$ac_cv_func_atexit)
2140   glib_atexit="
2141 #ifdef NeXT /* @#%@! NeXTStep */
2142 # define g_ATEXIT(proc) (!atexit (proc))
2143 #else
2144 # define g_ATEXIT(proc) (atexit (proc))
2145 #endif"
2146   ;;
2147 x$ac_cv_func_on_exit)
2148   glib_atexit="
2149 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2150   ;;
2151 esac
2152
2153 case xyes in
2154 x$ac_cv_func_memmove)
2155   glib_memmove='
2156 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2157   ;;
2158 x$glib_cv_working_bcopy)
2159   glib_memmove="
2160 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2161 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2162   ;;
2163 *)
2164   glib_memmove="
2165 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2166  * so we have to roll our own copy routine. */
2167 void g_memmove (void* dest, const void * src, unsigned long len);"
2168   ;;
2169 esac
2170
2171 glib_defines="
2172 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2173 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2174 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2175 "
2176
2177 case xyes in
2178 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2179 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2180 *)                      glib_vacopy=''
2181 esac
2182
2183 if test x$glib_cv_va_val_copy = xno; then
2184   glib_vacopy="\$glib_vacopy
2185 #define G_VA_COPY_AS_ARRAY 1"
2186 fi
2187
2188 if test x$glib_cv_hasinline = xyes; then
2189     glib_inline='#define G_HAVE_INLINE 1'
2190 fi
2191 if test x$glib_cv_has__inline = xyes; then
2192     glib_inline="\$glib_inline
2193 #define G_HAVE___INLINE 1"
2194 fi
2195 if test x$glib_cv_has__inline__ = xyes; then
2196     glib_inline="\$glib_inline
2197 #define G_HAVE___INLINE__ 1"
2198 fi
2199
2200 g_have_gnuc_varargs=$g_have_gnuc_varargs
2201 g_have_iso_c_varargs=$g_have_iso_c_varargs
2202 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2203
2204 case xyes in
2205 x$ac_cv_c_bigendian)
2206   g_byte_order=G_BIG_ENDIAN
2207   g_bs_native=BE
2208   g_bs_alien=LE
2209   ;;
2210 *)
2211   g_byte_order=G_LITTLE_ENDIAN
2212   g_bs_native=LE
2213   g_bs_alien=BE
2214   ;;
2215 esac
2216
2217 g_stack_grows=$glib_cv_stack_grows
2218
2219 g_have_eilseq=$have_eilseq
2220
2221 case x$have_threads in
2222 xno)    g_enable_threads_def="#undef";;
2223 *)      g_enable_threads_def="#define";;
2224 esac
2225
2226 g_threads_impl_def=$g_threads_impl
2227
2228 g_mutex_has_default="$mutex_has_default"
2229 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2230 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2231 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2232
2233 g_module_suffix="$glib_gmodule_suffix"
2234
2235 case $host in
2236   *-*-beos*)
2237     glib_os="#define G_OS_BEOS"
2238     ;;
2239   *-*-cygwin*)
2240     glib_os="#define G_OS_UNIX
2241 #define G_PLATFORM_WIN32
2242 #define G_WITH_CYGWIN"
2243     ;;
2244   *-*-mingw*)
2245     glib_os="#define G_OS_WIN32
2246 #define G_PLATFORM_WIN32"
2247     ;;
2248   *)
2249     glib_os="#define G_OS_UNIX"
2250     ;;
2251 esac
2252 ])
2253
2254 AC_OUTPUT([
2255 glib-2.0.pc
2256 glib-2.0-uninstalled.pc
2257 gmodule-2.0.pc
2258 gmodule-2.0-uninstalled.pc
2259 gthread-2.0.pc
2260 gthread-2.0-uninstalled.pc
2261 gobject-2.0.pc
2262 gobject-2.0-uninstalled.pc
2263 glib.spec
2264 glib-zip
2265 glib-gettextize
2266 Makefile
2267 build/Makefile
2268 build/win32/Makefile
2269 build/win32/dirent/Makefile
2270 glib/Makefile
2271 glib/libcharset/Makefile
2272 gmodule/gmoduleconf.h
2273 gmodule/Makefile
2274 gobject/Makefile
2275 gobject/glib-mkenums
2276 gthread/Makefile
2277 po/Makefile.in
2278 docs/Makefile
2279 docs/reference/Makefile
2280 docs/reference/glib/Makefile
2281 docs/reference/gobject/Makefile
2282 tests/Makefile
2283 m4macros/Makefile
2284 ])