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 100 '*' $GLIB_MINOR_VERSION + $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" = x; 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" = x; then
1490                         # AIX
1491                         AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
1492                                 PTHREAD_PRIO_MIN],,[
1493                                 posix_priority_min=PTHREAD_PRIO_MIN
1494                                 posix_priority_max=PTHREAD_PRIO_MIN])
1495                 fi
1496                 if test x"$posix_priority_min" = x; then
1497                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1498                                 PRI_OTHER_MIN],,[
1499                                 posix_priority_min=PRI_OTHER_MIN
1500                                 posix_priority_max=PRI_OTHER_MAX])
1501                 fi
1502                 if test x"$posix_priority_min" = x; then
1503                         AC_MSG_RESULT(none found)
1504                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1505                         posix_priority_min=-1
1506                         posix_priority_max=-1
1507                 else
1508                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1509                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1510                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1511                 fi
1512                 posix_yield_func=none
1513                 AC_MSG_CHECKING(for posix yield function)
1514                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1515                                                         thr_yield; do
1516                         AC_TRY_LINK([#include <pthread.h>],
1517                                 [$yield_func()],
1518                                 [posix_yield_func="$yield_func"
1519                                 break])
1520                 done
1521                 if test x"$posix_yield_func" = xnone; then
1522                         AC_MSG_RESULT(none found)
1523                         AC_MSG_WARN($POSIX_NO_YIELD)
1524                         posix_yield_func="g_usleep(1000)"
1525                 else
1526                         AC_MSG_RESULT($posix_yield_func)
1527                         posix_yield_func="$posix_yield_func()"
1528                 fi
1529                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1530                 CPPFLAGS="$glib_save_CPPFLAGS"
1531
1532                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1533                 AC_TRY_RUN([#include <pthread.h>
1534                         #include <sys/types.h>
1535                         #include <unistd.h>
1536                         pid_t other_pid = 0;
1537
1538                         void* func(void* data) {other_pid = getpid();}
1539                         main()
1540                         { pthread_t t;
1541                           void *ret;
1542                           pthread_create (&t, $defattr, func, NULL);
1543                           pthread_join (t, &ret);
1544                           exit (getpid()==other_pid ||
1545                                 $posix_priority_min != $posix_priority_max);
1546                         }],
1547                         [AC_MSG_RESULT(yes)
1548                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1549                         ],
1550                         [AC_MSG_RESULT(no)])
1551         elif test x"$have_threads" = xwin32; then
1552                 # It's a pointer to a private struct
1553                 GLIB_SIZEOF(,struct _GThreadData *, system_thread)
1554         elif test x"$have_threads" = xsolaris; then
1555                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1556         fi
1557
1558         LIBS="$glib_save_LIBS"
1559
1560         # now spit out all the warnings.
1561         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1562            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1563                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1564         fi
1565         if test "$ac_cv_func_localtime_r" != "yes"; then
1566                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1567         fi
1568 fi
1569
1570 if test x"$glib_cv_sizeof_system_thread" = x; then
1571    # use a pointer as a fallback.
1572    GLIB_SIZEOF(,void *, system_thread)
1573 fi
1574
1575 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1576                    [Source file containing theread implementation])
1577 AC_SUBST(G_THREAD_CFLAGS)
1578 AC_SUBST(G_THREAD_LIBS)
1579 AC_SUBST(G_THREAD_LIBS_EXTRA)
1580
1581 dnl **********************************************
1582 dnl *** GDefaultMutex setup and initialization ***
1583 dnl **********************************************
1584 dnl
1585 dnl if mutex_has_default = yes, we also got
1586 dnl mutex_default_type, mutex_default_init and mutex_header_file
1587 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1588         glib_save_CPPFLAGS="$CPPFLAGS"
1589         glib_save_LIBS="$LIBS"
1590         LIBS="$LIBS $G_THREAD_LIBS"
1591         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1592         GLIB_SIZEOF([#include <$mutex_header_file>],
1593                     $mutex_default_type,
1594                     gmutex,
1595                     )
1596         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1597                            $mutex_default_type,
1598                            gmutex,
1599                            $glib_cv_sizeof_gmutex,
1600                            $mutex_default_init)
1601         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1602                 mutex_has_default=no
1603         fi
1604         CPPFLAGS="$glib_save_CPPFLAGS"
1605         LIBS="$glib_save_LIBS"
1606         ,
1607 )
1608
1609
1610 dnl ****************************************
1611 dnl *** GLib POLL* compatibility defines ***
1612 dnl ****************************************
1613 GLIB_SYSDEFS(
1614 [#include <sys/types.h>
1615 #include <sys/poll.h>],
1616         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1617         glibconfig-sysdefs.h,
1618         =)
1619
1620 dnl **********************
1621 dnl *** Win32 API libs ***
1622 dnl **********************
1623
1624 case $host in
1625   *-*-cygwin*)
1626         G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32"
1627     ;;
1628   *-*-mingw*)
1629         G_LIBS_EXTRA="-lwsock32"
1630     ;;
1631   *)
1632         G_LIBS_EXTRA=""
1633     ;;
1634 esac
1635 AC_SUBST(G_LIBS_EXTRA)
1636
1637 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1638 dnl since we need it for g_iconv()
1639
1640 AC_MSG_CHECKING([for EILSEQ])
1641 AC_TRY_COMPILE([
1642 #include <errno.h>
1643 ],
1644 [
1645 int error = EILSEQ;
1646 ], have_eilseq=yes, have_eilseq=no);
1647 AC_MSG_RESULT($have_eilseq)
1648
1649 dnl ******************************************************************
1650 dnl *** Look for glib-genmarshal in PATH if we are cross-compiling ***
1651 dnl ******************************************************************
1652
1653 AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
1654
1655 if test $cross_compiling = yes; then
1656   AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal, no)
1657   if test x$GLIB_GENMARSHAL = xno; then
1658     AC_MSG_ERROR(Could not find a glib-genmarshal in your PATH)
1659   fi
1660 fi
1661
1662 dnl **************************
1663 dnl *** Checks for gtk-doc ***
1664 dnl **************************
1665
1666 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs])
1667
1668 if test "x$with_html_dir" = "x" ; then
1669   HTML_DIR='${datadir}/gtk-doc/html'
1670 else
1671   HTML_DIR=$with_html_dir
1672 fi
1673
1674 AC_SUBST(HTML_DIR)
1675
1676 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1677
1678 gtk_doc_min_version=0.6
1679 if $GTKDOC ; then
1680     gtk_doc_version=`gtkdoc-mkdb --version`
1681     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1682     if perl <<EOF ; then
1683       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1684             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1685 EOF
1686       AC_MSG_RESULT(yes)
1687    else
1688       AC_MSG_RESULT(no)
1689       GTKDOC=false
1690    fi
1691 fi
1692
1693 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1694 AC_SUBST(HAVE_GTK_DOC)
1695
1696 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1697 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1698
1699 dnl Let people disable the gtk-doc stuff.
1700 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=no)
1701
1702 if test x$enable_gtk_doc = xyes ; then
1703   if test x$GTKDOC = xtrue ; then
1704     enable_gtk_doc=yes
1705   else
1706     enable_gtk_doc=no
1707   fi
1708 fi
1709
1710 dnl NOTE: We need to use a separate automake conditional for this
1711 dnl       to make this work with the tarballs.
1712 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1713
1714 dnl ******************************
1715 dnl *** output the whole stuff ***
1716 dnl ******************************
1717
1718 AC_OUTPUT_COMMANDS([
1719
1720 ## Generate `glibconfig.h' in two cases
1721 ## 1. `config.status' is run either explicitly, or via configure.
1722 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1723 ##     config.h
1724 ## 2. CONFIG_OTHER is set explicitly
1725 ##
1726 ## Case 1 is difficult.  We know that `automake' sets one of
1727 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1728 ## only when AM_CONFIG_HEADER is set, however.
1729
1730 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1731   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1732   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1733 fi
1734 case "$CONFIG_OTHER" in
1735 *glibconfig.h*)
1736         echo creating glibconfig.h
1737         outfile=glibconfig.h-tmp
1738         cat > $outfile <<\_______EOF
1739 /* glibconfig.h
1740  *
1741  * This is a generated file.  Please modify 'configure.in'
1742  */
1743
1744 #ifndef __G_LIBCONFIG_H__
1745 #define __G_LIBCONFIG_H__
1746
1747 #include <glib/gmacros.h>
1748
1749 _______EOF
1750
1751         if test x$glib_limits_h = xyes; then
1752           echo '#include <limits.h>' >> $outfile
1753         fi
1754         if test x$glib_float_h = xyes; then
1755           echo '#include <float.h>' >> $outfile
1756         fi
1757         if test x$glib_values_h = xyes; then
1758           echo '#include <values.h>' >> $outfile
1759         fi
1760         if test "$glib_header_alloca_h" = "yes"; then
1761           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1762         fi
1763         if test x$glib_sys_poll_h = xyes; then
1764           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1765         fi
1766
1767         cat >> $outfile <<_______EOF
1768
1769 G_BEGIN_DECLS
1770
1771 #define G_MINFLOAT      $glib_mf
1772 #define G_MAXFLOAT      $glib_Mf
1773 #define G_MINDOUBLE     $glib_md
1774 #define G_MAXDOUBLE     $glib_Md
1775 #define G_MINSHORT      $glib_ms
1776 #define G_MAXSHORT      $glib_Ms
1777 #define G_MAXUSHORT     $glib_Mus
1778 #define G_MININT        $glib_mi
1779 #define G_MAXINT        $glib_Mi
1780 #define G_MAXUINT       $glib_Mui
1781 #define G_MINLONG       $glib_ml
1782 #define G_MAXLONG       $glib_Ml
1783 #define G_MAXULONG      $glib_Mul
1784
1785 #define G_MININT64      ((gint64)  0x8000000000000000)
1786 #define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
1787 #define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
1788
1789 _______EOF
1790
1791
1792         ### this should always be true in a modern C/C++ compiler
1793         cat >>$outfile <<_______EOF
1794 typedef signed char gint8;
1795 typedef unsigned char guint8;
1796 _______EOF
1797
1798
1799         if test -n "$gint16"; then
1800           cat >>$outfile <<_______EOF
1801 typedef signed $gint16 gint16;
1802 typedef unsigned $gint16 guint16;
1803 #define G_GINT16_FORMAT $gint16_format
1804 #define G_GUINT16_FORMAT $guint16_format
1805 _______EOF
1806         fi
1807
1808
1809         if test -n "$gint32"; then
1810           cat >>$outfile <<_______EOF
1811 typedef signed $gint32 gint32;
1812 typedef unsigned $gint32 guint32;
1813 #define G_GINT32_FORMAT $gint32_format
1814 #define G_GUINT32_FORMAT $guint32_format
1815 _______EOF
1816         fi
1817
1818         cat >>$outfile <<_______EOF
1819 #define G_HAVE_GINT64 1          /* deprecated, always true */
1820
1821 ${glib_extension}typedef signed $gint64 gint64;
1822 ${glib_extension}typedef unsigned $gint64 guint64;
1823
1824 #define G_GINT64_CONSTANT(val)  $gint64_constant
1825 _______EOF
1826
1827         if test x$gint64_format != x ; then
1828           cat >>$outfile <<_______EOF
1829 #define G_GINT64_FORMAT $gint64_format
1830 #define G_GUINT64_FORMAT $guint64_format
1831 _______EOF
1832         else
1833           cat >>$outfile <<_______EOF
1834 #undef G_GINT64_FORMAT
1835 #undef G_GUINT64_FORMAT
1836 _______EOF
1837         fi
1838
1839         cat >>$outfile <<_______EOF
1840
1841 #define GLIB_SIZEOF_VOID_P $glib_void_p
1842 #define GLIB_SIZEOF_LONG   $glib_long
1843 #define GLIB_SIZEOF_SIZE_T $glib_size_t
1844
1845 _______EOF
1846
1847 echo "typedef signed $glib_size_type_define gssize;" >> $outfile
1848 echo "typedef unsigned $glib_size_type_define gsize;" >> $outfile
1849
1850         if test -z "$glib_unknown_void_p"; then
1851           cat >>$outfile <<_______EOF
1852
1853 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1854 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1855
1856 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1857 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1858 _______EOF
1859         else
1860           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1861         fi
1862
1863
1864
1865         cat >>$outfile <<_______EOF
1866 $glib_atexit
1867 $glib_memmove
1868 $glib_defines
1869 $glib_os
1870
1871 $glib_vacopy
1872
1873 #ifdef  __cplusplus
1874 #define G_HAVE_INLINE   1
1875 #else   /* !__cplusplus */
1876 $glib_inline
1877 #endif  /* !__cplusplus */
1878
1879 _______EOF
1880
1881         if test x$g_have_iso_c_varargs = xyes ; then
1882                 cat >>$outfile <<_______EOF
1883 #ifndef __cplusplus
1884 # define G_HAVE_ISO_VARARGS 1
1885 #endif
1886 _______EOF
1887         fi
1888         if test x$g_have_iso_cxx_varargs = xyes ; then
1889                 cat >>$outfile <<_______EOF
1890 #ifdef __cplusplus
1891 # define G_HAVE_ISO_VARARGS 1
1892 #endif
1893 _______EOF
1894         fi
1895         if test x$g_have_gnuc_varargs = xyes ; then
1896                 cat >>$outfile <<_______EOF
1897
1898 /* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
1899  * is passed ISO vararg support is turned off, and there is no work
1900  * around to turn it on, so we unconditionally turn it off.
1901  */
1902 #if __GNUC__ == 2 && __GNUC_MINOR__ == 95
1903 #  undef G_HAVE_ISO_VARARGS
1904 #endif
1905
1906 #define G_HAVE_GNUC_VARARGS 1
1907 _______EOF
1908         fi
1909
1910         case x$g_stack_grows in
1911         xyes) echo "#define G_HAVE_GROWING_STACK 1" >>$outfile ;;
1912         *)    echo "#define G_HAVE_GROWING_STACK 0" >>$outfile ;;
1913         esac
1914
1915
1916         echo >>$outfile
1917         if test x$g_have_eilseq = xno; then
1918                 cat >>$outfile <<_______EOF
1919 #ifndef EILSEQ
1920 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1921  * The correspondence between this and the corresponding definition
1922  * in libiconv is essential.
1923  */
1924 #  define EILSEQ ENOENT
1925 #endif
1926 _______EOF
1927
1928         fi
1929
1930         echo >>$outfile
1931         if test x$g_mutex_has_default = xyes; then
1932                 cat >>$outfile <<_______EOF
1933 $g_enable_threads_def G_THREADS_ENABLED
1934 #define G_THREADS_IMPL_$g_threads_impl_def
1935 typedef struct _GStaticMutex GStaticMutex;
1936 struct _GStaticMutex
1937 {
1938   struct _GMutex *runtime_mutex;
1939   union {
1940     char   pad[$g_mutex_sizeof];
1941     double dummy_double;
1942     void  *dummy_pointer;
1943     long   dummy_long;
1944   } static_mutex;
1945 };
1946 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1947 #define g_static_mutex_get_mutex(mutex) \
1948   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1949    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1950 _______EOF
1951         else
1952                 cat >>$outfile <<_______EOF
1953 $g_enable_threads_def G_THREADS_ENABLED
1954 #define G_THREADS_IMPL_$g_threads_impl_def
1955 typedef struct _GMutex* GStaticMutex;
1956 #define G_STATIC_MUTEX_INIT NULL
1957 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1958 _______EOF
1959         fi
1960
1961         cat >>$outfile <<_______EOF
1962 /* This represents a system thread as used by the implementation. An
1963  * alien implementaion, as loaded by g_thread_init can only count on
1964  * "sizeof (gpointer)" bytes to store their info. We however need more
1965  * for some of our native implementations. */
1966 typedef union _GSystemThread GSystemThread;
1967 union _GSystemThread
1968 {
1969   char   data[$g_system_thread_sizeof];
1970   double dummy_double;
1971   void  *dummy_pointer;
1972   long   dummy_long;
1973 };
1974 _______EOF
1975
1976         echo >>$outfile
1977         g_bit_sizes="16 32 64"
1978         for bits in $g_bit_sizes; do
1979           cat >>$outfile <<_______EOF
1980 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1981 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1982 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1983 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1984 _______EOF
1985         done
1986
1987         cat >>$outfile <<_______EOF
1988 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1989 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1990 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1991 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1992 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1993 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1994 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1995 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1996 #define G_BYTE_ORDER $g_byte_order
1997
1998 _______EOF
1999
2000         if test -r glibconfig-sysdefs.h; then
2001           cat glibconfig-sysdefs.h >>$outfile
2002         fi
2003
2004         cat >>$outfile <<_______EOF
2005
2006 #define G_MODULE_SUFFIX "$g_module_suffix"
2007
2008 G_END_DECLS
2009
2010 #endif /* GLIBCONFIG_H */
2011 _______EOF
2012
2013
2014         if cmp -s $outfile glibconfig.h; then
2015           echo glibconfig.h is unchanged
2016           rm -f $outfile
2017         else
2018           mv $outfile glibconfig.h
2019         fi ;;
2020 esac
2021 ],[
2022
2023 # Note that if two cases are the same, case goes with the first one.
2024 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
2025 # on variable expansion in case labels.  Look at the generated config.status
2026 # for a hint.
2027
2028 if test "x${ac_cv_working_alloca_h+set}" = xset ; then
2029   glib_header_alloca_h="$ac_cv_working_alloca_h"
2030 else
2031   glib_header_alloca_h="$ac_cv_header_alloca_h"
2032 fi
2033
2034 case xyes in
2035 x$ac_cv_header_float_h)
2036   glib_float_h=yes
2037   glib_mf=FLT_MIN glib_Mf=FLT_MAX
2038   glib_md=DBL_MIN glib_Md=DBL_MAX
2039   ;;
2040 x$ac_cv_header_values_h)
2041   glib_values_h=yes
2042   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
2043   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
2044   ;;
2045 esac
2046
2047 case xyes in
2048 x$ac_cv_header_limits_h)
2049   glib_limits_h=yes
2050   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
2051   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
2052   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
2053   ;;
2054 x$ac_cv_header_values_h)
2055   glib_values_h=yes
2056   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
2057   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
2058   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
2059   ;;
2060 esac
2061
2062 if test x$ac_cv_header_sys_poll_h = xyes ; then
2063   glib_sys_poll_h=yes
2064 fi
2065
2066 case 2 in
2067 $ac_cv_sizeof_short)
2068   gint16=short
2069   gint16_format='"hi"'
2070   guint16_format='"hu"'
2071   ;;
2072 $ac_cv_sizeof_int)
2073   gint16=int
2074   gint16_format='"i"'
2075   guint16_format='"u"'
2076   ;;
2077 esac
2078 case 4 in
2079 $ac_cv_sizeof_short)
2080   gint32=short
2081   gint32_format='"hi"'
2082   guint32_format='"hu"'
2083   ;;
2084 $ac_cv_sizeof_int)
2085   gint32=int
2086   gint32_format='"i"'
2087   guint32_format='"u"'
2088   ;;
2089 $ac_cv_sizeof_long)
2090   gint32=long
2091   gint32_format='"li"'
2092   guint32_format='"lu"'
2093   ;;
2094 esac
2095 case 8 in
2096 $ac_cv_sizeof_int)
2097   gint64=int
2098   gint64_format='"i"'
2099   guint64_format='"u"'
2100   glib_extension=
2101   gint64_constant='(val)'
2102   ;;
2103 $ac_cv_sizeof_long)
2104   gint64=long
2105   gint64_format='"li"'
2106   guint64_format='"lu"'
2107   glib_extension=
2108   gint64_constant='(val##L)'
2109   ;;
2110 $ac_cv_sizeof_long_long)
2111   gint64='long long'
2112   if test -n "$glib_cv_long_long_format"; then
2113     gint64_format='"'$glib_cv_long_long_format'i"'
2114     guint64_format='"'$glib_cv_long_long_format'u"'
2115   fi
2116   glib_extension='G_GNUC_EXTENSION '
2117   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
2118   ;;
2119 $ac_cv_sizeof___int64)
2120   gint64='__int64'
2121   if test -n "$glib_cv_long_long_format"; then
2122     gint64_format='"'$glib_cv_long_long_format'i"'
2123     guint64_format='"'$glib_cv_long_long_format'u"'
2124   fi
2125   glib_extension=
2126   gint64_constant='(val##i64)'
2127   ;;
2128 esac
2129 glib_size_t=$glib_cv_sizeof_size_t
2130 glib_size_type_define=$glib_size_type
2131 glib_void_p=$ac_cv_sizeof_long
2132 glib_long=$ac_cv_sizeof_void_p
2133
2134 gintbits=`expr $ac_cv_sizeof_int \* 8`
2135 glongbits=`expr $ac_cv_sizeof_long \* 8`
2136
2137
2138 case $ac_cv_sizeof_void_p in
2139 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
2140 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
2141 *)                      glib_unknown_void_p=yes ;;
2142 esac
2143
2144
2145 case xyes in
2146 x$ac_cv_func_atexit)
2147   glib_atexit="
2148 #ifdef NeXT /* @#%@! NeXTStep */
2149 # define g_ATEXIT(proc) (!atexit (proc))
2150 #else
2151 # define g_ATEXIT(proc) (atexit (proc))
2152 #endif"
2153   ;;
2154 x$ac_cv_func_on_exit)
2155   glib_atexit="
2156 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
2157   ;;
2158 esac
2159
2160 case xyes in
2161 x$ac_cv_func_memmove)
2162   glib_memmove='
2163 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
2164   ;;
2165 x$glib_cv_working_bcopy)
2166   glib_memmove="
2167 /* memmove isn't available, but bcopy can copy overlapping memory regions */
2168 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
2169   ;;
2170 *)
2171   glib_memmove="
2172 /* memmove isn't found and bcopy can't copy overlapping memory regions,
2173  * so we have to roll our own copy routine. */
2174 void g_memmove (void* dest, const void * src, unsigned long len);"
2175   ;;
2176 esac
2177
2178 glib_defines="
2179 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
2180 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
2181 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
2182 "
2183
2184 case xyes in
2185 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
2186 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
2187 *)                      glib_vacopy=''
2188 esac
2189
2190 if test x$glib_cv_va_val_copy = xno; then
2191   glib_vacopy="\$glib_vacopy
2192 #define G_VA_COPY_AS_ARRAY 1"
2193 fi
2194
2195 if test x$glib_cv_hasinline = xyes; then
2196     glib_inline='#define G_HAVE_INLINE 1'
2197 fi
2198 if test x$glib_cv_has__inline = xyes; then
2199     glib_inline="\$glib_inline
2200 #define G_HAVE___INLINE 1"
2201 fi
2202 if test x$glib_cv_has__inline__ = xyes; then
2203     glib_inline="\$glib_inline
2204 #define G_HAVE___INLINE__ 1"
2205 fi
2206
2207 g_have_gnuc_varargs=$g_have_gnuc_varargs
2208 g_have_iso_c_varargs=$g_have_iso_c_varargs
2209 g_have_iso_cxx_varargs=$g_have_iso_cxx_varargs
2210
2211 case xyes in
2212 x$ac_cv_c_bigendian)
2213   g_byte_order=G_BIG_ENDIAN
2214   g_bs_native=BE
2215   g_bs_alien=LE
2216   ;;
2217 *)
2218   g_byte_order=G_LITTLE_ENDIAN
2219   g_bs_native=LE
2220   g_bs_alien=BE
2221   ;;
2222 esac
2223
2224 g_stack_grows=$glib_cv_stack_grows
2225
2226 g_have_eilseq=$have_eilseq
2227
2228 case x$have_threads in
2229 xno)    g_enable_threads_def="#undef";;
2230 *)      g_enable_threads_def="#define";;
2231 esac
2232
2233 g_threads_impl_def=$g_threads_impl
2234
2235 g_mutex_has_default="$mutex_has_default"
2236 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
2237 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
2238 g_mutex_contents="$glib_cv_byte_contents_gmutex"
2239
2240 g_module_suffix="$glib_gmodule_suffix"
2241
2242 case $host in
2243   *-*-beos*)
2244     glib_os="#define G_OS_BEOS"
2245     ;;
2246   *-*-cygwin*)
2247     glib_os="#define G_OS_UNIX
2248 #define G_PLATFORM_WIN32
2249 #define G_WITH_CYGWIN"
2250     ;;
2251   *-*-mingw*)
2252     glib_os="#define G_OS_WIN32
2253 #define G_PLATFORM_WIN32"
2254     ;;
2255   *)
2256     glib_os="#define G_OS_UNIX"
2257     ;;
2258 esac
2259 ])
2260
2261 AC_OUTPUT([
2262 glib-2.0.pc
2263 glib-2.0-uninstalled.pc
2264 gmodule-2.0.pc
2265 gmodule-2.0-uninstalled.pc
2266 gthread-2.0.pc
2267 gthread-2.0-uninstalled.pc
2268 gobject-2.0.pc
2269 gobject-2.0-uninstalled.pc
2270 glib.spec
2271 glib-zip
2272 glib-gettextize
2273 Makefile
2274 build/Makefile
2275 build/win32/Makefile
2276 build/win32/dirent/Makefile
2277 glib/Makefile
2278 glib/libcharset/Makefile
2279 gmodule/gmoduleconf.h
2280 gmodule/Makefile
2281 gobject/Makefile
2282 gobject/glib-mkenums
2283 gthread/Makefile
2284 po/Makefile.in
2285 docs/Makefile
2286 docs/reference/Makefile
2287 docs/reference/glib/Makefile
2288 docs/reference/gobject/Makefile
2289 tests/Makefile
2290 m4macros/Makefile
2291 ])