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