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