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=`expr 100 '*' GLIB_MINOR_VERSION + $GLIB_MICRO_VERSION
  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_attr_t attr; pthread_attr_init(&attr);],
1191                         have_threads=posix)
1192         fi
1193         if test "x$have_threads" = xno; then
1194                 AC_TRY_COMPILE([#include <pthread.h>],
1195                         [pthread_attr_t attr; pthread_attr_create(&attr);],
1196                         have_threads=dce)
1197         fi
1198         CPPFLAGS="$glib_save_CPPFLAGS"
1199 fi
1200 if test "x$want_threads" = xyes || test "x$want_threads" = xwin32; then
1201         case $host in
1202                 *-*-mingw*)
1203                 have_threads=win32
1204                 ;;
1205         esac
1206 fi
1207 if test "x$want_threads" = xnone; then
1208         have_threads=none
1209 fi
1210
1211 AC_MSG_CHECKING(for thread implementation)
1212
1213 if test "x$have_threads" = xno && test "x$want_threads" != xno; then
1214         AC_MSG_RESULT(none available)
1215         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
1216 else
1217         AC_MSG_RESULT($have_threads)
1218 fi
1219
1220
1221 dnl determination of G_THREAD_CFLAGS
1222 dnl ********************************
1223
1224 G_THREAD_LIBS=
1225 G_THREAD_LIBS_EXTRA=
1226 G_THREAD_CFLAGS=
1227
1228 if test x"$have_threads" != xno; then
1229
1230     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
1231
1232     case $host in
1233         *-aix*)
1234                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1235                 if test x"$GCC" = xyes; then
1236                         # GCC 3.0 and above needs -pthread
1237                         # GCC 2.x and below needs -mthreads
1238                         AC_TRY_COMPILE(,[#if __GNUC__ <= 2
1239                                         bail out here
1240                                         #endif],
1241                                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread",
1242                                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads")
1243                 fi
1244                 ;;
1245         *-freebsd2.2*)
1246                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1247
1248                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
1249                 # -mthreads flag.
1250                 ;;
1251         *-sysv5uw7*)  # UnixWare 7
1252                 if test "$GCC" != "yes"; then
1253                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
1254                 else
1255                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
1256                 fi
1257                 ;;
1258         *-dg-dgux*)  # DG/UX
1259                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
1260     esac
1261
1262     # if we are not finding the localtime_r function, then we probably are
1263     # not using the proper multithread flag
1264
1265     glib_save_CPPFLAGS="$CPPFLAGS"
1266     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1267
1268     # First we test, whether localtime_r is declared in time.h
1269     # directly. Then we test whether a macro localtime_r exists, in
1270     # which case localtime_r in the test program is replaced and thus
1271     # if we still find localtime_r in the output, it is not defined as
1272     # a macro.
1273
1274     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1275       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1276                                                            localtime_r(a,b)],
1277                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1278
1279     CPPFLAGS="$glib_save_CPPFLAGS"
1280
1281     AC_MSG_CHECKING(thread related cflags)
1282     AC_MSG_RESULT($G_THREAD_CFLAGS)
1283     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1284 fi
1285
1286 dnl determination of G_THREAD_LIBS
1287 dnl ******************************
1288
1289 mutex_has_default=no
1290 case $have_threads in
1291         posix|dce)
1292            glib_save_CPPFLAGS="$CPPFLAGS"
1293            CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1294            G_THREAD_LIBS=error
1295            glib_save_LIBS="$LIBS"
1296            case $host in
1297              *-sysv5uw7*) # UnixWare 7
1298                 if test "$GCC" != "yes"; then
1299                         G_THREAD_LIBS="-Kthread"
1300                 else
1301                         G_THREAD_LIBS="-pthread"
1302                 fi
1303                 ;;
1304              *-*-openbsd* | *-*-freebsd*)
1305                 # FreeBSD and OpenBSD want us to use the -pthread flag
1306                 # instead of linking to -lc_r and libtool enforces that.
1307                 G_THREAD_LIBS="-pthread"
1308                 ;;
1309              *)
1310                 for thread_lib in "" pthread pthread32 pthreads thread dce; do
1311                         if test x"$thread_lib" = x; then
1312                                 add_thread_lib=""
1313                                 IN=""
1314                         else
1315                                 add_thread_lib="-l$thread_lib"
1316                                 IN=" in -l$thread_lib"
1317                         fi
1318                         if test x"$have_threads" = xposix; then
1319                                 defattr=0
1320                         else
1321                                 defattr=pthread_attr_default
1322                         fi
1323
1324                         LIBS="$glib_save_LIBS $add_thread_lib"
1325
1326                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1327                         AC_TRY_RUN([#include <pthread.h>
1328                                 int check_me = 0;
1329                                 void* func(void* data) {check_me = 42;}
1330                                 main()
1331                                 { pthread_t t;
1332                                   void *ret;
1333                                   pthread_create (&t, $defattr, func, 0);
1334                                   pthread_join (t, &ret);
1335                                   exit (check_me != 42);
1336                                 }],
1337                                 [AC_MSG_RESULT(yes)
1338                                 G_THREAD_LIBS="$add_thread_lib"
1339                                 break],
1340                                 [AC_MSG_RESULT(no)])
1341                 done
1342                 ;;
1343            esac
1344            if test "x$G_THREAD_LIBS" = xerror; then
1345              AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1346            fi
1347            for thread_lib in "" rt rte; do
1348              if test x"$thread_lib" = x; then
1349                add_thread_lib=""
1350                IN=""
1351              else
1352                add_thread_lib="-l$thread_lib"
1353                IN=" in -l$thread_lib"
1354              fi
1355              LIBS="$glib_save_LIBS $add_thread_lib"
1356
1357              AC_MSG_CHECKING(for sched_get_priority_min$IN)
1358              AC_TRY_RUN([#include <sched.h>
1359                          #include <errno.h>
1360                          int main() {
1361                          errno = 0;
1362                          return sched_get_priority_min(SCHED_OTHER)==-1
1363                                 && errno != 0;}],
1364                         [AC_MSG_RESULT(yes)
1365                          G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1366                          posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1367                          posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1368                          break],
1369                         [AC_MSG_RESULT(no)])
1370            done
1371            LIBS="$glib_save_LIBS"
1372            mutex_has_default=yes
1373            mutex_default_type='pthread_mutex_t'
1374            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1375            mutex_header_file='pthread.h'
1376            if test "x$have_threads" = "xposix"; then
1377              g_threads_impl="POSIX"
1378            else
1379              g_threads_impl="DCE"
1380              have_threads="posix"
1381            fi
1382            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1383            CPPFLAGS="$glib_save_CPPFLAGS"
1384            ;;
1385         solaris)
1386            G_THREAD_LIBS=error
1387            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
1388            mutex_has_default=yes
1389            mutex_default_type='mutex_t'
1390            mutex_default_init="DEFAULTMUTEX"
1391            mutex_header_file='thread.h'
1392            g_threads_impl="SOLARIS"
1393            ;;
1394         win32)
1395            g_threads_impl="WIN32"
1396            G_THREAD_LIBS=""
1397            ;;
1398         none|no)
1399            g_threads_impl="NONE"
1400            ;;
1401         *)
1402            g_threads_impl="NONE"
1403            G_THREAD_LIBS=error
1404            ;;
1405 esac
1406
1407 if test "x$G_THREAD_LIBS" = xerror; then
1408         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1409 fi
1410
1411 case $host in
1412   *-*-beos*)
1413     G_THREAD_LIBS="-lbe -lroot -lglib "
1414     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1415     ;;
1416   *)
1417     ;;
1418 esac
1419
1420 AC_MSG_CHECKING(thread related libraries)
1421 AC_MSG_RESULT($G_THREAD_LIBS)
1422
1423 dnl check for mt safe function variants and some posix functions
1424 dnl ************************************************************
1425
1426 if test x"$have_threads" != xno; then
1427         glib_save_LIBS="$LIBS"
1428         # we are not doing the following for now, as this might require glib
1429         # to always be linked with the thread libs on some platforms.
1430         # LIBS="$LIBS $G_THREAD_LIBS"
1431         AC_CHECK_FUNCS(localtime_r)
1432         if test "$ac_cv_header_pwd_h" = "yes"; then
1433                 AC_CACHE_CHECK([for posix getpwuid_r],
1434                         ac_cv_func_posix_getpwuid_r,
1435                         [AC_TRY_RUN([#include <errno.h>
1436                                 #include <pwd.h>
1437                                 int main () { char buffer[10000];
1438                                 struct passwd pwd, *pwptr = &pwd;
1439                                 int error;
1440                                 errno = 0;
1441                                 error = getpwuid_r (0, &pwd, buffer,
1442                                         sizeof (buffer), &pwptr);
1443                                 return (error < 0 && errno == ENOSYS)
1444                                         || error == ENOSYS; }],
1445                                 [ac_cv_func_posix_getpwuid_r=yes],
1446                                 [ac_cv_func_posix_getpwuid_r=no])])
1447                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1448                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1449                                 [Have POSIX function getpwuid_r])
1450                 else
1451                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1452                                 ac_cv_func_nonposix_getpwuid_r,
1453                                 [AC_TRY_LINK([#include <pwd.h>],
1454                                         [char buffer[10000];
1455                                         struct passwd pwd;
1456                                         getpwuid_r (0, &pwd, buffer,
1457                                                         sizeof (buffer));],
1458                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1459                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1460                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1461                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1462                                         [Have non-POSIX function getpwuid_r])
1463                         fi
1464                 fi
1465         fi
1466         LIBS="$LIBS $G_THREAD_LIBS"
1467         if test x"$have_threads" = xposix; then
1468                 glib_save_CPPFLAGS="$CPPFLAGS"
1469                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1470                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1471                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1472                 # This is not AC_CHECK_FUNC to also work with function
1473                 # name mangling in header files.
1474                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1475                 AC_TRY_LINK([#include <pthread.h>],
1476                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1477                         [AC_MSG_RESULT(yes)
1478                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1479                                   [Have function pthread_attr_setstacksize])],
1480                         [AC_MSG_RESULT(no)])
1481                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1482                 if test x"$posix_priority_min" = xnone; then
1483                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1484                                 PX_PRIO_MIN],,[
1485                                 posix_priority_min=PX_PRIO_MIN
1486                                 posix_priority_max=PX_PRIO_MAX])
1487                 fi
1488                 if test x"$posix_priority_min" = xnone; then
1489                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1490                                 PRI_OTHER_MIN],,[
1491                                 posix_priority_min=PRI_OTHER_MIN
1492                                 posix_priority_max=PRI_OTHER_MAX])
1493                 fi
1494                 if test x"$posix_priority_min" = x; then
1495                         AC_MSG_RESULT(none found)
1496                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1497                         posix_priority_min=-1
1498                         posix_priority_max=-1
1499                 else
1500                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1501                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1502                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1503                 fi
1504                 posix_yield_func=none
1505                 AC_MSG_CHECKING(for posix yield function)
1506                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1507                                                         thr_yield; do
1508                         AC_TRY_LINK([#include <pthread.h>],
1509                                 [$yield_func()],
1510                                 [posix_yield_func="$yield_func"
1511                                 break])
1512                 done
1513                 if test x"$posix_yield_func" = xnone; then
1514                         AC_MSG_RESULT(none found)
1515                         AC_MSG_WARN($POSIX_NO_YIELD)
1516                         posix_yield_func="g_usleep(1000)"
1517                 else
1518                         AC_MSG_RESULT($posix_yield_func)
1519                         posix_yield_func="$posix_yield_func()"
1520                 fi
1521                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1522                 CPPFLAGS="$glib_save_CPPFLAGS"
1523
1524                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1525                 AC_TRY_RUN([#include <pthread.h>
1526                         #include <sys/types.h>
1527                         #include <unistd.h>
1528                         pid_t other_pid = 0;
1529
1530                         void* func(void* data) {other_pid = getpid();}
1531                         main()
1532                         { pthread_t t;
1533                           void *ret;
1534                           pthread_create (&t, $defattr, func, NULL);
1535                           pthread_join (t, &ret);
1536                           exit (getpid()==other_pid ||
1537                                 $posix_priority_min != $posix_priority_max);
1538                         }],
1539                         [AC_MSG_RESULT(yes)
1540                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1541                         ],
1542                         [AC_MSG_RESULT(no)])
1543         elif test x"$have_threads" = xwin32; then
1544                 # It's a pointer to a private struct
1545                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1546         elif test x"$have_threads" = xsolaris; then
1547                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1548         fi
1549
1550         LIBS="$glib_save_LIBS"
1551
1552         # now spit out all the warnings.
1553         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1554            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1555                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1556         fi
1557         if test "$ac_cv_func_localtime_r" != "yes"; then
1558                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1559         fi
1560 fi
1561
1562 if test x"$glib_cv_sizeof_system_thread" = x; then
1563    # use a pointer as a fallback.
1564    GLIB_SIZEOF(,void *, system_thread)
1565 fi
1566
1567 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1568                    [Source file containing theread implementation])
1569 AC_SUBST(G_THREAD_CFLAGS)
1570 AC_SUBST(G_THREAD_LIBS)
1571 AC_SUBST(G_THREAD_LIBS_EXTRA)
1572
1573 dnl **********************************************
1574 dnl *** GDefaultMutex setup and initialization ***
1575 dnl **********************************************
1576 dnl
1577 dnl if mutex_has_default = yes, we also got
1578 dnl mutex_default_type, mutex_default_init and mutex_header_file
1579 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1580         glib_save_CPPFLAGS="$CPPFLAGS"
1581         glib_save_LIBS="$LIBS"
1582         LIBS="$LIBS $G_THREAD_LIBS"
1583         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1584         GLIB_SIZEOF([#include <$mutex_header_file>],
1585                     $mutex_default_type,
1586                     gmutex,
1587                     )
1588         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1589                            $mutex_default_type,
1590                            gmutex,
1591                            $glib_cv_sizeof_gmutex,
1592                            $mutex_default_init)
1593         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1594                 mutex_has_default=no
1595         fi
1596         CPPFLAGS="$glib_save_CPPFLAGS"
1597         LIBS="$glib_save_LIBS"
1598         ,
1599 )
1600
1601
1602 dnl ****************************************
1603 dnl *** GLib POLL* compatibility defines ***
1604 dnl ****************************************
1605 GLIB_SYSDEFS(
1606 [#include <sys/types.h>
1607 #include <sys/poll.h>],
1608         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1609         glibconfig-sysdefs.h,
1610         =)
1611
1612 dnl **********************
1613 dnl *** Win32 API libs ***
1614 dnl **********************
1615
1616 case $host in
1617   *-*-cygwin*)
1618         G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32"
1619     ;;
1620   *-*-mingw*)
1621         G_LIBS_EXTRA="-lwsock32"
1622     ;;
1623   *)
1624         G_LIBS_EXTRA=""
1625     ;;
1626 esac
1627 AC_SUBST(G_LIBS_EXTRA)
1628
1629 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1630 dnl since we need it for g_iconv()
1631
1632 AC_MSG_CHECKING([for EILSEQ])
1633 AC_TRY_COMPILE([
1634 #include <errno.h>
1635 ],
1636 [
1637 int error = EILSEQ;
1638 ], have_eilseq=yes, have_eilseq=no);
1639 AC_MSG_RESULT($have_eilseq)
1640
1641 dnl ******************************************************************
1642 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1643 dnl ******************************************************************
1644
1645 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1646
1647 if test $cross_compiling = yes; then
1648   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1649   if test x$GLIB_GENMARSHAL = xno; then
1650     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1651   fi
1652 fi
1653
1654 dnl **************************
1655 dnl *** Checks for gtk-doc ***
1656 dnl **************************
1657
1658 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1659
1660 if test "x$with_html_dir" = "x" ; then
1661   HTML_DIR='${datadir}/gtk-doc/html'
1662 else
1663   HTML_DIR=$with_html_dir
1664 fi
1665
1666 AC_SUBST(HTML_DIR)
1667
1668 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1669
1670 gtk_doc_min_version=0.6
1671 if $GTKDOC ; then
1672     gtk_doc_version=`gtkdoc-mkdb --version`
1673     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1674     if perl <<EOF ; then
1675       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1676             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1677 EOF
1678       AC_MSG_RESULT(yes)
1679    else
1680       AC_MSG_RESULT(no)
1681       GTKDOC=false
1682    fi
1683 fi
1684
1685 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1686 AC_SUBST(HAVE_GTK_DOC)
1687
1688 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1689 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1690
1691 dnl Let people disable the gtk-doc stuff.
1692 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no)
1693
1694 if test x$enable_gtk_doc = xyes ; then
1695   if test x$GTKDOC = xtrue ; then
1696     enable_gtk_doc=yes
1697   else
1698     enable_gtk_doc=no
1699   fi
1700 fi
1701
1702 dnl NOTE: We need to use a separate automake conditional for this
1703 dnl       to make this work with the tarballs.
1704 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1705
1706 dnl ******************************
1707 dnl *** output the whole stuff ***
1708 dnl ******************************
1709
1710 AC_OUTPUT_COMMANDS([
1711
1712 ## Generate `glibconfig.h' in two cases
1713 ## 1. `config.status' is run either explicitly, or via configure.
1714 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1715 ##     config.h
1716 ## 2. CONFIG_OTHER is set explicitly
1717 ##
1718 ## Case 1 is difficult.  We know that `automake' sets one of
1719 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1720 ## only when AM_CONFIG_HEADER is set, however.
1721
1722 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1723   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1724   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1725 fi
1726 case "$CONFIG_OTHER" in
1727 *glibconfig.h*)
1728         echo creating glibconfig.h
1729         outfile=glibconfig.h-tmp
1730         cat > $outfile <<\_______EOF
1731 /* glibconfig.h
1732  *
1733  * This is a generated file.  Please modify 'configure.in'
1734  */
1735
1736 #ifndef __G_LIBCONFIG_H__
1737 #define __G_LIBCONFIG_H__
1738
1739 #include <glib/gmacros.h>
1740
1741 _______EOF
1742
1743         if test x$glib_limits_h = xyes; then
1744           echo '#include <limits.h>' >> $outfile
1745         fi
1746         if test x$glib_float_h = xyes; then
1747           echo '#include <float.h>' >> $outfile
1748         fi
1749         if test x$glib_values_h = xyes; then
1750           echo '#include <values.h>' >> $outfile
1751         fi
1752         if test "$glib_header_alloca_h" = "yes"; then
1753           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1754         fi
1755         if test x$glib_sys_poll_h = xyes; then
1756           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1757         fi
1758
1759         cat >> $outfile <<_______EOF
1760
1761 G_BEGIN_DECLS
1762
1763 #define G_MINFLOAT      $glib_mf
1764 #define G_MAXFLOAT      $glib_Mf
1765 #define G_MINDOUBLE     $glib_md
1766 #define G_MAXDOUBLE     $glib_Md
1767 #define G_MINSHORT      $glib_ms
1768 #define G_MAXSHORT      $glib_Ms
1769 #define G_MAXUSHORT     $glib_Mus
1770 #define G_MININT        $glib_mi
1771 #define G_MAXINT        $glib_Mi
1772 #define G_MAXUINT       $glib_Mui
1773 #define G_MINLONG       $glib_ml
1774 #define G_MAXLONG       $glib_Ml
1775 #define G_MAXULONG      $glib_Mul
1776
1777 #define G_MININT64      ((gint64)  0x8000000000000000)
1778 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1779 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1780
1781 _______EOF
1782
1783
1784         ### this should always be true in a modern C/C++ compiler
1785         cat >>$outfile <<_______EOF
1786 typedef signed char gint8;
1787 typedef unsigned char guint8;
1788 _______EOF
1789
1790
1791         if test -n "$gint16"; then
1792           cat >>$outfile <<_______EOF
1793 typedef signed $gint16 gint16;
1794 typedef unsigned $gint16 guint16;
1795 #define G_GINT16_FORMAT $gint16_format
1796 #define G_GUINT16_FORMAT $guint16_format
1797 _______EOF
1798         fi
1799
1800
1801         if test -n "$gint32"; then
1802           cat >>$outfile <<_______EOF
1803 typedef signed $gint32 gint32;
1804 typedef unsigned $gint32 guint32;
1805 #define G_GINT32_FORMAT $gint32_format
1806 #define G_GUINT32_FORMAT $guint32_format
1807 _______EOF
1808         fi
1809
1810         cat >>$outfile <<_______EOF
1811 #define G_HAVE_GINT64 1          /* deprecated, always true */
1812
1813 ${glib_extension}typedef signed $gint64 gint64;
1814 ${glib_extension}typedef unsigned $gint64 guint64;
1815
1816 #define G_GINT64_CONSTANT(val)  $gint64_constant
1817 _______EOF
1818
1819         if test x$gint64_format != x ; then
1820           cat >>$outfile <<_______EOF
1821 #define G_GINT64_FORMAT $gint64_format
1822 #define G_GUINT64_FORMAT $guint64_format
1823 _______EOF
1824         else
1825           cat >>$outfile <<_______EOF
1826 #undef G_GINT64_FORMAT
1827 #undef G_GUINT64_FORMAT
1828 _______EOF
1829         fi
1830
1831         cat >>$outfile <<_______EOF
1832
1833 #define GLIB_SIZEOF_VOID_P $glib_void_p
1834 #define GLIB_SIZEOF_LONG   $glib_long
1835 #define GLIB_SIZEOF_SIZE_T $glib_size_t
1836
1837 _______EOF
1838
1839 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
1840 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
1841
1842         if test -z "$glib_unknown_void_p"; then
1843           cat >>$outfile <<_______EOF
1844
1845 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1846 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1847
1848 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1849 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1850 _______EOF
1851         else
1852           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1853         fi
1854
1855
1856
1857         cat >>$outfile <<_______EOF
1858 $glib_atexit
1859 $glib_memmove
1860 $glib_defines
1861 $glib_os
1862
1863 $glib_vacopy
1864
1865 #ifdef  __cplusplus
1866 #define G_HAVE_INLINE   1
1867 #else   /* !__cplusplus */
1868 $glib_inline
1869 #endif  /* !__cplusplus */
1870
1871 _______EOF
1872
1873         if test x$g_have_iso_c_varargs = xyes ; then
1874                 cat >>$outfile <<_______EOF
1875 #ifndef __cplusplus
1876 # define G_HAVE_ISO_VARARGS 1
1877 #endif
1878 _______EOF
1879         fi
1880         if test x$g_have_iso_cxx_varargs = xyes ; then
1881                 cat >>$outfile <<_______EOF
1882 #ifdef __cplusplus
1883 # define G_HAVE_ISO_VARARGS 1
1884 #endif
1885 _______EOF
1886         fi
1887         if test x$g_have_gnuc_varargs = xyes ; then
1888                 cat >>$outfile <<_______EOF
1889
1890 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
1891  * is passed ISO vararg support is turned off, and there is no work
1892  * around to turn it on, so we unconditionally turn it off.
1893  */
1894 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
1895 #  undef G_HAVE_ISO_VARARGS
1896 #endif
1897
1898 #define G_HAVE_GNUC_VARARGS 1
1899 _______EOF
1900         fi
1901
1902         case x$g_stack_grows in
1903         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
1904         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
1905         esac
1906
1907
1908         echo >>$outfile
1909         if test x$g_have_eilseq = xno; then
1910                 cat >>$outfile <<_______EOF
1911 #ifndef EILSEQ
1912 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1913  * The correspondence between this and the corresponding definition
1914  * in libiconv is essential.
1915  */
1916 #  define EILSEQ ENOENT
1917 #endif
1918 _______EOF
1919
1920         fi
1921
1922         echo >>$outfile
1923         if test x$g_mutex_has_default = xyes; then
1924                 cat >>$outfile <<_______EOF
1925 $g_enable_threads_def G_THREADS_ENABLED
1926 #define G_THREADS_IMPL_$g_threads_impl_def
1927 typedef struct _GStaticMutex GStaticMutex;
1928 struct _GStaticMutex
1929 {
1930   struct _GMutex *runtime_mutex;
1931   union {
1932     char   pad[$g_mutex_sizeof];
1933     double dummy_double;
1934     void  *dummy_pointer;
1935     long   dummy_long;
1936   } static_mutex;
1937 };
1938 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1939 #define g_static_mutex_get_mutex(mutex) \
1940   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1941    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1942 _______EOF
1943         else
1944                 cat >>$outfile <<_______EOF
1945 $g_enable_threads_def G_THREADS_ENABLED
1946 #define G_THREADS_IMPL_$g_threads_impl_def
1947 typedef struct _GMutex* GStaticMutex;
1948 #define G_STATIC_MUTEX_INIT NULL
1949 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1950 _______EOF
1951         fi
1952
1953         cat >>$outfile <<_______EOF
1954 /* This represents a system thread as used by the implementation. An
1955  * alien implementaion, as loaded by g_thread_init can only count on
1956  * "sizeof (gpointer)" bytes to store their info. We however need more
1957  * for some of our native implementations. */
1958 typedef union _GSystemThread GSystemThread;
1959 union _GSystemThread
1960 {
1961   char   data[$g_system_thread_sizeof];
1962   double dummy_double;
1963   void  *dummy_pointer;
1964   long   dummy_long;
1965 };
1966 _______EOF
1967
1968         echo >>$outfile
1969         g_bit_sizes="16 32 64"
1970         for bits in $g_bit_sizes; do
1971           cat >>$outfile <<_______EOF
1972 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1973 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1974 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1975 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1976 _______EOF
1977         done
1978
1979         cat >>$outfile <<_______EOF
1980 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1981 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1982 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1983 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1984 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1985 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1986 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1987 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1988 #define G_BYTE_ORDER $g_byte_order
1989
1990 _______EOF
1991
1992         if test -r glibconfig-sysdefs.h; then
1993           cat glibconfig-sysdefs.h >>$outfile
1994         fi
1995
1996         cat >>$outfile <<_______EOF
1997
1998 #define G_MODULE_SUFFIX "$g_module_suffix"
1999
2000 G_END_DECLS
2001
2002 #endif /* GLIBCONFIG_H */
2003 _______EOF
2004
2005
2006         if cmp -s $outfile glibconfig.h; then
2007           echo glibconfig.h is unchanged
2008           rm -f $outfile
2009         else
2010           mv $outfile glibconfig.h
2011         fi ;;
2012 esac
2013 ],[
2014
2015 # Note that if two cases are the same, case goes with the first one.
2016 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2017 # on variable expansion in case labels.  Look at the generated config.status
2018 # for a hint.
2019
2020 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2021   glib_header_alloca_h="$ac_cv_working_alloca_h"
2022 else
2023   glib_header_alloca_h="$ac_cv_header_alloca_h"
2024 fi
2025
2026 case xyes in
2027 x$ac_cv_header_float_h)
2028   glib_float_h=yes
2029   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2030   glib_md=DBL_MIN glib_Md=DBL_MAX
2031   ;;
2032 x$ac_cv_header_values_h)
2033   glib_values_h=yes
2034   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2035   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2036   ;;
2037 esac
2038
2039 case xyes in
2040 x$ac_cv_header_limits_h)
2041   glib_limits_h=yes
2042   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2043   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2044   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2045   ;;
2046 x$ac_cv_header_values_h)
2047   glib_values_h=yes
2048   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2049   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2050   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2051   ;;
2052 esac
2053
2054 if test x$ac_cv_header_sys_poll_h = xyes ; then
2055   glib_sys_poll_h=yes
2056 fi
2057
2058 case 2 in
2059 $ac_cv_sizeof_short)
2060   gint16=short
2061   gint16_format='"hi"'
2062   guint16_format='"hu"'
2063   ;;
2064 $ac_cv_sizeof_int)
2065   gint16=int
2066   gint16_format='"i"'
2067   guint16_format='"u"'
2068   ;;
2069 esac
2070 case 4 in
2071 $ac_cv_sizeof_short)
2072   gint32=short
2073   gint32_format='"hi"'
2074   guint32_format='"hu"'
2075   ;;
2076 $ac_cv_sizeof_int)
2077   gint32=int
2078   gint32_format='"i"'
2079   guint32_format='"u"'
2080   ;;
2081 $ac_cv_sizeof_long)
2082   gint32=long
2083   gint32_format='"li"'
2084   guint32_format='"lu"'
2085   ;;
2086 esac
2087 case 8 in
2088 $ac_cv_sizeof_int)
2089   gint64=int
2090   gint64_format='"i"'
2091   guint64_format='"u"'
2092   glib_extension=
2093   gint64_constant='(val)'
2094   ;;
2095 $ac_cv_sizeof_long)
2096   gint64=long
2097   gint64_format='"li"'
2098   guint64_format='"lu"'
2099   glib_extension=
2100   gint64_constant='(val##L)'
2101   ;;
2102 $ac_cv_sizeof_long_long)
2103   gint64='long long'
2104   if test -n "$glib_cv_long_long_format"; then
2105     gint64_format='"'$glib_cv_long_long_format'i"'
2106     guint64_format='"'$glib_cv_long_long_format'u"'
2107   fi
2108   glib_extension='G_GNUC_EXTENSION '
2109   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2110   ;;
2111 $ac_cv_sizeof___int64)
2112   gint64='__int64'
2113   if test -n "$glib_cv_long_long_format"; then
2114     gint64_format='"'$glib_cv_long_long_format'i"'
2115     guint64_format='"'$glib_cv_long_long_format'u"'
2116   fi
2117   glib_extension=
2118   gint64_constant='(val##i64)'
2119   ;;
2120 esac
2121 glib_size_t=$glib_cv_sizeof_size_t
2122 glib_size_type_define=$glib_size_type
2123 glib_void_p=$ac_cv_sizeof_long
2124 glib_long=$ac_cv_sizeof_void_p
2125
2126 gintbits=`expr $ac_cv_sizeof_int \* 8`
2127 glongbits=`expr $ac_cv_sizeof_long \* 8`
2128
2129
2130 case $ac_cv_sizeof_void_p in
2131 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2132 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2133 *)                      glib_unknown_void_p=yes ;;
2134 esac
2135
2136
2137 case xyes in
2138 x$ac_cv_func_atexit)
2139   glib_atexit="
2140 #ifdef NeXT /* @#%@! NeXTStep */
2141 # define g_ATEXIT(proc) (!atexit (proc))
2142 #else
2143 # define g_ATEXIT(proc) (atexit (proc))
2144 #endif"
2145   ;;
2146 x$ac_cv_func_on_exit)
2147   glib_atexit="
2148 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2149   ;;
2150 esac
2151
2152 case xyes in
2153 x$ac_cv_func_memmove)
2154   glib_memmove='
2155 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2156   ;;
2157 x$glib_cv_working_bcopy)
2158   glib_memmove="
2159 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2160 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2161   ;;
2162 *)
2163   glib_memmove="
2164 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2165  * so we have to roll our own copy routine. */
2166 void g_memmove (void* dest, const void * src, unsigned long len);"
2167   ;;
2168 esac
2169
2170 glib_defines="
2171 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2172 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2173 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2174 "
2175
2176 case xyes in
2177 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2178 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2179 *)                      glib_vacopy=''
2180 esac
2181
2182 if test x$glib_cv_va_val_copy = xno; then
2183   glib_vacopy="\$glib_vacopy
2184 #define G_VA_COPY_AS_ARRAY 1"
2185 fi
2186
2187 if test x$glib_cv_hasinline = xyes; then
2188     glib_inline='#define G_HAVE_INLINE 1'
2189 fi
2190 if test x$glib_cv_has__inline = xyes; then
2191     glib_inline="\$glib_inline
2192 #define G_HAVE___INLINE 1"
2193 fi
2194 if test x$glib_cv_has__inline__ = xyes; then
2195     glib_inline="\$glib_inline
2196 #define G_HAVE___INLINE__ 1"
2197 fi
2198
2199 g_have_gnuc_varargs=$g_have_gnuc_varargs
2200 g_have_iso_c_varargs=$g_have_iso_c_varargs
2201 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2202
2203 case xyes in
2204 x$ac_cv_c_bigendian)
2205   g_byte_order=G_BIG_ENDIAN
2206   g_bs_native=BE
2207   g_bs_alien=LE
2208   ;;
2209 *)
2210   g_byte_order=G_LITTLE_ENDIAN
2211   g_bs_native=LE
2212   g_bs_alien=BE
2213   ;;
2214 esac
2215
2216 g_stack_grows=$glib_cv_stack_grows
2217
2218 g_have_eilseq=$have_eilseq
2219
2220 case x$have_threads in
2221 xno)    g_enable_threads_def="#undef";;
2222 *)      g_enable_threads_def="#define";;
2223 esac
2224
2225 g_threads_impl_def=$g_threads_impl
2226
2227 g_mutex_has_default="$mutex_has_default"
2228 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2229 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2230 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2231
2232 g_module_suffix="$glib_gmodule_suffix"
2233
2234 case $host in
2235   *-*-beos*)
2236     glib_os="#define G_OS_BEOS"
2237     ;;
2238   *-*-cygwin*)
2239     glib_os="#define G_OS_UNIX
2240 #define G_PLATFORM_WIN32
2241 #define G_WITH_CYGWIN"
2242     ;;
2243   *-*-mingw*)
2244     glib_os="#define G_OS_WIN32
2245 #define G_PLATFORM_WIN32"
2246     ;;
2247   *)
2248     glib_os="#define G_OS_UNIX"
2249     ;;
2250 esac
2251 ])
2252
2253 AC_OUTPUT([
2254 glib-2.0.pc
2255 glib-2.0-uninstalled.pc
2256 gmodule-2.0.pc
2257 gmodule-2.0-uninstalled.pc
2258 gthread-2.0.pc
2259 gthread-2.0-uninstalled.pc
2260 gobject-2.0.pc
2261 gobject-2.0-uninstalled.pc
2262 glib.spec
2263 glib-zip
2264 glib-gettextize
2265 Makefile
2266 build/Makefile
2267 build/win32/Makefile
2268 build/win32/dirent/Makefile
2269 glib/Makefile
2270 glib/libcharset/Makefile
2271 gmodule/gmoduleconf.h
2272 gmodule/Makefile
2273 gobject/Makefile
2274 gobject/glib-mkenums
2275 gthread/Makefile
2276 po/Makefile.in
2277 docs/Makefile
2278 docs/reference/Makefile
2279 docs/reference/glib/Makefile
2280 docs/reference/gobject/Makefile
2281 tests/Makefile
2282 m4macros/Makefile
2283 ])