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