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