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