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(glist.c)
  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_DIVERT_BEFORE_HELP([
  19 #
  20 # The following version number definitions apply to GLib, GModule, GObject and GThread
  21 # 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=1
  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 AC_SUBST(LT_RELEASE)
  53 AC_SUBST(LT_CURRENT)
  54 AC_SUBST(LT_REVISION)
  55 AC_SUBST(LT_AGE)
  56
  57 VERSION=$GLIB_VERSION
  58 PACKAGE=glib
  59
  60 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  61
  62 # Specify a configuration file
  63 AM_CONFIG_HEADER(config.h)
  64
  65 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION)
  66 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION)
  67 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION)
  68 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE)
  69 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)
  70
  71 dnl Initialize libtool
  72 AM_PROG_LIBTOOL
  73
  74 dnl Initialize maintainer mode
  75 AM_MAINTAINER_MODE
  76
  77 AC_CANONICAL_HOST
  78
  79 AC_MSG_CHECKING(for the BeOS)
  80 case $host in
  81   *-*-beos*)
  82     glib_native_beos="yes"
  83     ;;
  84   *)
  85     glib_native_beos="no"
  86     ;;
  87 esac
  88 AC_MSG_RESULT([$glib_native_beos])
  89
  90 dnl
  91
  92 GLIB_DIVERT_BEFORE_HELP([
  93 # figure debugging default, prior to $ac_help setup
  94 if test `expr $GLIB_MINOR_VERSION \% 2` = 1 ; then
  95   debug_default=yes
  96 else
  97   debug_default=minimum
  98 fi[]dnl
  99 ])
 100
 101 dnl declare --enable-* args and collect ac_help strings
 102 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
 103 AC_ARG_ENABLE(msg-prefix, [  --enable-msg-prefix     turn on program name and PID prefixing of messages and warnings],,enable_msg_prefix=no)
 104 AC_ARG_ENABLE(mem_check, [  --enable-mem-check      turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
 105 AC_ARG_ENABLE(mem_profile, [  --enable-mem-profile    turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)
 106 AC_ARG_ENABLE(gc_friendly, [  --enable-gc-friendly    turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
 107 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
 108                     , enable_ansi=no)
 109 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
 110                           ([=no] will override --with-threads)],,enable_threads=yes)
 111
 112 if test "x$enable_threads" != "xyes"; then
 113   enable_threads=no
 114 fi
 115
 116 AC_MSG_CHECKING(whether to enable memory checking)
 117 if test "x$enable_mem_check" = "xyes"; then
 118   AC_DEFINE(ENABLE_MEM_CHECK, 1)
 119   AC_SUBST(ENABLE_MEM_CHECK)
 120   AC_MSG_RESULT(yes)
 121 else
 122   AC_MSG_RESULT(no)
 123 fi
 124
 125 AC_MSG_CHECKING(whether to enable memory profiling)
 126 if test "x$enable_mem_profile" = "xyes"; then
 127   AC_DEFINE(ENABLE_MEM_PROFILE, 1)
 128   AC_SUBST(ENABLE_MEM_PROFILE)
 129   AC_MSG_RESULT(yes)
 130 else
 131   AC_MSG_RESULT(no)
 132 fi
 133
 134 AC_MSG_CHECKING(whether to enable garbage collector friendliness)
 135 if test "x$enable_gc_friendly" = "xyes"; then
 136   AC_DEFINE(ENABLE_GC_FRIENDLY, 1)
 137   AC_SUBST(ENABLE_GC_FRIENDLY)
 138   AC_MSG_RESULT(yes)
 139 else
 140   AC_MSG_RESULT(no)
 141 fi
 142
 143 if test "x$enable_debug" = "xyes"; then
 144   test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
 145   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 146 else
 147   if test "x$enable_debug" = "xno"; then
 148     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 149   fi
 150 fi
 151
 152 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}")
 153
 154 if test "x$enable_msg_prefix" = "xyes"; then
 155   AC_DEFINE_UNQUOTED(G_ENABLE_MSG_PREFIX, 1)
 156 fi
 157
 158 # Checks for programs.
 159 AC_PROG_CC
 160 AM_PROG_CC_STDC
 161 AC_PROG_INSTALL
 162
 163 changequote(,)dnl
 164 if test "x$GCC" = "xyes"; then
 165   case " $CFLAGS " in
 166   *[\ \ ]-Wall[\ \      ]*) ;;
 167   *) CFLAGS="$CFLAGS -Wall" ;;
 168   esac
 169
 170   if test "x$enable_ansi" = "xyes"; then
 171     case " $CFLAGS " in
 172     *[\ \       ]-ansi[\ \      ]*) ;;
 173     *) CFLAGS="$CFLAGS -ansi" ;;
 174     esac
 175
 176     case " $CFLAGS " in
 177     *[\ \       ]-pedantic[\ \  ]*) ;;
 178     *) CFLAGS="$CFLAGS -pedantic" ;;
 179     esac
 180   fi
 181 fi
 182 changequote([,])dnl
 183
 184 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 185 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 186 glib_save_LIBS=$LIBS
 187 LIBS="$LIBS -lm"
 188 AC_TRY_RUN([#include <math.h>
 189              int main (void) { return (log(1) != log(1.)); }],
 190      AC_MSG_RESULT(none needed),
 191      glib_save_CFLAGS=$CFLAGS
 192      CFLAGS="$CFLAGS -std1"
 193      AC_TRY_RUN([#include <math.h>
 194                  int main (void) { return (log(1) != log(1.)); }],
 195          AC_MSG_RESULT(-std1),
 196          AC_MSG_RESULT()
 197          CFLAGS=$glib_save_CFLAGS
 198          AC_MSG_WARN(
 199                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 200      )
 201 )
 202 LIBS=$glib_save_LIBS
 203
 204 dnl NeXTStep cc seems to need this
 205 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 206 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 207   AC_MSG_RESULT(none needed),
 208   glib_save_CFLAGS=$CFLAGS
 209   CFLAGS="$CFLAGS -posix"
 210   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 211     AC_MSG_RESULT(-posix),
 212     AC_MSG_RESULT()
 213     CFLAGS=$glib_save_CFLAGS
 214     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 215
 216 # Checks for header files.
 217 AC_HEADER_STDC
 218
 219 # Checks for library functions.
 220 AC_FUNC_VPRINTF
 221
 222 AC_FUNC_ALLOCA
 223
 224 AC_CHECK_FUNCS(atexit on_exit)
 225
 226 AC_CHECK_SIZEOF(char)
 227 AC_CHECK_SIZEOF(short)
 228 AC_CHECK_SIZEOF(long)
 229 AC_CHECK_SIZEOF(int)
 230 AC_CHECK_SIZEOF(void *)
 231 AC_CHECK_SIZEOF(long long)
 232
 233 if test x$ac_cv_sizeof_long_long = x8; then
 234         # long long is a 64 bit integer.
 235         AC_MSG_CHECKING(for format to printf and scanf a gint64)
 236         AC_CACHE_VAL(glib_cv_long_long_format,[
 237                 for format in ll q; do
 238                   AC_TRY_RUN([#include <stdio.h>
 239                         int main()
 240                         {
 241                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 242                           char buffer[1000];
 243                           sprintf (buffer, "%${format}u", a);
 244                           sscanf (buffer, "%${format}u", &b);
 245                           exit (b!=a);
 246                         }
 247                         ],
 248                         glib_cv_long_long_format=${format}
 249                         break)
 250                 done])
 251         if test -n "$glib_cv_long_long_format"; then
 252           AC_MSG_RESULT(%${glib_cv_long_long_format}i)
 253         else
 254           AC_MSG_RESULT(none)
 255         fi
 256 fi
 257
 258 dnl long doubles were not used, and a portability problem
 259 dnl AC_C_LONG_DOUBLE
 260 AC_C_CONST
 261
 262 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 263 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 264 dnl actually supported.
 265 AC_MSG_CHECKING(for __inline)
 266 AC_CACHE_VAL(glib_cv_has__inline,[
 267         AC_TRY_RUN([
 268         __inline int foo () { return 0; }
 269         int main () { return foo (); }
 270         ],
 271         glib_cv_has__inline=yes
 272         ,
 273         glib_cv_has__inline=no
 274         ,)
 275 ])
 276 AC_MSG_RESULT($glib_cv_has__inline)
 277 case x$glib_cv_has__inline in
 278 xyes) AC_DEFINE(G_HAVE___INLINE)
 279 esac
 280 AC_MSG_CHECKING(for __inline__)
 281 AC_CACHE_VAL(glib_cv_has__inline__,[
 282         AC_TRY_RUN([
 283         __inline__ int foo () { return 0; }
 284         int main () { return foo (); }
 285         ],
 286         glib_cv_has__inline__=yes
 287         ,
 288         glib_cv_has__inline__=no
 289         ,)
 290 ])
 291 AC_MSG_RESULT($glib_cv_has__inline__)
 292 case x$glib_cv_has__inline__ in
 293 xyes) AC_DEFINE(G_HAVE___INLINE__)
 294 esac
 295 AC_MSG_CHECKING(for inline)
 296 AC_CACHE_VAL(glib_cv_hasinline,[
 297         AC_TRY_RUN([
 298         inline int foo () { return 0; }
 299         int main () { return foo (); }
 300         ],
 301         glib_cv_hasinline=yes
 302         ,
 303         glib_cv_hasinline=no
 304         ,)
 305 ])
 306 AC_MSG_RESULT($glib_cv_hasinline)
 307 case x$glib_cv_hasinline in
 308 xyes) AC_DEFINE(G_HAVE_INLINE)
 309 esac
 310
 311 # check for bytesex stuff
 312 AC_C_BIGENDIAN
 313
 314 # check for header files
 315 AC_CHECK_HEADERS([float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h])
 316 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h])
 317
 318 AC_MSG_CHECKING(whether make is GNU Make)
 319 STRIP_BEGIN=
 320 STRIP_END=
 321 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
 322         STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 323         STRIP_END=')'
 324         AC_MSG_RESULT(yes)
 325 else
 326         AC_MSG_RESULT(no)
 327 fi
 328 STRIP_DUMMY=
 329 AC_SUBST(STRIP_DUMMY)
 330 AC_SUBST(STRIP_BEGIN)
 331 AC_SUBST(STRIP_END)
 332
 333 # check additional type sizes
 334 size_includes=["
 335 #include <stdarg.h>
 336 #include <stdio.h>
 337 #include <ctype.h>
 338 #include <string.h>
 339 "]
 340 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 341   size_includes=["$size_includes
 342 #include <stdint.h>
 343 "]
 344 fi
 345 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 346   size_includes=["$size_includes
 347 #include <unistd.h>
 348 "]
 349 fi
 350 GLIB_SIZEOF([$size_includes], size_t, size_t)
 351 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 352 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 353
 354 # Check for some functions
 355 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll getcwd)
 356
 357 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 358 # The check is borrowed from the PERL Configure script.
 359 if test "$ac_cv_func_memmove" != "yes"; then
 360   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 361     glib_cv_working_bcopy,[AC_TRY_RUN([
 362       int main() {
 363         char buf[128], abc[128], *b;
 364         int len, off, align;
 365         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 366         for (align = 7; align >= 0; align--) {
 367           for (len = 36; len; len--) {
 368             b = buf+align; bcopy(abc, b, len);
 369             for (off = 1; off <= len; off++) {
 370               bcopy(b, b+off, len); bcopy(b+off, b, len);
 371                 if (bcmp(b, abc, len)) return(1);
 372             }
 373           }
 374         }
 375         return(0);
 376       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 377   if test "$glib_cv_working_bcopy" == "yes"; then
 378     AC_DEFINE(HAVE_WORKING_BCOPY)
 379   fi
 380 fi
 381
 382 # Check for sys_errlist
 383 AC_MSG_CHECKING(for sys_errlist)
 384 AC_TRY_LINK(, [
 385 extern char *sys_errlist[];
 386 extern int sys_nerr;
 387 sys_errlist[sys_nerr-1][0] = 0;
 388 ], glib_ok=yes, glib_ok=no)
 389 AC_MSG_RESULT($glib_ok)
 390 if test $glib_ok = no; then
 391     AC_DEFINE(NO_SYS_ERRLIST)
 392 fi
 393
 394 # Check for sys_siglist
 395 AC_MSG_CHECKING(for sys_siglist)
 396 AC_TRY_LINK(, [
 397 extern char *sys_siglist[];
 398 exit (sys_siglist[0]);
 399 ], glib_ok=yes, glib_ok=no)
 400 AC_MSG_RESULT($glib_ok)
 401 if test $glib_ok = no; then
 402     AC_DEFINE(NO_SYS_SIGLIST)
 403 fi
 404
 405 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 406 AC_MSG_CHECKING(for sys_siglist declaration)
 407 AC_TRY_COMPILE([#include <signal.h>], [
 408 strlen (sys_siglist[0]);
 409 ], glib_ok=yes, glib_ok=no)
 410 AC_MSG_RESULT($glib_ok)
 411 if test $glib_ok = no; then
 412     AC_DEFINE(NO_SYS_SIGLIST_DECL)
 413 fi
 414
 415 # Check if <sys/select.h> needs to be included for fd_set
 416 AC_MSG_CHECKING([for fd_set])
 417 AC_TRY_COMPILE([#include <sys/types.h>],
 418         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 419 if test $gtk_ok = yes; then
 420     AC_MSG_RESULT([yes, found in sys/types.h])
 421 else
 422     AC_HEADER_EGREP(fd_set, sys/select.h, gtk_ok=yes)
 423     if test $gtk_ok = yes; then
 424         AC_DEFINE(HAVE_SYS_SELECT_H)
 425         AC_MSG_RESULT([yes, found in sys/select.h])
 426     else
 427         AC_DEFINE(NO_FD_SET)
 428         AC_MSG_RESULT(no)
 429     fi
 430 fi
 431
 432 dnl *** check for sane realloc() ***
 433 AC_MSG_CHECKING(whether realloc (NULL,) will work)
 434 AC_CACHE_VAL(glib_cv_sane_realloc,[
 435         AC_TRY_RUN([
 436         #include <stdlib.h>
 437         int main() {
 438           return realloc (0, sizeof (int)) == 0;
 439         }],
 440         glib_cv_sane_realloc=yes
 441         ,
 442         glib_cv_sane_realloc=no
 443         ,)
 444 ])
 445 if test x$glib_cv_sane_realloc = xyes; then
 446   AC_DEFINE(REALLOC_0_WORKS)
 447 fi
 448 AC_MSG_RESULT($glib_cv_sane_realloc)
 449
 450 dnl Check for nl_langinfo and CODESET
 451
 452 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 453 AC_TRY_COMPILE([#include <langinfo.h>],
 454         [char *codeset = nl_langinfo (CODESET);],
 455    AC_DEFINE(HAVE_CODESET)
 456    have_codeset=yes,
 457    have_codeset=no)
 458 AC_MSG_RESULT($have_codeset)
 459
 460
 461 dnl ****************************************
 462 dnl *** strlcpy/strlcat                  ***
 463 dnl ****************************************
 464 # Check for strlcpy
 465 AC_MSG_CHECKING(for strlcpy/strlcat)
 466 AC_TRY_LINK([#include <stdlib.h>
 467 #include <string.h>], [
 468 char *p = malloc(10);
 469 (void) strlcpy(p, "hi", 10);
 470 (void) strlcat(p, "bye", 10);
 471 ], glib_ok=yes, glib_ok=no)
 472 AC_MSG_RESULT($glib_ok)
 473 if test $glib_ok = yes; then
 474     AC_DEFINE(HAVE_STRLCPY)
 475 fi
 476
 477
 478 dnl **********************
 479 dnl *** va_copy checks ***
 480 dnl **********************
 481 dnl we currently check for all three va_copy possibilities, so we get
 482 dnl all results in config.log for bug reports.
 483 AC_MSG_CHECKING(for an implementation of va_copy())
 484 AC_CACHE_VAL(glib_cv_va_copy,[
 485         AC_TRY_RUN([
 486         #include <stdarg.h>
 487         void f (int i, ...) {
 488         va_list args1, args2;
 489         va_start (args1, i);
 490         va_copy (args2, args1);
 491         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 492           exit (1);
 493         va_end (args1); va_end (args2);
 494         }
 495         int main() {
 496           f (0, 42);
 497           return 0;
 498         }],
 499         glib_cv_va_copy=yes
 500         ,
 501         glib_cv_va_copy=no
 502         ,)
 503 ])
 504 AC_MSG_RESULT($glib_cv_va_copy)
 505 AC_MSG_CHECKING(for an implementation of __va_copy())
 506 AC_CACHE_VAL(glib_cv___va_copy,[
 507         AC_TRY_RUN([
 508         #include <stdarg.h>
 509         void f (int i, ...) {
 510         va_list args1, args2;
 511         va_start (args1, i);
 512         __va_copy (args2, args1);
 513         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 514           exit (1);
 515         va_end (args1); va_end (args2);
 516         }
 517         int main() {
 518           f (0, 42);
 519           return 0;
 520         }],
 521         glib_cv___va_copy=yes
 522         ,
 523         glib_cv___va_copy=no
 524         ,)
 525 ])
 526 AC_MSG_RESULT($glib_cv___va_copy)
 527 AC_MSG_CHECKING(whether va_lists can be copied by value)
 528 AC_CACHE_VAL(glib_cv_va_val_copy,[
 529         AC_TRY_RUN([
 530         #include <stdarg.h>
 531         void f (int i, ...) {
 532         va_list args1, args2;
 533         va_start (args1, i);
 534         args2 = args1;
 535         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 536           exit (1);
 537         va_end (args1); va_end (args2);
 538         }
 539         int main() {
 540           f (0, 42);
 541           return 0;
 542         }],
 543         glib_cv_va_val_copy=yes
 544         ,
 545         glib_cv_va_val_copy=no
 546         ,)
 547 ])
 548 if test "x$glib_cv_va_copy" = "xyes"; then
 549   AC_DEFINE(G_VA_COPY, va_copy)
 550 else if test "x$glib_cv___va_copy" = "xyes"; then
 551   AC_DEFINE(G_VA_COPY, __va_copy)
 552 fi
 553 fi
 554 if test "x$glib_cv_va_val_copy" = "xno"; then
 555   AC_DEFINE(G_VA_COPY_AS_ARRAY)
 556 fi
 557 AC_MSG_RESULT($glib_cv_va_val_copy)
 558
 559
 560 dnl ***********************
 561 dnl *** g_module checks ***
 562 dnl ***********************
 563 G_MODULE_LIBS=
 564 G_MODULE_LIBS_EXTRA=
 565 G_MODULE_PLUGIN_LIBS=
 566 G_MODULE_LDFLAGS=
 567 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 568 G_MODULE_NEED_USCORE=0
 569 G_MODULE_HAVE_DLERROR=0
 570 dnl *** dlopen() and dlsym() in system libraries
 571 if test -z "$G_MODULE_IMPL"; then
 572         AC_CHECK_FUNC(dlopen,
 573                       [AC_CHECK_FUNC(dlsym,
 574                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 575                       [])
 576 fi
 577 dnl *** load_image (BeOS)
 578 if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
 579   AC_CHECK_LIB(root, load_image,
 580       G_MODULE_LIBS="-lbe -lroot -lglib"
 581       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 582       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 583       G_MODULE_IMPL=G_MODULE_IMPL_BEOS
 584 ,)
 585 fi
 586 # *** dlopen() and dlsym() in libdl
 587 if test -z "$G_MODULE_IMPL"; then
 588         AC_CHECK_LIB(dl, dlopen,
 589                      [AC_CHECK_LIB(dl, dlsym,
 590                                    [G_MODULE_LIBS=-ldl
 591                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 592                      [])
 593 fi
 594 dnl *** shl_load() in libdld (HP-UX)
 595 if test -z "$G_MODULE_IMPL"; then
 596         AC_MSG_CHECKING(how to export all symbols)
 597         SAVED_LDFLAGS=$LDFLAGS
 598         LDFLAGS="$LDFLAGS -Wl,-E"
 599         AC_TRY_LINK(,[ return 0; ],
 600                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 601                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 602                 AC_TRY_LINK(,[ return 0; ],
 603                         G_MODULE_LDFLAGS="-bexpall",
 604                         G_MODULE_LDFLAGS="none"
 605                 )
 606         ])
 607         LDFLAGS=$SAVED_LDFLAGS
 608         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 609         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 610                 G_MODULE_LDFLAGS=
 611         fi
 612         AC_CHECK_LIB(dld, shl_load,
 613                 G_MODULE_LIBS=-ldld
 614                 G_MODULE_IMPL=G_MODULE_IMPL_DLD
 615         ,)
 616 fi
 617 dnl *** additional checks for G_MODULE_IMPL_DL
 618 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 619         case "$host_os" in
 620           linux*)
 621             G_MODULE_LDFLAGS='-rdynamic'
 622             ;;
 623         esac
 624         LIBS_orig="$LIBS"
 625         LDFLAGS_orig="$LDFLAGS"
 626         LIBS="$LIBS $G_MODULE_LIBS"
 627         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 628 dnl *** check whether we need preceeding underscores
 629         AC_MSG_CHECKING(for preceeding underscore in symbols)
 630         AC_CACHE_VAL(glib_cv_uscore,[
 631                 AC_TRY_RUN([
 632                 #include <dlfcn.h>
 633                 int glib_underscore_test (void) { return 42; }
 634                 int main() {
 635                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 636                   handle = dlopen ((void*)0, 0);
 637                   if (handle) {
 638                     f1 = dlsym (handle, "glib_underscore_test");
 639                     f2 = dlsym (handle, "_glib_underscore_test");
 640                   } return (!f2 || f1);
 641                 }],
 642                         glib_cv_uscore=yes,
 643                         glib_cv_uscore=no,
 644                 )
 645                 rm -f plugin.c plugin.o plugin.lo
 646         ])
 647         AC_MSG_RESULT($glib_cv_uscore)
 648         if test "x$glib_cv_uscore" = "xyes"; then
 649                 G_MODULE_NEED_USCORE=1
 650         else
 651                 G_MODULE_NEED_USCORE=0
 652         fi
 653
 654         LDFLAGS="$LDFLAGS_orig"
 655 dnl *** check for having dlerror()
 656         AC_CHECK_FUNC(dlerror,
 657                 G_MODULE_HAVE_DLERROR=1,
 658                 G_MODULE_HAVE_DLERROR=0)
 659         LIBS="$LIBS_orig"
 660 fi
 661 dnl *** done, have e got an implementation?
 662 if test -z "$G_MODULE_IMPL"; then
 663         G_MODULE_IMPL=0
 664 fi
 665 AC_SUBST(G_MODULE_IMPL)
 666 AC_SUBST(G_MODULE_LIBS)
 667 AC_SUBST(G_MODULE_LIBS_EXTRA)
 668 AC_SUBST(G_MODULE_PLUGIN_LIBS)
 669 AC_SUBST(G_MODULE_LDFLAGS)
 670 AC_SUBST(G_MODULE_HAVE_DLERROR)
 671 AC_SUBST(G_MODULE_NEED_USCORE)
 672 AC_SUBST(GLIB_DEBUG_FLAGS)
 673
 674
 675 dnl ***********************
 676 dnl *** g_thread checks ***
 677 dnl ***********************
 678
 679 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
 680         if test "x$with_threads" = x; then
 681                 want_threads=yes
 682         else
 683                 want_threads=$with_threads
 684         fi,
 685         want_threads=yes)
 686 if test "x$enable_threads" = "xno"; then
 687         want_threads=no
 688 fi
 689 if test "x$want_threads" = "xnone"; then
 690         want_threads=no
 691 fi
 692
 693 dnl error and warning message
 694 dnl *************************
 695
 696 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
 697                 computer. GLib will not have a default thread implementation."
 698
 699 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
 700                 platform (normaly it's "_REENTRANT"). I'll not use any flag on
 701                 compilation now, but then your programs might not work.
 702                 Please provide information on how it is done on your system."
 703
 704 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
 705                 "
 706
 707 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
 708                 provide information on your thread implementation.
 709                 You can also run 'configure --disable-threads'
 710                 to compile without thread support."
 711
 712 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
 713                 functions will not be MT-safe during their first call because
 714                 there is no working 'getpwuid_r' on your system."
 715
 716 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
 717                 because there is no 'localtime_r' on your system."
 718
 719 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
 720                 crude surrogate will be used. If you happen to know a
 721                 yield function for your system, please inform the GLib
 722                 developers."
 723
 724 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
 725                 threads on your system. Thus threads can only have the default
 726                 priority. If you happen to know these main/max
 727                 priorities, please inform the GLib developers."
 728
 729
 730 dnl determination of thread implementation
 731 dnl ***************************************
 732
 733 have_threads=none
 734 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
 735         case $host in
 736                 *-*-solaris*)
 737                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
 738                 ;;
 739         esac
 740 fi
 741 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
 742                                 || test "x$want_threads" = xdce; then
 743         # -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
 744         # -U_OSF_SOURCE is for Digital UNIX 4.0d
 745         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
 746         glib_save_CPPFLAGS="$CPPFLAGS"
 747         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 748         if test "x$have_threads" = xnone; then
 749                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_init[^a-zA-Z_]],
 750                         pthread.h,
 751                         have_threads=posix)
 752         fi
 753         if test "x$have_threads" = xnone; then
 754                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_create[^a-zA-Z_]],
 755                         pthread.h,
 756                         have_threads=dce)
 757         fi
 758         CPPFLAGS="$glib_save_CPPFLAGS"
 759 fi
 760
 761 AC_MSG_CHECKING(for thread implementation)
 762
 763 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
 764         AC_MSG_RESULT(none available)
 765         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
 766 else
 767         AC_MSG_RESULT($have_threads)
 768 fi
 769
 770
 771 dnl determination of G_THREAD_CFLAGS
 772 dnl ********************************
 773
 774 G_THREAD_LIBS=
 775 G_THREAD_LIBS_EXTRA=
 776 G_THREAD_CFLAGS=
 777
 778 if test x"$have_threads" != xnone; then
 779
 780     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
 781
 782     case $host in
 783         *-aix*)
 784                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 785                 if test x"$GCC" = xyes; then
 786                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
 787                 fi
 788                 ;;
 789         *-freebsd2.2*)
 790                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 791
 792                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
 793                 # -mthreads flag.
 794                 ;;
 795         *-sysv5uw7*)  # UnixWare 7
 796                 if test "$GCC" != "yes"; then
 797                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
 798                 else
 799                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
 800                 fi
 801                 ;;
 802     esac
 803
 804     # if we are not finding the ctime_r function, then we probably are
 805     # not using the proper multithread flag
 806
 807     glib_save_CPPFLAGS="$CPPFLAGS"
 808     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
 809
 810     # Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc.
 811     AC_EGREP_HEADER([[^a-zA-Z_](_P)?ctime_r[^a-zA-Z_]], time.h, ,
 812         AC_MSG_WARN($FLAG_DOES_NOT_WORK))
 813
 814     CPPFLAGS="$glib_save_CPPFLAGS"
 815
 816     AC_MSG_CHECKING(thread related cflags)
 817     AC_MSG_RESULT($G_THREAD_CFLAGS)
 818     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
 819 fi
 820
 821 dnl determination of G_THREAD_LIBS
 822 dnl ******************************
 823
 824 mutex_has_default=no
 825 case $have_threads in
 826         posix|dce)
 827            G_THREAD_LIBS=error
 828            glib_save_LIBS="$LIBS"
 829            case $host in
 830              *-sysv5uw7*) # UnixWare 7
 831                 if test "$GCC" != "yes"; then
 832                         G_THREAD_LIBS="-Kthread"
 833                 else
 834                         G_THREAD_LIBS="-pthread"
 835                 fi
 836                 ;;
 837              *)
 838                 for thread_lib in "" pthread pthreads c_r thread dce; do
 839                         if test x"$thread_lib" = x; then
 840                                 add_thread_lib=""
 841                                 IN=""
 842                         else
 843                                 add_thread_lib="-l$thread_lib"
 844                                 IN=" in -l$thread_lib"
 845                         fi
 846                         if test x"$have_threads" = xposix; then
 847                                 defattr=NULL
 848                         else
 849                                 defattr=pthread_attr_default
 850                         fi
 851
 852                         LIBS="$glib_save_LIBS $add_thread_lib"
 853
 854                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
 855                         AC_TRY_RUN([#include <pthread.h>
 856                                 int check_me = 0;
 857                                 void* func(void* data) {check_me = 42;}
 858                                 main()
 859                                 { pthread_t t;
 860                                   void *ret;
 861                                   pthread_create (&t, $defattr, func, NULL);
 862                                   pthread_join (t, &ret);
 863                                   exit (check_me != 42);
 864                                 }],
 865                                 [AC_MSG_RESULT(yes)
 866                                 G_THREAD_LIBS="$add_thread_lib"
 867                                 break],
 868                                 [AC_MSG_RESULT(no)])
 869                 done
 870                 if test "x$G_THREAD_LIBS" = xerror; then
 871                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
 872                 fi
 873                 for thread_lib in "" rt; do
 874                         if test x"$thread_lib" = x; then
 875                                 add_thread_lib=""
 876                                 IN=""
 877                         else
 878                                 add_thread_lib="-l$thread_lib"
 879                                 IN=" in -l$thread_lib"
 880                         fi
 881                         LIBS="$glib_save_LIBS $add_thread_lib"
 882
 883                         AC_MSG_CHECKING(for sched_get_priority_min$IN)
 884                         AC_TRY_RUN([#include <sched.h>
 885                                 #include <errno.h>
 886                                 int main() {
 887                                 errno = 0;
 888                                 return sched_get_priority_min(SCHED_OTHER)==-1
 889                                         && errno != 0;
 890                                 }],
 891                                 [AC_MSG_RESULT(yes)
 892                                 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
 893                                 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
 894                                 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
 895                                 break],
 896                                 [AC_MSG_RESULT(no)])
 897                 done
 898                 LIBS="$glib_save_LIBS"
 899                 ;;
 900            esac
 901            mutex_has_default=yes
 902            mutex_default_type='pthread_mutex_t'
 903            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
 904            mutex_header_file='pthread.h'
 905            if test "x$have_threads" = "xposix"; then
 906              g_threads_impl="POSIX"
 907            else
 908              g_threads_impl="DCE"
 909              have_threads="posix"
 910            fi
 911            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
 912            ;;
 913         solaris)
 914            G_THREAD_LIBS=error
 915            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
 916            mutex_has_default=yes
 917            mutex_default_type='mutex_t'
 918            mutex_default_init="DEFAULTMUTEX"
 919            mutex_header_file='thread.h'
 920            g_threads_impl="SOLARIS"
 921            ;;
 922         none)
 923            g_threads_impl="NONE"
 924            ;;
 925         *)
 926            g_threads_impl="NONE"
 927            G_THREAD_LIBS=error
 928            ;;
 929 esac
 930
 931 if test "x$G_THREAD_LIBS" = xerror; then
 932         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
 933 fi
 934
 935 case $host in
 936   *-*-beos*)
 937     G_THREAD_LIBS="-lbe -lroot -lglib "
 938     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 939     ;;
 940   *)
 941     ;;
 942 esac
 943
 944 AC_MSG_CHECKING(thread related libraries)
 945 AC_MSG_RESULT($G_THREAD_LIBS)
 946
 947 dnl check for mt safe function variants and some posix functions
 948 dnl ************************************************************
 949
 950 if test x"$have_threads" != xnone; then
 951         glib_save_LIBS="$LIBS"
 952         # we are not doing the following for now, as this might require glib
 953         # to always be linked with the thread libs on some platforms.
 954         # LIBS="$LIBS $G_THREAD_LIBS"
 955         AC_CHECK_FUNCS(localtime_r)
 956         if test "$ac_cv_header_pwd_h" = "yes"; then
 957                 AC_MSG_CHECKING([for getpwuid_r])
 958                 AC_CACHE_VAL(ac_cv_func_getpwuid_r,
 959                         [AC_TRY_RUN([#include <errno.h>
 960                                 int main () { char buffer[10000], *pointer;
 961                                 char getpwuid_r (long, void*, void*,
 962                                         int, void*);
 963                                 int error;
 964                                 errno = 0;
 965                                 error = getpwuid_r (0, &buffer, &buffer,
 966                                         sizeof (buffer), &pointer);
 967                                 return errno == ENOSYS || error == ENOSYS;}],
 968                                 [ac_cv_func_getpwuid_r=yes],
 969                                 [ac_cv_func_getpwuid_r=no])])
 970                 if test "$ac_cv_func_getpwuid_r" = yes; then
 971                         AC_MSG_RESULT(yes)
 972                         AC_DEFINE(HAVE_GETPWUID_R)
 973                 else
 974                         AC_MSG_RESULT(no)
 975                 fi
 976                 if test "$ac_cv_func_getpwuid_r" = "yes"; then
 977                         AC_MSG_CHECKING(whether getpwuid_r is posix like)
 978                         # The signature for the POSIX version is:
 979                         # int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **)
 980                         AC_TRY_COMPILE([#include <pwd.h>
 981                                 #include <sys/types.h>
 982                                 #include <stdlib.h>],
 983                                 [getpwuid_r((uid_t)0, NULL, NULL, (size_t)0, NULL);],
 984                                 [AC_DEFINE(HAVE_GETPWUID_R_POSIX)
 985                                 AC_MSG_RESULT(yes)],
 986                                 [AC_MSG_RESULT(no)])
 987                 fi
 988         fi
 989         LIBS="$LIBS $G_THREAD_LIBS"
 990         if test x"$have_threads" = xposix; then
 991                 glib_save_CPPFLAGS="$CPPFLAGS"
 992                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 993                 GLIB_SIZEOF([#include <pthread.h>],
 994                         pthread_t,
 995                         system_thread)
 996                 # This is not AC_CHECK_FUNC to also work with function
 997                 # name mangling in header files.
 998                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
 999                 AC_TRY_LINK([#include <pthread.h>],
1000                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1001                         [AC_MSG_RESULT(yes)
1002                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)],
1003                         [AC_MSG_RESULT(no)])
1004                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1005                 if test x"$posix_priority_min" = xnone; then
1006                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1007                                 PX_PRIO_MIN],,[
1008                                 posix_priority_min=PX_PRIO_MIN
1009                                 posix_priority_max=PX_PRIO_MAX])
1010                 fi
1011                 if test x"$posix_priority_min" = xnone; then
1012                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1013                                 PRI_OTHER_MIN],,[
1014                                 posix_priority_min=PRI_OTHER_MIN
1015                                 posix_priority_max=PRI_OTHER_MAX])
1016                 fi
1017                 if test x"$posix_priority_min" = x; then
1018                         AC_MSG_RESULT(none found)
1019                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1020                         posix_priority_min=-1
1021                         posix_priority_max=-1
1022                 else
1023                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1024                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min)
1025                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max)
1026                 fi
1027                 posix_yield_func=none
1028                 AC_MSG_CHECKING(for posix yield function)
1029                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1030                                                         thr_yield; do
1031                         AC_TRY_LINK([#include <pthread.h>],
1032                                 [$yield_func()],
1033                                 [posix_yield_func="$yield_func"
1034                                 break])
1035                 done
1036                 if test x"$posix_yield_func" = xnone; then
1037                         AC_MSG_RESULT(none found)
1038                         AC_MSG_WARN($POSIX_NO_YIELD)
1039                         posix_yield_func="g_usleep(1000)"
1040                 else
1041                         AC_MSG_RESULT($posix_yield_func)
1042                         posix_yield_func="$posix_yield_func()"
1043                 fi
1044                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func)
1045                 CPPFLAGS="$glib_save_CPPFLAGS"
1046         else # solaris threads
1047                 GLIB_SIZEOF([#include <thread.h>],
1048                         thread_t,
1049                         system_thread)
1050         fi
1051
1052         LIBS="$glib_save_LIBS"
1053
1054         # now spit out all the warnings.
1055         if test "$ac_cv_func_getpwuid_r" != "yes"; then
1056                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1057         fi
1058         if test "$ac_cv_func_localtime_r" != "yes"; then
1059                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1060         fi
1061 else
1062         # If no thread implementation exists, we will provide enough
1063         # space for a pointer
1064         GLIB_SIZEOF(, void*, system_thread)
1065 fi
1066
1067 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
1068 AC_SUBST(G_THREAD_CFLAGS)
1069 AC_SUBST(G_THREAD_LIBS)
1070 AC_SUBST(G_THREAD_LIBS_EXTRA)
1071
1072 dnl **********************************************
1073 dnl *** GDefaultMutex setup and initialization ***
1074 dnl **********************************************
1075 dnl
1076 dnl if mutex_has_default = yes, we also got
1077 dnl mutex_default_type, mutex_default_init and mutex_header_file
1078 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1079         glib_save_CPPFLAGS="$CPPFLAGS"
1080         glib_save_LIBS="$LIBS"
1081         LIBS="$LIBS $G_THREAD_LIBS"
1082         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1083         GLIB_SIZEOF([#include <$mutex_header_file>],
1084                     $mutex_default_type,
1085                     gmutex,
1086                     )
1087         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1088                            $mutex_default_type,
1089                            gmutex,
1090                            $glib_cv_sizeof_gmutex,
1091                            $mutex_default_init)
1092         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1093                 mutex_has_default=no
1094         fi
1095         CPPFLAGS="$glib_save_CPPFLAGS"
1096         LIBS="$glib_save_LIBS"
1097         ,
1098 )
1099
1100
1101 dnl ****************************************
1102 dnl *** GLib POLL* compatibility defines ***
1103 dnl ****************************************
1104 GLIB_SYSDEFS(
1105 [#include <sys/types.h>
1106 #include <sys/poll.h>],
1107         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1108         glibconfig-sysdefs.h,
1109         =)
1110
1111 dnl **************************
1112 dnl *** Checks for gtk-doc ***
1113 dnl **************************
1114
1115 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH path to installed docs ])
1116
1117 if test "x$with_html_dir" = "x" ; then
1118   HTML_DIR='${datadir}/gtk-doc/html'
1119 else
1120   HTML_DIR=$with_html_dir
1121 fi
1122
1123 AC_SUBST(HTML_DIR)
1124
1125
1126 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1127 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1128 AC_SUBST(HAVE_GTK_DOC)
1129
1130 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1131 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1132
1133 dnl Let people disable the gtk-doc stuff.
1134 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc  Use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)
1135
1136 if test x$enable_gtk_doc = xauto ; then
1137   if test x$GTKDOC = xtrue ; then
1138     enable_gtk_doc=yes
1139   else
1140     enable_gtk_doc=no
1141   fi
1142 fi
1143
1144 dnl NOTE: We need to use a separate automake conditional for this
1145 dnl       to make this work with the tarballs.
1146 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1147
1148 dnl ******************************
1149 dnl *** output the whole stuff ***
1150 dnl ******************************
1151
1152 AC_OUTPUT_COMMANDS([
1153
1154 ## Generate `glibconfig.h' in two cases
1155 ## 1. `config.status' is run either explicitly, or via configure.
1156 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1157 ##     config.h
1158 ## 2. CONFIG_OTHER is set explicitly
1159 ##
1160 ## Case 1 is difficult.  We know that `automake' sets one of
1161 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1162 ## only when AM_CONFIG_HEADER is set, however.
1163
1164 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1165   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1166   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1167 fi
1168 case "$CONFIG_OTHER" in
1169 *glibconfig.h*)
1170         echo creating glibconfig.h
1171         outfile=glibconfig.h-tmp
1172         cat > $outfile <<\_______EOF
1173 /* glibconfig.h
1174  *
1175  * This is a generated file.  Please modify 'configure.in'
1176  */
1177
1178 #ifndef __G_LIBCONFIG_H__
1179 #define __G_LIBCONFIG_H__
1180
1181 #include <gmacros.h>
1182
1183 _______EOF
1184
1185         if test x$glib_limits_h = xyes; then
1186           echo '#include <limits.h>' >> $outfile
1187         fi
1188         if test x$glib_float_h = xyes; then
1189           echo '#include <float.h>' >> $outfile
1190         fi
1191         if test x$glib_values_h = xyes; then
1192           echo '#include <values.h>' >> $outfile
1193         fi
1194         if test "$glib_header_alloca_h" = "yes"; then
1195           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1196         fi
1197         if test x$glib_sys_poll_h = xyes; then
1198           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1199         fi
1200
1201         cat >> $outfile <<_______EOF
1202
1203 G_BEGIN_DECLS
1204
1205 #define G_MINFLOAT      $glib_mf
1206 #define G_MAXFLOAT      $glib_Mf
1207 #define G_MINDOUBLE     $glib_md
1208 #define G_MAXDOUBLE     $glib_Md
1209 #define G_MINSHORT      $glib_ms
1210 #define G_MAXSHORT      $glib_Ms
1211 #define G_MAXUSHORT     $glib_Mus
1212 #define G_MININT        $glib_mi
1213 #define G_MAXINT        $glib_Mi
1214 #define G_MAXUINT       $glib_Mui
1215 #define G_MINLONG       $glib_ml
1216 #define G_MAXLONG       $glib_Ml
1217 #define G_MAXULONG      $glib_Mul
1218
1219 _______EOF
1220
1221
1222         ### this should always be true in a modern C/C++ compiler
1223         cat >>$outfile <<_______EOF
1224 typedef signed char gint8;
1225 typedef unsigned char guint8;
1226 _______EOF
1227
1228
1229         if test -n "$gint16"; then
1230           cat >>$outfile <<_______EOF
1231 typedef signed $gint16 gint16;
1232 typedef unsigned $gint16 guint16;
1233 #define G_GINT16_FORMAT $gint16_format
1234 #define G_GUINT16_FORMAT $guint16_format
1235 _______EOF
1236         fi
1237
1238
1239         if test -n "$gint32"; then
1240           cat >>$outfile <<_______EOF
1241 typedef signed $gint32 gint32;
1242 typedef unsigned $gint32 guint32;
1243 #define G_GINT32_FORMAT $gint32_format
1244 #define G_GUINT32_FORMAT $guint32_format
1245 _______EOF
1246         fi
1247
1248
1249         if test -n "$gint64"; then
1250           cat >>$outfile <<_______EOF
1251 #define G_HAVE_GINT64 1
1252
1253 ${glib_extension}typedef signed $gint64 gint64;
1254 ${glib_extension}typedef unsigned $gint64 guint64;
1255
1256 #define G_GINT64_CONSTANT(val)  $gint64_constant
1257 _______EOF
1258                 if test -n "$gint64_format"; then
1259           cat >>$outfile <<_______EOF
1260 #define G_GINT64_FORMAT $gint64_format
1261 #define G_GUINT64_FORMAT $guint64_format
1262 _______EOF
1263                 fi
1264         fi
1265
1266         case x$glib_size_t in
1267         x2) echo "typedef gint16  gssize;" >> $outfile
1268             echo "typedef guint16 gsize;"  >> $outfile
1269             ;;
1270         x4) echo "typedef gint32  gssize;" >> $outfile
1271             echo "typedef guint32 gsize;"  >> $outfile
1272             ;;
1273         x8) echo "typedef gint64  gssize;" >> $outfile
1274             echo "typedef guint64 gsize;"  >> $outfile
1275             ;;
1276         *)  echo "#error size of size_t is unknown" >> $outfile
1277             ;;
1278         esac
1279
1280         if test -z "$glib_unknown_void_p"; then
1281           cat >>$outfile <<_______EOF
1282
1283 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1284 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1285
1286 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1287 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1288 _______EOF
1289         else
1290           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1291         fi
1292
1293
1294
1295         cat >>$outfile <<_______EOF
1296 $glib_atexit
1297 $glib_memmove
1298 $glib_defines
1299 $glib_os
1300
1301 $glib_vacopy
1302
1303 #ifdef  __cplusplus
1304 #define G_HAVE_INLINE   1
1305 #else   /* !__cplusplus */
1306 $glib_inline
1307 #endif  /* !__cplusplus */
1308 _______EOF
1309
1310         echo >>$outfile
1311         if test x$g_mutex_has_default = xyes; then
1312                 cat >>$outfile <<_______EOF
1313 $g_enable_threads_def G_THREADS_ENABLED
1314 #define G_THREADS_IMPL_$g_threads_impl_def
1315 typedef struct _GStaticMutex GStaticMutex;
1316 struct _GStaticMutex
1317 {
1318   struct _GMutex *runtime_mutex;
1319   struct {
1320     union {
1321       char   pad[$g_mutex_sizeof];
1322       double dummy_double;
1323       void  *dummy_pointer;
1324       long   dummy_long;
1325     } mutex;
1326     void *debug_info;
1327   } static_mutex;
1328 };
1329 #define G_STATIC_MUTEX_INIT     { NULL, { { { $g_mutex_contents} }, NULL } }
1330 #define g_static_mutex_get_mutex(mutex) \
1331   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1332    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1333 _______EOF
1334         else
1335                 cat >>$outfile <<_______EOF
1336 $g_enable_threads_def G_THREADS_ENABLED
1337 #define G_THREADS_IMPL_$g_threads_impl_def
1338 typedef struct _GMutex* GStaticMutex;
1339 #define G_STATIC_MUTEX_INIT NULL
1340 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1341 _______EOF
1342         fi
1343
1344         cat >>$outfile <<_______EOF
1345 /* This represents a system thread as used by the implementation. An
1346  * alien implementaion, as loaded by g_thread_init can only count on
1347  * "sizeof (gpointer)" bytes to store their info. We however need more
1348  * for some of our native implementations. */
1349 typedef union _GSystemThread GSystemThread;
1350 union _GSystemThread
1351 {
1352   char   data[$g_system_thread_sizeof];
1353   double dummy_double;
1354   void  *dummy_pointer;
1355   long   dummy_long;
1356 };
1357 _______EOF
1358
1359         echo >>$outfile
1360         g_bit_sizes="16 32"
1361         if test -n "$gint64"; then
1362           g_bit_sizes="$g_bit_sizes 64"
1363         fi
1364         for bits in $g_bit_sizes; do
1365           cat >>$outfile <<_______EOF
1366 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1367 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1368 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1369 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1370 _______EOF
1371         done
1372
1373         cat >>$outfile <<_______EOF
1374 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1375 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1376 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1377 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1378 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1379 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1380 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1381 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1382 #define G_BYTE_ORDER $g_byte_order
1383
1384 _______EOF
1385
1386         if test -r glibconfig-sysdefs.h; then
1387           cat glibconfig-sysdefs.h >>$outfile
1388         fi
1389
1390         cat >>$outfile <<_______EOF
1391
1392 G_END_DECLS
1393
1394 #endif /* GLIBCONFIG_H */
1395 _______EOF
1396
1397
1398         if cmp -s $outfile glibconfig.h; then
1399           echo glibconfig.h is unchanged
1400           rm -f $outfile
1401         else
1402           mv $outfile glibconfig.h
1403         fi ;;
1404 esac
1405 ],[
1406
1407 # Note that if two cases are the same, case goes with the first one.
1408 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1409 # on variable expansion in case labels.  Look at the generated config.status
1410 # for a hint.
1411
1412 glib_header_alloca_h="$ac_cv_header_alloca_h"
1413
1414 case xyes in
1415 x$ac_cv_header_float_h)
1416   glib_float_h=yes
1417   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1418   glib_md=DBL_MIN glib_Md=DBL_MAX
1419   ;;
1420 x$ac_cv_header_values_h)
1421   glib_values_h=yes
1422   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1423   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1424   ;;
1425 esac
1426
1427 case xyes in
1428 x$ac_cv_header_limits_h)
1429   glib_limits_h=yes
1430   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1431   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1432   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1433   ;;
1434 x$ac_cv_header_values_h)
1435   glib_values_h=yes
1436   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1437   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1438   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1439   ;;
1440 esac
1441
1442 if test x$ac_cv_header_sys_poll_h = xyes ; then
1443   glib_sys_poll_h=yes
1444 fi
1445
1446 case 2 in
1447 $ac_cv_sizeof_short)
1448   gint16=short
1449   gint16_format='"hi"'
1450   guint16_format='"hu"'
1451   ;;
1452 $ac_cv_sizeof_int)
1453   gint16=int
1454   gint16_format='"i"'
1455   guint16_format='"u"'
1456   ;;
1457 esac
1458 case 4 in
1459 $ac_cv_sizeof_short)
1460   gint32=short
1461   gint32_format='"hi"'
1462   guint32_format='"hu"'
1463   ;;
1464 $ac_cv_sizeof_int)
1465   gint32=int
1466   gint32_format='"i"'
1467   guint32_format='"u"'
1468   ;;
1469 $ac_cv_sizeof_long)
1470   gint32=long
1471   gint32_format='"li"'
1472   guint32_format='"lu"'
1473   ;;
1474 esac
1475 case 8 in
1476 $ac_cv_sizeof_int)
1477   gint64=int
1478   gint64_format='"i"'
1479   guint64_format='"u"'
1480   glib_extension=
1481   gint64_constant='(val)'
1482   ;;
1483 $ac_cv_sizeof_long)
1484   gint64=long
1485   gint64_format='"li"'
1486   guint64_format='"lu"'
1487   glib_extension=
1488   gint64_constant='(val##L)'
1489   ;;
1490 $ac_cv_sizeof_long_long)
1491   gint64='long long'
1492   if test -n "$glib_cv_long_long_format"; then
1493     gint64_format='"'$glib_cv_long_long_format'i"'
1494     guint64_format='"'$glib_cv_long_long_format'u"'
1495   fi
1496   glib_extension='G_GNUC_EXTENSION '
1497   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1498   ;;
1499 esac
1500 glib_size_t=$glib_cv_sizeof_size_t
1501
1502 gintbits=`expr $ac_cv_sizeof_int \* 8`
1503 glongbits=`expr $ac_cv_sizeof_long \* 8`
1504
1505
1506 case $ac_cv_sizeof_void_p in
1507 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
1508 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
1509 *)                      glib_unknown_void_p=yes ;;
1510 esac
1511
1512
1513 case xyes in
1514 x$ac_cv_func_atexit)
1515   glib_atexit="
1516 #ifdef NeXT /* @#%@! NeXTStep */
1517 # define g_ATEXIT(proc) (!atexit (proc))
1518 #else
1519 # define g_ATEXIT(proc) (atexit (proc))
1520 #endif"
1521   ;;
1522 x$ac_cv_func_on_exit)
1523   glib_atexit="
1524 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
1525   ;;
1526 esac
1527
1528 case xyes in
1529 x$ac_cv_func_memmove)
1530   glib_memmove='
1531 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
1532   ;;
1533 x$glib_cv_working_bcopy)
1534   glib_memmove="
1535 /* memmove isn't available, but bcopy can copy overlapping memory regions */
1536 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
1537   ;;
1538 *)
1539   glib_memmove="
1540 /* memmove isn't found and bcopy can't copy overlapping memory regions,
1541  * so we have to roll our own copy routine. */
1542 void g_memmove (void* dest, const void * src, unsigned long len);"
1543   ;;
1544 esac
1545
1546 glib_defines="
1547 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
1548 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
1549 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
1550 "
1551
1552 case xyes in
1553 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
1554 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
1555 *)                      glib_vacopy=''
1556 esac
1557
1558 if test x$glib_cv_va_val_copy = xno; then
1559   glib_vacopy="\$glib_vacopy
1560 #define G_VA_COPY_AS_ARRAY 1"
1561 fi
1562
1563 if test x$glib_cv_hasinline = xyes; then
1564     glib_inline='#define G_HAVE_INLINE 1'
1565 fi
1566 if test x$glib_cv_has__inline = xyes; then
1567     glib_inline="\$glib_inline
1568 #define G_HAVE___INLINE 1"
1569 fi
1570 if test x$glib_cv_has__inline__ = xyes; then
1571     glib_inline="\$glib_inline
1572 #define G_HAVE___INLINE__ 1"
1573 fi
1574
1575 case xyes in
1576 x$ac_cv_c_bigendian)
1577   g_byte_order=G_BIG_ENDIAN
1578   g_bs_native=BE
1579   g_bs_alien=LE
1580   ;;
1581 *)
1582   g_byte_order=G_LITTLE_ENDIAN
1583   g_bs_native=LE
1584   g_bs_alien=BE
1585   ;;
1586 esac
1587
1588 case x$have_threads in
1589 xnone)  g_enable_threads_def="#undef";;
1590 *)      g_enable_threads_def="#define";;
1591 esac
1592
1593 g_threads_impl_def=$g_threads_impl
1594
1595 g_mutex_has_default="$mutex_has_default"
1596 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
1597 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
1598 g_mutex_contents="$glib_cv_byte_contents_gmutex"
1599
1600 case $host in
1601   *-*-beos*)
1602     glib_os="#define G_OS_BEOS"
1603     ;;
1604   *-*-cygwin*)
1605     glib_os="#define G_OS_UNIX
1606 #define G_WITH_CYGWIN"
1607 v    ;;
1608   *)
1609     glib_os="#define G_OS_UNIX"
1610     ;;
1611 esac
1612 ])
1613
1614 AC_OUTPUT([
1615 glib-2.0.pc
1616 gmodule-2.0.pc
1617 gthread-2.0.pc
1618 gobject-2.0.pc
1619 glib.spec
1620 Makefile
1621 glib-config-2.0
1622 build/Makefile
1623 build/win32/Makefile
1624 gmodule/gmoduleconf.h
1625 gmodule/Makefile
1626 gobject/Makefile
1627 gthread/Makefile
1628 docs/Makefile
1629 docs/glib-config.1
1630 docs/reference/Makefile
1631 docs/reference/glib/Makefile
1632 docs/reference/gobject/Makefile
1633 tests/Makefile
1634 ],[case "$CONFIG_FILES" in
1635 *glib-config-2.0*)chmod +x glib-config-2.0;;
1636 esac
1637 echo ""
1638 echo " *** IMPORTANT *** "
1639 echo ""
1640 echo "This is a development version of GLib.  You should be using a stable"
1641 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
1642 echo "version you just configured is meant for developers of GLib only:"
1643 echo ""
1644 echo "  * You should not base stable software on this version of GLib."
1645 echo "  * GNOME developers should use a stable version of GLib."
1646 echo ""
1647 echo "If you install this version of GLib, we strongly recommend that you"
1648 echo "install it in a different prefix than GLib 1.2.  Use --prefix as an"
1649 echo "argument to configure to do this.  Otherwise, you will not be able to"
1650 echo "do development with GLib 1.2 any longer."
1651 echo ""
1652 echo " *** You should be using GLib 1.2 instead. ***"
1653 ])
1654