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