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 <ctype.h>
 341 #include <string.h>
 342 "]
 343 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 344   size_includes=["$size_includes
 345 #include <stdint.h>
 346 "]
 347 fi
 348 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 349   size_includes=["$size_includes
 350 #include <unistd.h>
 351 "]
 352 fi
 353 GLIB_SIZEOF([$size_includes], size_t, size_t)
 354 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 355 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 356
 357 # Check for some functions
 358 AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll)
 359
 360 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 361 # The check is borrowed from the PERL Configure script.
 362 if test "$ac_cv_func_memmove" != "yes"; then
 363   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 364     glib_cv_working_bcopy,[AC_TRY_RUN([
 365       int main() {
 366         char buf[128], abc[128], *b;
 367         int len, off, align;
 368         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 369         for (align = 7; align >= 0; align--) {
 370           for (len = 36; len; len--) {
 371             b = buf+align; bcopy(abc, b, len);
 372             for (off = 1; off <= len; off++) {
 373               bcopy(b, b+off, len); bcopy(b+off, b, len);
 374                 if (bcmp(b, abc, len)) return(1);
 375             }
 376           }
 377         }
 378         return(0);
 379       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 380   if test "$glib_cv_working_bcopy" == "yes"; then
 381     AC_DEFINE(HAVE_WORKING_BCOPY)
 382   fi
 383 fi
 384
 385 # Check for sys_errlist
 386 AC_MSG_CHECKING(for sys_errlist)
 387 AC_TRY_LINK(, [
 388 extern char *sys_errlist[];
 389 extern int sys_nerr;
 390 sys_errlist[sys_nerr-1][0] = 0;
 391 ], glib_ok=yes, glib_ok=no)
 392 AC_MSG_RESULT($glib_ok)
 393 if test $glib_ok = no; then
 394     AC_DEFINE(NO_SYS_ERRLIST)
 395 fi
 396
 397 # Check for sys_siglist
 398 AC_MSG_CHECKING(for sys_siglist)
 399 AC_TRY_LINK(, [
 400 extern char *sys_siglist[];
 401 exit (sys_siglist[0]);
 402 ], glib_ok=yes, glib_ok=no)
 403 AC_MSG_RESULT($glib_ok)
 404 if test $glib_ok = no; then
 405     AC_DEFINE(NO_SYS_SIGLIST)
 406 fi
 407
 408 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 409 AC_MSG_CHECKING(for sys_siglist declaration)
 410 AC_TRY_COMPILE([#include <signal.h>], [
 411 strlen (sys_siglist[0]);
 412 ], glib_ok=yes, glib_ok=no)
 413 AC_MSG_RESULT($glib_ok)
 414 if test $glib_ok = no; then
 415     AC_DEFINE(NO_SYS_SIGLIST_DECL)
 416 fi
 417
 418 # Check if <sys/select.h> needs to be included for fd_set
 419 AC_MSG_CHECKING([for fd_set])
 420 AC_TRY_COMPILE([#include <sys/types.h>],
 421         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 422 if test $gtk_ok = yes; then
 423     AC_MSG_RESULT([yes, found in sys/types.h])
 424 else
 425     AC_HEADER_EGREP(fd_set, sys/select.h, gtk_ok=yes)
 426     if test $gtk_ok = yes; then
 427         AC_DEFINE(HAVE_SYS_SELECT_H)
 428         AC_MSG_RESULT([yes, found in sys/select.h])
 429     else
 430         AC_DEFINE(NO_FD_SET)
 431         AC_MSG_RESULT(no)
 432     fi
 433 fi
 434
 435 dnl *** check for sane realloc() ***
 436 AC_MSG_CHECKING(whether realloc (NULL,) will work)
 437 AC_CACHE_VAL(glib_cv_sane_realloc,[
 438         AC_TRY_RUN([
 439         #include <stdlib.h>
 440         int main() {
 441           return realloc (0, sizeof (int)) == 0;
 442         }],
 443         glib_cv_sane_realloc=yes
 444         AC_DEFINE(REALLOC_0_WORKS)
 445         ,
 446         glib_cv_sane_realloc=no
 447         ,)
 448 ])
 449 AC_MSG_RESULT($glib_cv_sane_realloc)
 450
 451 dnl Check for nl_langinfo and CODESET
 452
 453 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 454 AC_TRY_COMPILE([#include <langinfo.h>],
 455         [char *codeset = nl_langinfo (CODESET);],
 456    AC_DEFINE(HAVE_CODESET)
 457    have_codeset=yes,
 458    have_codeset=no)
 459
 460 AC_MSG_RESULT($have_codeset)
 461
 462
 463 dnl **********************
 464 dnl *** va_copy checks ***
 465 dnl **********************
 466 dnl we currently check for all three va_copy possibilities, so we get
 467 dnl all results in config.log for bug reports.
 468 AC_MSG_CHECKING(for an implementation of va_copy())
 469 AC_CACHE_VAL(glib_cv_va_copy,[
 470         AC_TRY_RUN([
 471         #include <stdarg.h>
 472         void f (int i, ...) {
 473         va_list args1, args2;
 474         va_start (args1, i);
 475         va_copy (args2, args1);
 476         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 477           exit (1);
 478         va_end (args1); va_end (args2);
 479         }
 480         int main() {
 481           f (0, 42);
 482           return 0;
 483         }],
 484         glib_cv_va_copy=yes
 485         ,
 486         glib_cv_va_copy=no
 487         ,)
 488 ])
 489 AC_MSG_RESULT($glib_cv_va_copy)
 490 AC_MSG_CHECKING(for an implementation of __va_copy())
 491 AC_CACHE_VAL(glib_cv___va_copy,[
 492         AC_TRY_RUN([
 493         #include <stdarg.h>
 494         void f (int i, ...) {
 495         va_list args1, args2;
 496         va_start (args1, i);
 497         __va_copy (args2, args1);
 498         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 499           exit (1);
 500         va_end (args1); va_end (args2);
 501         }
 502         int main() {
 503           f (0, 42);
 504           return 0;
 505         }],
 506         glib_cv___va_copy=yes
 507         ,
 508         glib_cv___va_copy=no
 509         ,)
 510 ])
 511 AC_MSG_RESULT($glib_cv___va_copy)
 512 AC_MSG_CHECKING(whether va_lists can be copied by value)
 513 AC_CACHE_VAL(glib_cv_va_val_copy,[
 514         AC_TRY_RUN([
 515         #include <stdarg.h>
 516         void f (int i, ...) {
 517         va_list args1, args2;
 518         va_start (args1, i);
 519         args2 = args1;
 520         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 521           exit (1);
 522         va_end (args1); va_end (args2);
 523         }
 524         int main() {
 525           f (0, 42);
 526           return 0;
 527         }],
 528         glib_cv_va_val_copy=yes
 529         ,
 530         glib_cv_va_val_copy=no
 531         ,)
 532 ])
 533 if test "x$glib_cv_va_copy" = "xyes"; then
 534   AC_DEFINE(G_VA_COPY, va_copy)
 535 else if test "x$glib_cv___va_copy" = "xyes"; then
 536   AC_DEFINE(G_VA_COPY, __va_copy)
 537 fi
 538 fi
 539 if test "x$glib_cv_va_val_copy" = "xno"; then
 540   AC_DEFINE(G_VA_COPY_AS_ARRAY)
 541 fi
 542 AC_MSG_RESULT($glib_cv_va_val_copy)
 543
 544
 545 dnl ***********************
 546 dnl *** g_module checks ***
 547 dnl ***********************
 548 G_MODULE_LIBS=
 549 G_MODULE_LIBS_EXTRA=
 550 G_MODULE_PLUGIN_LIBS=
 551 G_MODULE_LDFLAGS=
 552 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 553 G_MODULE_NEED_USCORE=0
 554 G_MODULE_HAVE_DLERROR=0
 555 dnl *** dlopen() and dlsym() in system libraries
 556 if test -z "$G_MODULE_IMPL"; then
 557         AC_CHECK_FUNC(dlopen,
 558                 AC_CHECK_FUNC(dlsym,
 559                         G_MODULE_IMPL=G_MODULE_IMPL_DL
 560                 ,)
 561         ,)
 562 fi
 563 dnl *** load_image (BeOS)
 564 if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
 565   AC_CHECK_LIB(root, load_image,
 566       G_MODULE_LIBS="-lbe -lroot -lglib"
 567       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 568       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 569       G_MODULE_IMPL=G_MODULE_IMPL_BEOS
 570 ,)
 571 fi
 572 dnl *** dlopen() and dlsym() in libdl
 573 if test -z "$G_MODULE_IMPL"; then
 574         AC_CHECK_LIB(dl, dlopen,
 575                 AC_CHECK_LIB(dl, dlsym,
 576                         G_MODULE_LIBS=-ldl
 577                         G_MODULE_IMPL=G_MODULE_IMPL_DL
 578                 ,)
 579         ,)
 580 fi
 581 dnl *** shl_load() in libdld (HP-UX)
 582 if test -z "$G_MODULE_IMPL"; then
 583         AC_MSG_CHECKING(how to export all symbols)
 584         SAVED_LDFLAGS=$LDFLAGS
 585         LDFLAGS="$LDFLAGS -Wl,-E"
 586         AC_TRY_LINK(,[ return 0; ],
 587                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 588                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 589                 AC_TRY_LINK(,[ return 0; ],
 590                         G_MODULE_LDFLAGS="-bexpall",
 591                         G_MODULE_LDFLAGS="none"
 592                 )
 593         ])
 594         LDFLAGS=$SAVED_LDFLAGS
 595         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 596         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 597                 G_MODULE_LDFLAGS=
 598         fi
 599         AC_CHECK_LIB(dld, shl_load,
 600                 G_MODULE_LIBS=-ldld
 601                 G_MODULE_IMPL=G_MODULE_IMPL_DLD
 602         ,)
 603 fi
 604 dnl *** additional checks for G_MODULE_IMPL_DL
 605 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 606         case "$host_os" in
 607           linux*)
 608             G_MODULE_LDFLAGS='-rdynamic'
 609             ;;
 610         esac
 611         LIBS_orig="$LIBS"
 612         LDFLAGS_orig="$LDFLAGS"
 613         LIBS="$LIBS $G_MODULE_LIBS"
 614         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 615 dnl *** check whether we need preceeding underscores
 616         AC_MSG_CHECKING(for preceeding underscore in symbols)
 617         AC_CACHE_VAL(glib_cv_uscore,[
 618                 AC_TRY_RUN([
 619                 #include <dlfcn.h>
 620                 int glib_underscore_test (void) { return 42; }
 621                 int main() {
 622                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 623                   handle = dlopen ((void*)0, 0);
 624                   if (handle) {
 625                     f1 = dlsym (handle, "glib_underscore_test");
 626                     f2 = dlsym (handle, "_glib_underscore_test");
 627                   } return (!f2 || f1);
 628                 }],
 629                         glib_cv_uscore=yes,
 630                         glib_cv_uscore=no,
 631                 )
 632                 rm -f plugin.c plugin.o plugin.lo
 633         ])
 634         AC_MSG_RESULT($glib_cv_uscore)
 635         if test "x$glib_cv_uscore" = "xyes"; then
 636                 G_MODULE_NEED_USCORE=1
 637         else
 638                 G_MODULE_NEED_USCORE=0
 639         fi
 640
 641         LDFLAGS="$LDFLAGS_orig"
 642 dnl *** check for having dlerror()
 643         AC_CHECK_FUNC(dlerror,
 644                 G_MODULE_HAVE_DLERROR=1,
 645                 G_MODULE_HAVE_DLERROR=0)
 646         LIBS="$LIBS_orig"
 647 fi
 648 dnl *** done, have e got an implementation?
 649 if test -z "$G_MODULE_IMPL"; then
 650         G_MODULE_IMPL=0
 651 fi
 652 AC_SUBST(G_MODULE_IMPL)
 653 AC_SUBST(G_MODULE_LIBS)
 654 AC_SUBST(G_MODULE_LIBS_EXTRA)
 655 AC_SUBST(G_MODULE_PLUGIN_LIBS)
 656 AC_SUBST(G_MODULE_LDFLAGS)
 657 AC_SUBST(G_MODULE_HAVE_DLERROR)
 658 AC_SUBST(G_MODULE_NEED_USCORE)
 659 AC_SUBST(GLIB_DEBUG_FLAGS)
 660
 661
 662 dnl ***********************
 663 dnl *** g_thread checks ***
 664 dnl ***********************
 665
 666 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
 667         if test "x$with_threads" = x; then
 668                 want_threads=yes
 669         else
 670                 want_threads=$with_threads
 671         fi,
 672         want_threads=yes)
 673 if test "x$enable_threads" = "xno"; then
 674         want_threads=no
 675 fi
 676 if test "x$want_threads" = "xnone"; then
 677         want_threads=no
 678 fi
 679
 680 dnl error and warning message
 681 dnl *************************
 682
 683 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
 684                 computer. GLib will not have a default thread implementation."
 685
 686 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
 687                 platform (normaly it's "_REENTRANT"). I'll not use any flag on
 688                 compilation now, but then your programs might not work.
 689                 Please provide information on how it is done on your system."
 690
 691 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
 692                 "
 693
 694 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
 695                 provide information on your thread implementation.
 696                 You can also run 'configure --disable-threads'
 697                 to compile without thread support."
 698
 699 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
 700                 functions will not be MT-safe during their first call because
 701                 there is no working 'getpwuid_r' on your system."
 702
 703 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
 704                 because there is no 'localtime_r' on your system."
 705
 706 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
 707                 crude surrogate will be used. If you happen to know a
 708                 yield function for your system, please inform the GLib
 709                 developers."
 710
 711 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
 712                 threads on your system. Thus threads can only have the default
 713                 priority. If you happen to know these main/max
 714                 priorities, please inform the GLib developers."
 715
 716
 717 dnl determination of thread implementation
 718 dnl ***************************************
 719
 720 have_threads=none
 721 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
 722         case $host in
 723                 *-*-solaris*)
 724                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
 725                 ;;
 726         esac
 727 fi
 728 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
 729                                 || test "x$want_threads" = xdce; then
 730         # -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
 731         # -U_OSF_SOURCE is for Digital UNIX 4.0d
 732         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
 733         glib_save_CPPFLAGS="$CPPFLAGS"
 734         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 735         if test "x$have_threads" = xnone; then
 736                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_init[^a-zA-Z_]],
 737                         pthread.h,
 738                         have_threads=posix)
 739         fi
 740         if test "x$have_threads" = xnone; then
 741                 AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_create[^a-zA-Z_]],
 742                         pthread.h,
 743                         have_threads=dce)
 744         fi
 745         CPPFLAGS="$glib_save_CPPFLAGS"
 746 fi
 747
 748 AC_MSG_CHECKING(for thread implementation)
 749
 750 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
 751         AC_MSG_RESULT(none available)
 752         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
 753 else
 754         AC_MSG_RESULT($have_threads)
 755 fi
 756
 757
 758 dnl determination of G_THREAD_LIBS
 759 dnl ******************************
 760
 761 G_THREAD_LIBS=
 762 G_THREAD_LIBS_EXTRA=
 763 G_THREAD_CFLAGS=
 764
 765 mutex_has_default=no
 766 case $have_threads in
 767         posix|dce)
 768                 G_THREAD_LIBS=error
 769                 glib_save_LIBS="$LIBS"
 770                 for thread_lib in "" pthread pthreads c_r thread dce; do
 771                         if test x"$thread_lib" = x; then
 772                                 add_thread_lib=""
 773                                 IN=""
 774                         else
 775                                 add_thread_lib="-l$thread_lib"
 776                                 IN=" in -l$thread_lib"
 777                         fi
 778                         if test x"$have_threads" = xposix; then
 779                                 defattr=NULL
 780                         else
 781                                 defattr=pthread_attr_default
 782                         fi
 783
 784                         LIBS="$glib_save_LIBS $add_thread_lib"
 785
 786                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
 787                         AC_TRY_RUN([#include <pthread.h>
 788                                 int check_me = 0;
 789                                 void* func(void* data) {check_me = 42;}
 790                                 main()
 791                                 { pthread_t t;
 792                                   void *ret;
 793                                   pthread_create (&t, $defattr, func, NULL);
 794                                   pthread_join (t, &ret);
 795                                   exit (check_me != 42);
 796                                 }],
 797                                 [AC_MSG_RESULT(yes)
 798                                 G_THREAD_LIBS="$add_thread_lib"
 799                                 break],
 800                                 [AC_MSG_RESULT(no)])
 801                 done
 802                 for thread_lib in "" rt; do
 803                         if test x"$thread_lib" = x; then
 804                                 add_thread_lib=""
 805                                 IN=""
 806                         else
 807                                 add_thread_lib="-l$thread_lib"
 808                                 IN=" in -l$thread_lib"
 809                         fi
 810                         LIBS="$glib_save_LIBS $add_thread_lib"
 811
 812                         AC_MSG_CHECKING(for sched_get_priority_min$IN)
 813                         AC_TRY_RUN([#include <sched.h>
 814                                 #include <errno.h>
 815                                 int main() {
 816                                 errno = 0;
 817                                 return sched_get_priority_min(SCHED_OTHER)==-1
 818                                         && errno != 0;
 819                                 }],
 820                                 [AC_MSG_RESULT(yes)
 821                                 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
 822                                 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
 823                                 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
 824                                 break],
 825                                 [AC_MSG_RESULT(no)])
 826                 done
 827                 LIBS="$glib_save_LIBS"
 828                 mutex_has_default=yes
 829                 mutex_default_type='pthread_mutex_t'
 830                 mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
 831                 mutex_header_file='pthread.h'
 832                 if test "x$have_threads" = "xposix"; then
 833                         g_threads_impl="POSIX"
 834                 else
 835                         g_threads_impl="DCE"
 836                         have_threads="posix"
 837                 fi
 838                 AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
 839                 ;;
 840         solaris)
 841                 G_THREAD_LIBS=error
 842                 AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
 843                 mutex_has_default=yes
 844                 mutex_default_type='mutex_t'
 845                 mutex_default_init="DEFAULTMUTEX"
 846                 mutex_header_file='thread.h'
 847                 g_threads_impl="SOLARIS"
 848                 ;;
 849         none)
 850                 g_threads_impl="NONE"
 851                 ;;
 852         *)
 853                 g_threads_impl="NONE"
 854                 G_THREAD_LIBS=error
 855                 ;;
 856 esac
 857
 858 if test "x$G_THREAD_LIBS" = xerror; then
 859         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
 860 fi
 861
 862 case $host in
 863   *-*-beos*)
 864     G_THREAD_LIBS="-lbe -lroot -lglib "
 865     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 866     ;;
 867   *)
 868     ;;
 869 esac
 870
 871 AC_MSG_CHECKING(thread related libraries)
 872 AC_MSG_RESULT($G_THREAD_LIBS)
 873
 874 dnl determination of G_THREAD_CFLAGS
 875 dnl ********************************
 876
 877 if test x"$enable_threads" = xyes; then
 878
 879     G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_REENTRANT" # good default guess
 880
 881     case $host in
 882         *-aix*)
 883                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 884                 if test x"$GCC" = xyes; then
 885                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
 886                 fi
 887                 ;;
 888         *-freebsd2.2*)
 889                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
 890
 891                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
 892                 # -mthreads flag.
 893                 ;;
 894     esac
 895
 896     # if we are not finding the ctime_r function, then we probably are
 897     # not using the proper multithread flag
 898     old_CPPFLAGS=$CPPFLAGS
 899     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
 900     # Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc.
 901     AC_EGREP_HEADER([[^a-zA-Z_](_P)?ctime_r[^a-zA-Z_]], time.h, ,
 902     G_THREAD_CFLAGS=
 903     AC_MSG_WARN($FLAG_DOES_NOT_WORK))
 904     CPPFLAGS=$old_CPPFLAGS
 905
 906     AC_MSG_CHECKING(thread related cflags)
 907
 908     AC_MSG_RESULT($G_THREAD_CFLAGS)
 909 else
 910     G_THREAD_CFLAGS=
 911 fi
 912
 913 dnl check for mt safe function variants and some posix functions
 914 dnl ************************************************************
 915
 916 if test x"$enable_threads" = xyes; then
 917         glib_save_LIBS="$LIBS"
 918         glib_save_CFLAGS="$CFLAGS"
 919         # we are not doing the following for now, as this might require glib
 920         # to always be linked with the thread libs on some platforms.
 921         # LIBS="$LIBS $G_THREAD_LIBS"
 922         CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
 923         AC_CHECK_FUNCS(localtime_r)
 924         if test "$ac_cv_header_pwd_h" = "yes"; then
 925                 AC_MSG_CHECKING([for getpwuid_r])
 926                 AC_CACHE_VAL(ac_cv_func_getpwuid_r,
 927                         [AC_TRY_RUN([#include <errno.h>
 928                                 int main () { char buffer[10000], *pointer;
 929                                 char getpwuid_r (long, void*, void*,
 930                                         int, void*);
 931                                 errno = 0;
 932                                 getpwuid_r (0, &buffer, &buffer,
 933                                         sizeof (buffer), &pointer);
 934                                 return errno == ENOSYS;}],
 935                                 [ac_cv_func_getpwuid_r=yes],
 936                                 [ac_cv_func_getpwuid_r=no])])
 937                 if test "$ac_cv_func_getpwuid_r" = yes; then
 938                         AC_MSG_RESULT(yes)
 939                         AC_DEFINE(HAVE_GETPWUID_R)
 940                 else
 941                         AC_MSG_RESULT(no)
 942                 fi
 943                 if test "$ac_cv_func_getpwuid_r" = "yes"; then
 944                         AC_MSG_CHECKING(whether getpwuid_r is posix like)
 945                         # The signature for the POSIX version is:
 946                         # int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **)
 947                         AC_TRY_COMPILE([#include <pwd.h>
 948                                 #include <sys/types.h>
 949                                 #include <stdlib.h>],
 950                                 [getpwuid_r((uid_t)0, NULL, NULL, (size_t)0, NULL);],
 951                                 [AC_DEFINE(HAVE_GETPWUID_R_POSIX)
 952                                 AC_MSG_RESULT(yes)],
 953                                 [AC_MSG_RESULT(no)])
 954                 fi
 955         fi
 956         LIBS="$LIBS $G_THREAD_LIBS"
 957         if test x"$have_threads" = xposix; then
 958                 glib_save_CPPFLAGS="$CPPFLAGS"
 959                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 960                 GLIB_SIZEOF([#include <pthread.h>],
 961                         pthread_t,
 962                         system_thread)
 963                 # This is not AC_CHECK_FUNC to also work with function
 964                 # name mangling in header files.
 965                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
 966                 AC_TRY_LINK([#include <pthread.h>],
 967                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
 968                         [AC_MSG_RESULT(yes)
 969                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)],
 970                         [AC_MSG_RESULT(no)])
 971                 AC_MSG_CHECKING(for minimal/maximal thread priority)
 972                 if test x"$posix_priority_min" = xnone; then
 973                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
 974                                 PX_PRIO_MIN],,[
 975                                 posix_priority_min=PX_PRIO_MIN
 976                                 posix_priority_max=PX_PRIO_MAX])
 977                 fi
 978                 if test x"$posix_priority_min" = xnone; then
 979                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
 980                                 PRI_OTHER_MIN],,[
 981                                 posix_priority_min=PRI_OTHER_MIN
 982                                 posix_priority_max=PRI_OTHER_MAX])
 983                 fi
 984                 if test x"$posix_priority_min" = x; then
 985                         AC_MSG_RESULT(none found)
 986                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
 987                         posix_priority_min=-1
 988                         posix_priority_max=-1
 989                 else
 990                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
 991                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min)
 992                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max)
 993                 fi
 994                 posix_yield_func=none
 995                 AC_MSG_CHECKING(for posix yield function)
 996                 for yield_func in sched_yield pthread_yield_np pthread_yield \
 997                                                         thr_yield; do
 998                         AC_TRY_LINK([#include <pthread.h>],
 999                                 [$yield_func()],
1000                                 [posix_yield_func="$yield_func"
1001                                 break])
1002                 done
1003                 if test x"$posix_yield_func" = xnone; then
1004                         AC_MSG_RESULT(none found)
1005                         AC_MSG_WARN($POSIX_NO_YIELD)
1006                         posix_yield_func="g_usleep(1000)"
1007                 else
1008                         AC_MSG_RESULT($posix_yield_func)
1009                         posix_yield_func="$posix_yield_func()"
1010                 fi
1011                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func)
1012                 CPPFLAGS="$glib_save_CPPFLAGS"
1013         else # solaris threads
1014                 GLIB_SIZEOF([#include <thread.h>],
1015                         thread_t,
1016                         system_thread)
1017         fi
1018
1019         LIBS="$glib_save_LIBS"
1020         CFLAGS="$glib_save_CFLAGS"
1021
1022         # now spit out all the warnings.
1023         if test "$ac_cv_func_getpwuid_r" != "yes"; then
1024                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1025         fi
1026         if test "$ac_cv_func_localtime_r" != "yes"; then
1027                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1028         fi
1029 else
1030         # If no thread implementation exists, we will provide enough
1031         # space for a pointer
1032         GLIB_SIZEOF(, void*, system_thread)
1033 fi
1034
1035 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
1036 AC_SUBST(G_THREAD_CFLAGS)
1037 AC_SUBST(G_THREAD_LIBS)
1038 AC_SUBST(G_THREAD_LIBS_EXTRA)
1039
1040 CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1041
1042 dnl **********************************************
1043 dnl *** GDefaultMutex setup and initialization ***
1044 dnl **********************************************
1045 dnl
1046 dnl if mutex_has_default = yes, we also got
1047 dnl mutex_default_type, mutex_default_init and mutex_header_file
1048 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1049         glib_save_CPPFLAGS="$CPPFLAGS"
1050         glib_save_LIBS="$LIBS"
1051         LIBS="$LIBS $G_THREAD_LIBS"
1052         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1053         GLIB_SIZEOF([#include <$mutex_header_file>],
1054                     $mutex_default_type,
1055                     gmutex,
1056                     )
1057         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1058                            $mutex_default_type,
1059                            gmutex,
1060                            $glib_cv_sizeof_gmutex,
1061                            $mutex_default_init)
1062         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1063                 mutex_has_default=no
1064         fi
1065         CPPFLAGS="$glib_save_CPPFLAGS"
1066         LIBS="$glib_save_LIBS"
1067         ,
1068 )
1069
1070
1071 dnl ****************************************
1072 dnl *** GLib POLL* compatibility defines ***
1073 dnl ****************************************
1074 GLIB_SYSDEFS(
1075 [#include <sys/types.h>
1076 #include <sys/poll.h>],
1077         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1078         glibconfig-sysdefs.h,
1079         =)
1080
1081
1082 dnl ******************************
1083 dnl *** output the whole stuff ***
1084 dnl ******************************
1085
1086 AC_OUTPUT_COMMANDS([
1087
1088 ## Generate `glibconfig.h' in two cases
1089 ## 1. `config.status' is run either explicitly, or via configure.
1090 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1091 ##     config.h
1092 ## 2. CONFIG_OTHER is set explicitly
1093 ##
1094 ## Case 1 is difficult.  We know that `automake' sets one of
1095 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1096 ## only when AM_CONFIG_HEADER is set, however.
1097
1098 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1099   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1100   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1101 fi
1102 case "$CONFIG_OTHER" in
1103 *glibconfig.h*)
1104         echo creating glibconfig.h
1105         outfile=glibconfig.h-tmp
1106         cat > $outfile <<\_______EOF
1107 /* glibconfig.h
1108  *
1109  * This is a generated file.  Please modify `configure.in'
1110  */
1111
1112 #ifndef GLIBCONFIG_H
1113 #define GLIBCONFIG_H
1114
1115 _______EOF
1116
1117         if test x$glib_limits_h = xyes; then
1118           echo '#include <limits.h>' >> $outfile
1119         fi
1120         if test x$glib_float_h = xyes; then
1121           echo '#include <float.h>' >> $outfile
1122         fi
1123         if test x$glib_values_h = xyes; then
1124           echo '#include <values.h>' >> $outfile
1125         fi
1126         if test x$g_mutex_header_file != x; then
1127           echo '#include <'"$g_mutex_header_file"'>' >> $outfile
1128         fi
1129         if test x$glib_sys_poll_h = xyes; then
1130           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1131         fi
1132
1133         cat >> $outfile <<_______EOF
1134
1135 #ifdef __cplusplus
1136 extern "C" {
1137 #endif /* __cplusplus */
1138
1139 #define G_MINFLOAT      $glib_mf
1140 #define G_MAXFLOAT      $glib_Mf
1141 #define G_MINDOUBLE     $glib_md
1142 #define G_MAXDOUBLE     $glib_Md
1143 #define G_MINSHORT      $glib_ms
1144 #define G_MAXSHORT      $glib_Ms
1145 #define G_MAXUSHORT     $glib_Mus
1146 #define G_MININT        $glib_mi
1147 #define G_MAXINT        $glib_Mi
1148 #define G_MAXUINT       $glib_Mui
1149 #define G_MINLONG       $glib_ml
1150 #define G_MAXLONG       $glib_Ml
1151 #define G_MAXULONG      $glib_Mul
1152
1153 _______EOF
1154
1155
1156         ### this should always be true in a modern C/C++ compiler
1157         cat >>$outfile <<_______EOF
1158 typedef signed char gint8;
1159 typedef unsigned char guint8;
1160 _______EOF
1161
1162
1163         if test -n "$gint16"; then
1164           cat >>$outfile <<_______EOF
1165 typedef signed $gint16 gint16;
1166 typedef unsigned $gint16 guint16;
1167 #define G_GINT16_FORMAT $gint16_format
1168 #define G_GUINT16_FORMAT $guint16_format
1169 _______EOF
1170         fi
1171
1172
1173         if test -n "$gint32"; then
1174           cat >>$outfile <<_______EOF
1175 typedef signed $gint32 gint32;
1176 typedef unsigned $gint32 guint32;
1177 #define G_GINT32_FORMAT $gint32_format
1178 #define G_GUINT32_FORMAT $guint32_format
1179 _______EOF
1180         fi
1181
1182
1183         if test -n "$gint64"; then
1184           cat >>$outfile <<_______EOF
1185 #define G_HAVE_GINT64 1
1186
1187 ${glib_extension}typedef signed $gint64 gint64;
1188 ${glib_extension}typedef unsigned $gint64 guint64;
1189
1190 #define G_GINT64_FORMAT $gint64_format
1191 #define G_GUINT64_FORMAT $guint64_format
1192 #define G_GINT64_CONSTANT(val)  $gint64_constant
1193
1194 _______EOF
1195         fi
1196
1197         case x$glib_size_t in
1198         x2) echo "typedef gint16  gssize;" >> $outfile
1199             echo "typedef guint16 gsize;"  >> $outfile
1200             ;;
1201         x4) echo "typedef gint32  gssize;" >> $outfile
1202             echo "typedef guint32 gsize;"  >> $outfile
1203             ;;
1204         x8) echo "typedef gint64  gssize;" >> $outfile
1205             echo "typedef guint64 gsize;"  >> $outfile
1206             ;;
1207         *)  echo "#error size of size_t is unknown" >> $outfile
1208             ;;
1209         esac
1210
1211         if test -z "$glib_unknown_void_p"; then
1212           cat >>$outfile <<_______EOF
1213
1214 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1215 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1216
1217 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1218 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1219 _______EOF
1220         else
1221           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1222         fi
1223
1224
1225
1226         cat >>$outfile <<_______EOF
1227 $glib_atexit
1228 $glib_memmove
1229 $glib_defines
1230 $glib_os
1231
1232 $glib_vacopy
1233
1234 #ifdef  __cplusplus
1235 #define G_HAVE_INLINE   1
1236 #else   /* !__cplusplus */
1237 $glib_inline
1238 #endif  /* !__cplusplus */
1239 _______EOF
1240
1241         echo >>$outfile
1242         if test x$g_mutex_has_default = xyes; then
1243                 cat >>$outfile <<_______EOF
1244 $g_enable_threads_def G_THREADS_ENABLED
1245 #define G_THREADS_IMPL_$g_threads_impl_def
1246 typedef struct _GStaticMutex GStaticMutex;
1247 struct _GStaticMutex
1248 {
1249   struct _GMutex *runtime_mutex;
1250   union {
1251     char   pad[$g_mutex_sizeof];
1252     double dummy_double;
1253     void  *dummy_pointer;
1254     long   dummy_long;
1255   } aligned_pad_u;
1256 };
1257 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1258 #define g_static_mutex_get_mutex(mutex) \
1259   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : \
1260    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1261 _______EOF
1262         else
1263                 cat >>$outfile <<_______EOF
1264 $g_enable_threads_def G_THREADS_ENABLED
1265 #define G_THREADS_IMPL_$g_threads_impl_def
1266 typedef struct _GMutex* GStaticMutex;
1267 #define G_STATIC_MUTEX_INIT NULL
1268 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1269 _______EOF
1270         fi
1271
1272         cat >>$outfile <<_______EOF
1273 /* This represents a system thread as used by the implementation. An
1274  * alien implementaion, as loaded by g_thread_init can only count on
1275  * "sizeof (gpointer)" bytes to store their info. We however need more
1276  * for some of our native implementations. */
1277 typedef union _GSystemThread GSystemThread;
1278 union _GSystemThread
1279 {
1280   char   data[$g_system_thread_sizeof];
1281   double dummy_double;
1282   void  *dummy_pointer;
1283   long   dummy_long;
1284 };
1285 _______EOF
1286
1287         echo >>$outfile
1288         g_bit_sizes="16 32"
1289         if test -n "$gint64"; then
1290           g_bit_sizes="$g_bit_sizes 64"
1291         fi
1292         for bits in $g_bit_sizes; do
1293           cat >>$outfile <<_______EOF
1294 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1295 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1296 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1297 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1298 _______EOF
1299         done
1300
1301         cat >>$outfile <<_______EOF
1302 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1303 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1304 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1305 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1306 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1307 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1308 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1309 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1310 #define G_BYTE_ORDER $g_byte_order
1311
1312 _______EOF
1313
1314         if test -r glibconfig-sysdefs.h; then
1315           cat glibconfig-sysdefs.h >>$outfile
1316         fi
1317
1318         cat >>$outfile <<_______EOF
1319
1320 #ifdef __cplusplus
1321 }
1322 #endif /* __cplusplus */
1323
1324 #endif /* GLIBCONFIG_H */
1325 _______EOF
1326
1327
1328         if cmp -s $outfile glibconfig.h; then
1329           echo glibconfig.h is unchanged
1330           rm -f $outfile
1331         else
1332           mv $outfile glibconfig.h
1333         fi ;;
1334 esac
1335 ],[
1336
1337 # Note that if two cases are the same, case goes with the first one.
1338 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1339 # on variable expansion in case labels.  Look at the generated config.status
1340 # for a hint.
1341
1342 case xyes in
1343 x$ac_cv_header_float_h)
1344   glib_float_h=yes
1345   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1346   glib_md=DBL_MIN glib_Md=DBL_MAX
1347   ;;
1348 x$ac_cv_header_values_h)
1349   glib_values_h=yes
1350   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1351   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1352   ;;
1353 esac
1354
1355 case xyes in
1356 x$ac_cv_header_limits_h)
1357   glib_limits_h=yes
1358   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1359   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1360   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1361   ;;
1362 x$ac_cv_header_values_h)
1363   glib_values_h=yes
1364   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1365   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1366   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1367   ;;
1368 esac
1369
1370 if test x$ac_cv_header_sys_poll_h = xyes ; then
1371   glib_sys_poll_h=yes
1372 fi
1373
1374 case 2 in
1375 $ac_cv_sizeof_short)
1376   gint16=short
1377   gint16_format='"hi"'
1378   guint16_format='"hu"'
1379   ;;
1380 $ac_cv_sizeof_int)
1381   gint16=int
1382   gint16_format='"i"'
1383   guint16_format='"u"'
1384   ;;
1385 esac
1386 case 4 in
1387 $ac_cv_sizeof_short)
1388   gint32=short
1389   gint32_format='"hi"'
1390   guint32_format='"hu"'
1391   ;;
1392 $ac_cv_sizeof_int)
1393   gint32=int
1394   gint32_format='"i"'
1395   guint32_format='"u"'
1396   ;;
1397 $ac_cv_sizeof_long)
1398   gint32=long
1399   gint32_format='"li"'
1400   guint32_format='"lu"'
1401   ;;
1402 esac
1403 case 8 in
1404 $ac_cv_sizeof_int)
1405   gint64=int
1406   gint64_format='"i"'
1407   guint64_format='"u"'
1408   glib_extension=
1409   gint64_constant='(val)'
1410   ;;
1411 $ac_cv_sizeof_long)
1412   gint64=long
1413   gint64_format='"li"'
1414   guint64_format='"lu"'
1415   glib_extension=
1416   gint64_constant='(val##L)'
1417   ;;
1418 $ac_cv_sizeof_long_long)
1419   gint64='long long'
1420   gint64_format='"'$glib_cv_long_long_format'i"'
1421   guint64_format='"'$glib_cv_long_long_format'u"'
1422   glib_extension='G_GNUC_EXTENSION '
1423   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1424   ;;
1425 esac
1426 glib_size_t=$glib_cv_sizeof_size_t
1427
1428 gintbits=`expr $ac_cv_sizeof_int \* 8`
1429 glongbits=`expr $ac_cv_sizeof_long \* 8`
1430
1431
1432 case $ac_cv_sizeof_void_p in
1433 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
1434 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
1435 *)                      glib_unknown_void_p=yes ;;
1436 esac
1437
1438
1439 case xyes in
1440 x$ac_cv_func_atexit)
1441   glib_atexit="
1442 #ifdef NeXT /* @#%@! NeXTStep */
1443 # define g_ATEXIT(proc) (!atexit (proc))
1444 #else
1445 # define g_ATEXIT(proc) (atexit (proc))
1446 #endif"
1447   ;;
1448 x$ac_cv_func_on_exit)
1449   glib_atexit="
1450 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
1451   ;;
1452 esac
1453
1454 case xyes in
1455 x$ac_cv_func_memmove)
1456   glib_memmove='
1457 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
1458   ;;
1459 x$glib_cv_working_bcopy)
1460   glib_memmove="
1461 /* memmove isn't available, but bcopy can copy overlapping memory regions */
1462 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
1463   ;;
1464 *)
1465   glib_memmove="
1466 /* memmove isn't found and bcopy can't copy overlapping memory regions,
1467  * so we have to roll our own copy routine. */
1468 void g_memmove (void* dest, const void * src, unsigned long len);"
1469   ;;
1470 esac
1471
1472 glib_defines="
1473 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
1474 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
1475 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
1476 "
1477
1478 case xyes in
1479 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
1480 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
1481 *)                      glib_vacopy=''
1482 esac
1483
1484 if test x$glib_cv_va_val_copy = xno; then
1485   glib_vacopy="\$glib_vacopy
1486 #define G_VA_COPY_AS_ARRAY 1"
1487 fi
1488
1489 if test x$glib_cv_hasinline = xyes; then
1490     glib_inline='#define G_HAVE_INLINE 1'
1491 fi
1492 if test x$glib_cv_has__inline = xyes; then
1493     glib_inline="\$glib_inline
1494 #define G_HAVE___INLINE 1"
1495 fi
1496 if test x$glib_cv_has__inline__ = xyes; then
1497     glib_inline="\$glib_inline
1498 #define G_HAVE___INLINE__ 1"
1499 fi
1500
1501 case xyes in
1502 x$ac_cv_c_bigendian)
1503   g_byte_order=G_BIG_ENDIAN
1504   g_bs_native=BE
1505   g_bs_alien=LE
1506   ;;
1507 *)
1508   g_byte_order=G_LITTLE_ENDIAN
1509   g_bs_native=LE
1510   g_bs_alien=BE
1511   ;;
1512 esac
1513
1514 case x$enable_threads in
1515 xyes)   g_enable_threads_def="#define";;
1516 *)      g_enable_threads_def="#undef ";;
1517 esac
1518
1519 g_threads_impl_def=$g_threads_impl
1520
1521 g_mutex_has_default="$mutex_has_default"
1522 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
1523 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
1524 g_mutex_contents="$glib_cv_byte_contents_gmutex"
1525
1526 case $host in
1527   *-*-beos*)
1528     glib_os="#define G_OS_BEOS"
1529     ;;
1530   *-*-cygwin*)
1531     glib_os="#define G_OS_UNIX
1532 #define G_WITH_CYGWIN"
1533 v    ;;
1534   *)
1535     glib_os="#define G_OS_UNIX"
1536     ;;
1537 esac
1538 ])
1539
1540 AC_OUTPUT([
1541 glib.spec
1542 Makefile
1543 glib-config-2.0
1544 build/Makefile
1545 build/win32/Makefile
1546 gmodule/gmoduleconf.h
1547 gmodule/Makefile
1548 gobject/Makefile
1549 gthread/Makefile
1550 docs/Makefile
1551 docs/glib-config.1
1552 tests/Makefile
1553 ],[case "$CONFIG_FILES" in
1554 *glib-config-2.0*)chmod +x glib-config-2.0;;
1555 esac
1556 echo ""
1557 echo " *** IMPORTANT *** "
1558 echo ""
1559 echo "This is a development version of GLib.  You should be using a stable"
1560 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
1561 echo "version you just configured is meant for developers of GLib only:"
1562 echo ""
1563 echo "  * You should not base stable software on this version of GLib."
1564 echo "  * GNOME developers should use a stable version of GLib."
1565 echo ""
1566 echo "If you install this version of GLib, we strongly recommend that you"
1567 echo "install it in a different prefix than GLib 1.2.  Use --prefix as an"
1568 echo "argument to configure to do this.  Otherwise, you will not be able to"
1569 echo "do development with GLib 1.2 any longer."
1570 echo ""
1571 echo " *** You should be using GLib 1.2 instead. ***"
1572 ])
1573