configure.in

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