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