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 GLIB_AC_DIVERT_BEFORE_HELP([
  19 #
  20 # The following version number definitions apply to GLib, GModule, GObject
  21 # and GThread as a whole, so if changes occoured in any of them, they are all
  22 # treated with the same interface and binary age.
  23 #
  24 # Making releases:
  25 #   GLIB_MICRO_VERSION += 1;
  26 #   GLIB_INTERFACE_AGE += 1;
  27 #   GLIB_BINARY_AGE += 1;
  28 # if any functions have been added, set GLIB_INTERFACE_AGE to 0.
  29 # if backwards compatibility has been broken,
  30 # set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0.
  31 #
  32 GLIB_MAJOR_VERSION=1
  33 GLIB_MINOR_VERSION=3
  34 GLIB_MICRO_VERSION=5
  35 GLIB_INTERFACE_AGE=0
  36 GLIB_BINARY_AGE=0
  37 GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
  38 ])dnl
  39
  40 AC_SUBST(GLIB_MAJOR_VERSION)
  41 AC_SUBST(GLIB_MINOR_VERSION)
  42 AC_SUBST(GLIB_MICRO_VERSION)
  43 AC_SUBST(GLIB_VERSION)
  44 AC_SUBST(GLIB_INTERFACE_AGE)
  45 AC_SUBST(GLIB_BINARY_AGE)
  46
  47 # libtool versioning
  48 LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
  49 LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
  50 LT_REVISION=$GLIB_INTERFACE_AGE
  51 LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
  52 AC_SUBST(LT_RELEASE)
  53 AC_SUBST(LT_CURRENT)
  54 AC_SUBST(LT_REVISION)
  55 AC_SUBST(LT_AGE)
  56
  57 VERSION=$GLIB_VERSION
  58 PACKAGE=glib
  59
  60 AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
  61
  62 # Specify a configuration file
  63 AM_CONFIG_HEADER(config.h)
  64
  65 AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION,
  66                    [Define to the GLIB major version])
  67 AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION,
  68                    [Define to the GLIB minor version])
  69 AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION,
  70                    [Define to the GLIB micro version])
  71 AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE,
  72                    [Define to the GLIB interface age])
  73 AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE,
  74                    [Define to the GLIB binary age])
  75
  76 dnl Initialize maintainer mode
  77 AM_MAINTAINER_MODE
  78
  79 AC_CANONICAL_HOST
  80
  81 AC_MSG_CHECKING(for the BeOS)
  82 case $host in
  83   *-*-beos*)
  84     glib_native_beos="yes"
  85     ;;
  86   *)
  87     glib_native_beos="no"
  88     ;;
  89 esac
  90 AC_MSG_RESULT([$glib_native_beos])
  91
  92 dnl
  93
  94 GLIB_AC_DIVERT_BEFORE_HELP([
  95 # figure debugging default, prior to $ac_help setup
  96 case $GLIB_MINOR_VERSION in
  97 *[[13579]]) debug_default=yes ;;
  98 *)          debug_default=minimum ;;
  99 esac[]dnl
 100 ])
 101
 102 dnl declare --enable-* args and collect ac_help strings
 103 AC_ARG_ENABLE(debug, [  --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
 104 AC_ARG_ENABLE(gc_friendly, [  --enable-gc-friendly    turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
 105 AC_ARG_ENABLE(mem_pools, [  --disable-mem-pools     disable all glib memory pools],,disable_mem_pools=no)
 106 AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
 107                     , enable_ansi=no)
 108 AC_ARG_ENABLE(threads, [  --enable-threads        turn on basic thread support [default=yes]
 109                           ([=no] will override --with-threads)],,enable_threads=yes)
 110 AC_ARG_ENABLE(rebuilds, [  --disable-rebuilds      disable all source autogeneration rules],,enable_rebuilds=yes)
 111
 112 if test "x$enable_threads" != "xyes"; then
 113   enable_threads=no
 114 fi
 115
 116 AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}",
 117         [Whether glib was compiled with debugging enabled])
 118
 119 AC_MSG_CHECKING(whether to enable garbage collector friendliness)
 120 if test "x$enable_gc_friendly" = "xyes"; then
 121   AC_DEFINE(ENABLE_GC_FRIENDLY, 1, [Whether to enable GC friendliness])
 122   AC_SUBST(ENABLE_GC_FRIENDLY)
 123   AC_MSG_RESULT(yes)
 124 else
 125   AC_MSG_RESULT(no)
 126 fi
 127
 128 AC_MSG_CHECKING(whether to disable memory pools)
 129 if test "x$disable_mem_pools" = "xno"; then
 130   AC_MSG_RESULT(no)
 131 else
 132   AC_DEFINE(DISABLE_MEM_POOLS, 1, [Whether to disable memory pools])
 133   AC_SUBST(DISABLE_MEM_POOLS)
 134   AC_MSG_RESULT(yes)
 135 fi
 136
 137 dnl Checks for programs.
 138 AC_PROG_CC
 139
 140 AM_PROG_CC_STDC
 141 AC_PROG_INSTALL
 142
 143 #
 144 # Find pkg-config
 145 #
 146 AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
 147 if test x$PKG_CONFIG = xno ; then
 148   AC_MSG_ERROR([*** pkg-config not found. See http://pkgconfig.sourceforge.net])
 149 fi
 150
 151 if pkg-config --atleast-pkgconfig-version 0.5 ; then
 152   :
 153 else
 154   AC_MSG_ERROR([*** pkg-config too old; version 0.5 or better required.])
 155 fi
 156
 157 if test "x$enable_debug" = "xyes"; then
 158   if test x$cflags_set != xset ; then
 159       case " $CFLAGS " in
 160       *[[\ \    ]]-g[[\ \       ]]*) ;;
 161       *) CFLAGS="$CFLAGS -g" ;;
 162       esac
 163   fi
 164
 165   GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
 166 else
 167   if test "x$enable_debug" = "xno"; then
 168     GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
 169   fi
 170 fi
 171
 172 AC_CYGWIN
 173 AC_EXEEXT
 174
 175 # define a MAINT-like variable REBUILD which is set if Perl
 176 # and awk are found, so autogenerated sources can be rebuilt
 177 AC_PROG_AWK
 178 AC_CHECK_PROGS(PERL, perl5 perl)
 179 # We would like indent, but don't require it.
 180 AC_CHECK_PROG(INDENT, indent, indent)
 181 REBUILD=\#
 182 if test "x$enable_rebuilds" = "xyes" && \
 183      test -n "$PERL" && \
 184      $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 && \
 185      test -n "$AWK" ; then
 186   REBUILD=
 187 fi
 188 AC_SUBST(REBUILD)
 189
 190
 191 dnl
 192 dnl gettext support
 193 dnl
 194
 195 ALL_LINGUAS="ca de fr no ru sl sv tr uk"
 196 AM_GLIB_GNU_GETTEXT
 197 LIBS="$LIBS $INTLLIBS"
 198
 199 GETTEXT_PACKAGE=glib20
 200 AC_SUBST(GETTEXT_PACKAGE)
 201 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE")
 202
 203 # AM_GLIB_GNU_GETTEXT above substs $DATADIRNAME
 204 # this is the directory where the *.{mo,gmo} files are installed
 205 GLIB_LOCALE_DIR="${prefix}/${DATADIRNAME}/locale"
 206 AC_DEFINE_UNQUOTED(GLIB_LOCALE_DIR,"$GLIB_LOCALE_DIR")
 207
 208 dnl Initialize libtool
 209 AC_LIBTOOL_WIN32_DLL
 210 AM_PROG_LIBTOOL
 211
 212 if test "x$GCC" = "xyes"; then
 213   case " $CFLAGS " in
 214   *[[\ \        ]]-Wall[[\ \    ]]*) ;;
 215   *) CFLAGS="$CFLAGS -Wall" ;;
 216   esac
 217
 218   if test "x$enable_ansi" = "xyes"; then
 219     case " $CFLAGS " in
 220     *[[\ \      ]]-ansi[[\ \    ]]*) ;;
 221     *) CFLAGS="$CFLAGS -ansi" ;;
 222     esac
 223
 224     case " $CFLAGS " in
 225     *[[\ \      ]]-pedantic[[\ \        ]]*) ;;
 226     *) CFLAGS="$CFLAGS -pedantic" ;;
 227     esac
 228   fi
 229 fi
 230
 231 dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
 232 AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
 233 glib_save_LIBS=$LIBS
 234 LIBS="$LIBS -lm"
 235 AC_TRY_RUN([#include <math.h>
 236              int main (void) { return (log(1) != log(1.)); }],
 237      AC_MSG_RESULT(none needed),
 238      glib_save_CFLAGS=$CFLAGS
 239      CFLAGS="$CFLAGS -std1"
 240      AC_TRY_RUN([#include <math.h>
 241                  int main (void) { return (log(1) != log(1.)); }],
 242          AC_MSG_RESULT(-std1),
 243          AC_MSG_RESULT()
 244          CFLAGS=$glib_save_CFLAGS
 245          AC_MSG_WARN(
 246                 [No ANSI prototypes found in library. (-std1 didn't work.)])
 247      )
 248 )
 249 LIBS=$glib_save_LIBS
 250
 251 dnl NeXTStep cc seems to need this
 252 AC_MSG_CHECKING([for extra flags for POSIX compliance])
 253 AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 254   AC_MSG_RESULT(none needed),
 255   glib_save_CFLAGS=$CFLAGS
 256   CFLAGS="$CFLAGS -posix"
 257   AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
 258     AC_MSG_RESULT(-posix),
 259     AC_MSG_RESULT()
 260     CFLAGS=$glib_save_CFLAGS
 261     AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
 262
 263 # Checks for header files.
 264 AC_HEADER_STDC
 265
 266 # Checks for library functions.
 267 AC_FUNC_VPRINTF
 268
 269 AC_FUNC_ALLOCA
 270
 271 AC_CHECK_FUNCS(atexit on_exit)
 272
 273 AC_CHECK_SIZEOF(char)
 274 AC_CHECK_SIZEOF(short)
 275 AC_CHECK_SIZEOF(long)
 276 AC_CHECK_SIZEOF(int)
 277 AC_CHECK_SIZEOF(void *)
 278 AC_CHECK_SIZEOF(long long)
 279
 280 if test x$ac_cv_sizeof_long_long = x8; then
 281         # long long is a 64 bit integer.
 282         AC_MSG_CHECKING(for format to printf and scanf a gint64)
 283         AC_CACHE_VAL(glib_cv_long_long_format,[
 284                 for format in ll q I64; do
 285                   AC_TRY_RUN([#include <stdio.h>
 286                         int main()
 287                         {
 288                           long long b, a = -0x3AFAFAFAFAFAFAFALL;
 289                           char buffer[1000];
 290                           sprintf (buffer, "%${format}u", a);
 291                           sscanf (buffer, "%${format}u", &b);
 292                           exit (b!=a);
 293                         }
 294                         ],
 295                         glib_cv_long_long_format=${format}
 296                         break)
 297                 done])
 298         if test -n "$glib_cv_long_long_format"; then
 299           AC_MSG_RESULT(%${glib_cv_long_long_format}u)
 300         else
 301           AC_MSG_RESULT(none)
 302         fi
 303 fi
 304
 305 dnl long doubles were not used, and a portability problem
 306 dnl AC_C_LONG_DOUBLE
 307 AC_C_CONST
 308
 309 dnl ok, here we try to check whether the systems prototypes for
 310 dnl malloc and friends actually match the prototypes provided
 311 dnl by gmem.h (keep in sync). i currently only know how to check
 312 dnl this reliably with gcc (-Werror), improvements for other
 313 dnl compilers are apprechiated.
 314 SANE_MALLOC_PROTOS=no
 315 AC_MSG_CHECKING([if malloc() and friends prototypes are gmem.h compatible])
 316 glib_save_CFLAGS=$CFLAGS
 317 if test "x$GCC" = "xyes"; then
 318   CFLAGS="$CFLAGS -Werror"
 319   AC_TRY_COMPILE([#include <stdlib.h>], [
 320     void* (*my_calloc_p)  (size_t, size_t) = calloc;
 321     void* (*my_malloc_p)  (size_t)         = malloc;
 322     void  (*my_free_p)    (void*)          = free;
 323     void* (*my_realloc_p) (void*, size_t)  = realloc;
 324     my_calloc_p = 0;
 325     my_malloc_p = 0;
 326     my_free_p = 0;
 327     my_realloc_p = 0;
 328   ],
 329     AC_DEFINE(SANE_MALLOC_PROTOS)
 330     SANE_MALLOC_PROTOS=yes)
 331 fi
 332 AC_MSG_RESULT($SANE_MALLOC_PROTOS)
 333 CFLAGS=$glib_save_CFLAGS
 334
 335
 336 dnl AC_C_INLINE is useless to us since it bails out too early, we need to
 337 dnl truely know which ones of `inline', `__inline' and `__inline__' are
 338 dnl actually supported.
 339 AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
 340         AC_TRY_RUN([
 341         __inline int foo () { return 0; }
 342         int main () { return foo (); }
 343         ],
 344         glib_cv_has__inline=yes
 345         ,
 346         glib_cv_has__inline=no
 347         ,)
 348 ])
 349 case x$glib_cv_has__inline in
 350 xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
 351 esac
 352 AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
 353         AC_TRY_RUN([
 354         __inline__ int foo () { return 0; }
 355         int main () { return foo (); }
 356         ],
 357         glib_cv_has__inline__=yes
 358         ,
 359         glib_cv_has__inline__=no
 360         ,)
 361 ])
 362 case x$glib_cv_has__inline__ in
 363 xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
 364 esac
 365 AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
 366         AC_TRY_RUN([
 367         inline int foo () { return 0; }
 368         int main () { return foo (); }
 369         ],
 370         glib_cv_hasinline=yes
 371         ,
 372         glib_cv_hasinline=no
 373         ,)
 374 ])
 375 case x$glib_cv_hasinline in
 376 xyes) AC_DEFINE(G_HAVE_INLINE,1,[Have inline keyword])
 377 esac
 378
 379 # check for flavours of varargs macros
 380 AC_MSG_CHECKING(for ISO C99 varargs macros)
 381 AC_TRY_COMPILE([],[
 382 int a(int p1, int p2, int p3);
 383 #define call_a(...) a(1,__VA_ARGS__)
 384 call_a(2,3);
 385 ],g_have_iso_varargs=yes,g_have_iso_varargs=no)
 386 AC_MSG_RESULT($g_have_iso_varargs)
 387
 388 AC_MSG_CHECKING(for GNUC varargs macros)
 389 AC_TRY_COMPILE([],[
 390 int a(int p1, int p2, int p3);
 391 #define call_a(params...) a(1,params)
 392 call_a(2,3);
 393 ],g_have_gnuc_varargs=yes,g_have_gnuc_varargs=no)
 394 AC_MSG_RESULT($g_have_gnuc_varargs)
 395
 396 # check for bytesex stuff
 397 AC_C_BIGENDIAN
 398
 399 # check for header files
 400 AC_CHECK_HEADERS([float.h limits.h pwd.h sys/param.h sys/poll.h sys/select.h])
 401 AC_CHECK_HEADERS([sys/time.h sys/times.h unistd.h values.h stdint.h sched.h])
 402
 403 AC_MSG_CHECKING(whether make is GNU Make)
 404 STRIP_BEGIN=
 405 STRIP_END=
 406 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
 407         STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 408         STRIP_END=')'
 409         AC_MSG_RESULT(yes)
 410 else
 411         AC_MSG_RESULT(no)
 412 fi
 413 STRIP_DUMMY=
 414 AC_SUBST(STRIP_DUMMY)
 415 AC_SUBST(STRIP_BEGIN)
 416 AC_SUBST(STRIP_END)
 417
 418 # check additional type sizes
 419 size_includes=["
 420 #include <stdarg.h>
 421 #include <stdio.h>
 422 #include <ctype.h>
 423 #include <string.h>
 424 "]
 425 if test "x$ac_cv_header_stdint_h" = "xyes"; then
 426   size_includes=["$size_includes
 427 #include <stdint.h>
 428 "]
 429 fi
 430 if test "x$ac_cv_header_unistd_h" = "xyes"; then
 431   size_includes=["$size_includes
 432 #include <unistd.h>
 433 "]
 434 fi
 435 GLIB_SIZEOF([$size_includes], size_t, size_t)
 436 GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
 437 GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
 438
 439 # Check for some functions
 440 AC_CHECK_FUNCS(lstat strerror strsignal memmove mkstemp vsnprintf stpcpy strcasecmp strncasecmp poll getcwd)
 441
 442 # Check if bcopy can be used for overlapping copies, if memmove isn't found.
 443 # The check is borrowed from the PERL Configure script.
 444 if test "$ac_cv_func_memmove" != "yes"; then
 445   AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
 446     glib_cv_working_bcopy,[AC_TRY_RUN([
 447       int main() {
 448         char buf[128], abc[128], *b;
 449         int len, off, align;
 450         bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
 451         for (align = 7; align >= 0; align--) {
 452           for (len = 36; len; len--) {
 453             b = buf+align; bcopy(abc, b, len);
 454             for (off = 1; off <= len; off++) {
 455               bcopy(b, b+off, len); bcopy(b+off, b, len);
 456                 if (bcmp(b, abc, len)) return(1);
 457             }
 458           }
 459         }
 460         return(0);
 461       }],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
 462   if test "$glib_cv_working_bcopy" = "yes"; then
 463     AC_DEFINE(HAVE_WORKING_BCOPY,1,[Have a working bcopy])
 464   fi
 465 fi
 466
 467 # Check for sys_errlist
 468 AC_MSG_CHECKING(for sys_errlist)
 469 AC_TRY_LINK(, [
 470 extern char *sys_errlist[];
 471 extern int sys_nerr;
 472 sys_errlist[sys_nerr-1][0] = 0;
 473 ], glib_ok=yes, glib_ok=no)
 474 AC_MSG_RESULT($glib_ok)
 475 if test $glib_ok = no; then
 476     AC_DEFINE(NO_SYS_ERRLIST,1,[global 'sys_errlist' not found])
 477 fi
 478
 479 # Check for sys_siglist
 480 AC_MSG_CHECKING(for sys_siglist)
 481 AC_TRY_LINK(, [
 482 extern char *sys_siglist[];
 483 exit (sys_siglist[0]);
 484 ], glib_ok=yes, glib_ok=no)
 485 AC_MSG_RESULT($glib_ok)
 486 if test $glib_ok = no; then
 487     AC_DEFINE(NO_SYS_SIGLIST,1,[global 'sys_siglist' not found])
 488 fi
 489
 490 # Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
 491 AC_MSG_CHECKING(for sys_siglist declaration)
 492 AC_TRY_COMPILE([#include <signal.h>], [
 493 strlen (sys_siglist[0]);
 494 ], glib_ok=yes, glib_ok=no)
 495 AC_MSG_RESULT($glib_ok)
 496 if test $glib_ok = no; then
 497     AC_DEFINE(NO_SYS_SIGLIST_DECL,1,[global 'sys_siglist' not declared])
 498 fi
 499
 500 # Check if <sys/select.h> needs to be included for fd_set
 501 AC_MSG_CHECKING([for fd_set])
 502 AC_TRY_COMPILE([#include <sys/types.h>],
 503         [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
 504 if test $gtk_ok = yes; then
 505     AC_MSG_RESULT([yes, found in sys/types.h])
 506 else
 507     AC_EGREP_HEADER(fd_set, sys/select.h, gtk_ok=yes)
 508     if test $gtk_ok = yes; then
 509         # *** FIXME: give it a different name
 510         AC_DEFINE(HAVE_SYS_SELECT_H,1,[found fd_set in sys/select.h])
 511         AC_MSG_RESULT([yes, found in sys/select.h])
 512     else
 513         AC_DEFINE(NO_FD_SET,1,[didn't find fd_set])
 514         AC_MSG_RESULT(no)
 515     fi
 516 fi
 517
 518 dnl *** check for sane realloc() ***
 519 AC_CACHE_CHECK([whether realloc (NULL,) will work],glib_cv_sane_realloc,[
 520         AC_TRY_RUN([
 521         #include <stdlib.h>
 522         int main() {
 523           return realloc (0, sizeof (int)) == 0;
 524         }],
 525         [glib_cv_sane_realloc=yes],
 526         [glib_cv_sane_realloc=no],
 527         [])
 528 ])
 529 if test x$glib_cv_sane_realloc = xyes; then
 530   AC_DEFINE(REALLOC_0_WORKS,1,[whether realloc (NULL,) works])
 531 fi
 532
 533 dnl Check for nl_langinfo and CODESET
 534
 535 AC_MSG_CHECKING([for nl_langinfo (CODESET)])
 536 AC_TRY_COMPILE([#include <langinfo.h>],
 537         [char *codeset = nl_langinfo (CODESET);],
 538    AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
 539    have_codeset=yes,
 540    have_codeset=no)
 541 AC_MSG_RESULT($have_codeset)
 542
 543
 544 dnl ****************************************
 545 dnl *** strlcpy/strlcat                  ***
 546 dnl ****************************************
 547 # Check for strlcpy
 548 AC_MSG_CHECKING(for strlcpy/strlcat)
 549 AC_TRY_LINK([#include <stdlib.h>
 550 #include <string.h>], [
 551 char *p = malloc(10);
 552 (void) strlcpy(p, "hi", 10);
 553 (void) strlcat(p, "bye", 10);
 554 ], glib_ok=yes, glib_ok=no)
 555 AC_MSG_RESULT($glib_ok)
 556 if test $glib_ok = yes; then
 557     AC_DEFINE(HAVE_STRLCPY,1,[Have functions strlcpy and strlcat])
 558 fi
 559
 560
 561 dnl **********************
 562 dnl *** va_copy checks ***
 563 dnl **********************
 564 dnl we currently check for all three va_copy possibilities, so we get
 565 dnl all results in config.log for bug reports.
 566 AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
 567         AC_TRY_RUN([
 568         #include <stdarg.h>
 569         void f (int i, ...) {
 570         va_list args1, args2;
 571         va_start (args1, i);
 572         va_copy (args2, args1);
 573         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 574           exit (1);
 575         va_end (args1); va_end (args2);
 576         }
 577         int main() {
 578           f (0, 42);
 579           return 0;
 580         }],
 581         [glib_cv_va_copy=yes],
 582         [glib_cv_va_copy=no],
 583         [])
 584 ])
 585 AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
 586         AC_TRY_RUN([
 587         #include <stdarg.h>
 588         void f (int i, ...) {
 589         va_list args1, args2;
 590         va_start (args1, i);
 591         __va_copy (args2, args1);
 592         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 593           exit (1);
 594         va_end (args1); va_end (args2);
 595         }
 596         int main() {
 597           f (0, 42);
 598           return 0;
 599         }],
 600         [glib_cv___va_copy=yes],
 601         [glib_cv___va_copy=no],
 602         [])
 603 ])
 604
 605 if test "x$glib_cv_va_copy" = "xyes"; then
 606   g_va_copy_func=va_copy
 607 else if test "x$glib_cv___va_copy" = "xyes"; then
 608   g_va_copy_func=__va_copy
 609 fi
 610 fi
 611
 612 if test -n "$g_va_copy_func"; then
 613   AC_DEFINE_UNQUOTED(G_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
 614 fi
 615
 616 AC_CACHE_CHECK([whether va_lists can be copied by value],glib_cv_va_val_copy,[
 617         AC_TRY_RUN([
 618         #include <stdarg.h>
 619         void f (int i, ...) {
 620         va_list args1, args2;
 621         va_start (args1, i);
 622         args2 = args1;
 623         if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
 624           exit (1);
 625         va_end (args1); va_end (args2);
 626         }
 627         int main() {
 628           f (0, 42);
 629           return 0;
 630         }],
 631         [glib_cv_va_val_copy=yes],
 632         [glib_cv_va_val_copy=no],
 633         [])
 634 ])
 635
 636 if test "x$glib_cv_va_val_copy" = "xno"; then
 637   AC_DEFINE(G_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
 638 fi
 639
 640 dnl ***********************
 641 dnl *** g_module checks ***
 642 dnl ***********************
 643 G_MODULE_LIBS=
 644 G_MODULE_LIBS_EXTRA=
 645 G_MODULE_PLUGIN_LIBS=
 646 G_MODULE_LDFLAGS=
 647 dnl G_MODULE_IMPL= don't reset, so cmd-line can override
 648 G_MODULE_NEED_USCORE=0
 649 G_MODULE_BROKEN_RTLD_GLOBAL=0
 650 G_MODULE_HAVE_DLERROR=0
 651 dnl *** force native WIN32 shared lib loader
 652 if test -z "$G_MODULE_IMPL"; then
 653   case "$host" in
 654   *-*-mingw*|*-*-cygwin*) G_MODULE_IMPL=G_MODULE_IMPL_WIN32 ;;
 655   esac
 656 fi
 657 dnl *** dlopen() and dlsym() in system libraries
 658 if test -z "$G_MODULE_IMPL"; then
 659         AC_CHECK_FUNC(dlopen,
 660                       [AC_CHECK_FUNC(dlsym,
 661                                      [G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 662                       [])
 663 fi
 664 dnl *** load_image (BeOS)
 665 if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
 666   AC_CHECK_LIB(root, load_image,
 667       [G_MODULE_LIBS="-lbe -lroot -lglib"
 668       G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
 669       G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
 670       G_MODULE_IMPL=G_MODULE_IMPL_BEOS],
 671       [])
 672 fi
 673 dnl *** dlopen() and dlsym() in libdl
 674 if test -z "$G_MODULE_IMPL"; then
 675         AC_CHECK_LIB(dl, dlopen,
 676                      [AC_CHECK_LIB(dl, dlsym,
 677                                    [G_MODULE_LIBS=-ldl
 678                                    G_MODULE_IMPL=G_MODULE_IMPL_DL],[])],
 679                      [])
 680 fi
 681 dnl *** NSLinkModule (dyld) in system libraries (Darwin)
 682 if test -z "$G_MODULE_IMPL"; then
 683         AC_CHECK_FUNC(NSLinkModule,
 684                       [G_MODULE_IMPL=G_MODULE_IMPL_DYLD
 685                        G_MODULE_NEED_USCORE=1],
 686                       [])
 687 fi
 688 dnl *** shl_load() in libdld (HP-UX)
 689 if test -z "$G_MODULE_IMPL"; then
 690         AC_MSG_CHECKING(how to export all symbols)
 691         SAVED_LDFLAGS=$LDFLAGS
 692         LDFLAGS="$LDFLAGS -Wl,-E"
 693         AC_TRY_LINK(,[ return 0; ],
 694                 [ G_MODULE_LDFLAGS="-Wl,-E" ],[
 695                 LDFLAGS="$SAVED_LDFLAGS -bexpall"
 696                 AC_TRY_LINK(,[ return 0; ],
 697                         [G_MODULE_LDFLAGS="-bexpall"],
 698                         [G_MODULE_LDFLAGS="none"])
 699         ])
 700         LDFLAGS=$SAVED_LDFLAGS
 701         AC_MSG_RESULT($G_MODULE_LDFLAGS)
 702         if test "x$G_MODULE_LDFLAGS" = "xnone"; then
 703                 G_MODULE_LDFLAGS=
 704         fi
 705         AC_CHECK_LIB(dld, shl_load,
 706                 [G_MODULE_LIBS=-ldld
 707                 G_MODULE_IMPL=G_MODULE_IMPL_DLD],
 708                 [])
 709 fi
 710 dnl *** additional checks for G_MODULE_IMPL_DL
 711 if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
 712         case "$host_os" in
 713           linux*)
 714             G_MODULE_LDFLAGS='-rdynamic'
 715             ;;
 716         esac
 717         LIBS_orig="$LIBS"
 718         LDFLAGS_orig="$LDFLAGS"
 719         LIBS="$LIBS $G_MODULE_LIBS"
 720         LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
 721 dnl *** check for OSF1/5.0 RTLD_GLOBAL brokenness
 722         AC_CACHE_CHECK([for RTLD_GLOBAL brokenness],
 723                 glib_cv_rtldglobal_broken,[
 724                 AC_TRY_RUN([
 725                 #include <dlfcn.h>
 726                 #ifndef RTLD_GLOBAL
 727                 #define RTLD_GLOBAL 0
 728                 #endif
 729                 #ifndef RTLD_LAZY
 730                 #define RTLD_LAZY 0
 731                 #endif
 732                 int pthread_create;
 733                 int main () {
 734                 void *handle, *global, *local;
 735                 global = &pthread_create;
 736                 handle = dlopen ("libpthread.so", RTLD_GLOBAL | RTLD_LAZY);
 737                 if (!handle) return 0;
 738                 local = dlsym (handle, "pthread_create");
 739                 return global == local;
 740                 }],
 741                         [glib_cv_rtldglobal_broken=no],
 742                         [glib_cv_rtldglobal_broken=yes],
 743                         [])
 744                 rm -f plugin.c plugin.o plugin.lo
 745         ])
 746         if test "x$glib_cv_rtldglobal_broken" = "xyes"; then
 747                 G_MODULE_BROKEN_RTLD_GLOBAL=1
 748         else
 749                 G_MODULE_BROKEN_RTLD_GLOBAL=0
 750         fi
 751 dnl *** check whether we need preceeding underscores
 752         AC_CACHE_CHECK([for preceeding underscore in symbols],
 753                 glib_cv_uscore,[
 754                 AC_TRY_RUN([
 755                 #include <dlfcn.h>
 756                 int glib_underscore_test (void) { return 42; }
 757                 int main() {
 758                   void *f1 = (void*)0, *f2 = (void*)0, *handle;
 759                   handle = dlopen ((void*)0, 0);
 760                   if (handle) {
 761                     f1 = dlsym (handle, "glib_underscore_test");
 762                     f2 = dlsym (handle, "_glib_underscore_test");
 763                   } return (!f2 || f1);
 764                 }],
 765                         [glib_cv_uscore=yes],
 766                         [glib_cv_uscore=no],
 767                         [])
 768                 rm -f plugin.c plugin.$ac_objext plugin.lo
 769         ])
 770         if test "x$glib_cv_uscore" = "xyes"; then
 771                 G_MODULE_NEED_USCORE=1
 772         else
 773                 G_MODULE_NEED_USCORE=0
 774         fi
 775
 776         LDFLAGS="$LDFLAGS_orig"
 777 dnl *** check for having dlerror()
 778         AC_CHECK_FUNC(dlerror,
 779                 [G_MODULE_HAVE_DLERROR=1],
 780                 [G_MODULE_HAVE_DLERROR=0])
 781         LIBS="$LIBS_orig"
 782 fi
 783 dnl *** done, have we got an implementation?
 784 if test -z "$G_MODULE_IMPL"; then
 785         G_MODULE_IMPL=0
 786 fi
 787
 788 AC_MSG_CHECKING(for the suffix of shared libraries)
 789 case "$host_os" in
 790   hpux9* | hpux10* | hpux11*)  # taken from ltconfig
 791     glib_gmodule_suffix='sl'
 792     ;;
 793   cygwin* | mingw*)
 794     glib_gmodule_suffix='dll'
 795     ;;
 796   *)
 797     glib_gmodule_suffix='so'
 798     ;;
 799 esac
 800 AC_MSG_RESULT(.$glib_gmodule_suffix)
 801
 802 AC_SUBST(G_MODULE_IMPL)
 803 AC_SUBST(G_MODULE_LIBS)
 804 AC_SUBST(G_MODULE_LIBS_EXTRA)
 805 AC_SUBST(G_MODULE_PLUGIN_LIBS)
 806 AC_SUBST(G_MODULE_LDFLAGS)
 807 AC_SUBST(G_MODULE_HAVE_DLERROR)
 808 AC_SUBST(G_MODULE_BROKEN_RTLD_GLOBAL)
 809 AC_SUBST(G_MODULE_NEED_USCORE)
 810 AC_SUBST(GLIB_DEBUG_FLAGS)
 811
 812 dnl **********************
 813 dnl *** g_spawn checks ***
 814 dnl **********************
 815
 816 AC_MSG_CHECKING(for gspawn implementation)
 817 case "$host" in
 818   *-*-mingw*)
 819     GSPAWN=gspawn-win32.lo
 820     ;;
 821   *)
 822     GSPAWN=gspawn.lo
 823     ;;
 824 esac
 825 AC_MSG_RESULT($GSPAWN)
 826 AC_SUBST(GSPAWN)
 827
 828 dnl *************************
 829 dnl *** GIOChannel checks ***
 830 dnl *************************
 831
 832 AC_MSG_CHECKING(for GIOChannel implementation)
 833 case "$host" in
 834   *-*-mingw*)
 835     GIO=giowin32.lo
 836     ;;
 837   *)
 838     GIO=giounix.lo
 839     ;;
 840 esac
 841 AC_MSG_RESULT($GIO)
 842 AC_SUBST(GIO)
 843
 844 dnl ****************************************
 845 dnl *** platform dependent source checks ***
 846 dnl ****************************************
 847
 848 AC_MSG_CHECKING(for platform-dependent source)
 849 case "$host" in
 850   *-*-cygwin*|*-*-mingw*)
 851     PLATFORMDEP=gwin32.lo
 852     ;;
 853   *)
 854     PLATFORMDEP=
 855     ;;
 856 esac
 857 AC_MSG_RESULT($PLATFORMDEP)
 858 AC_SUBST(PLATFORMDEP)
 859
 860 AC_MSG_CHECKING([whether to compile timeloop])
 861 case "$host" in
 862   *-*-cygwin*|*-*-mingw*)
 863     enable_timeloop=no
 864     ;;
 865   *)
 866     enable_timeloop=yes
 867     ;;
 868 esac
 869 AC_MSG_RESULT($enable_timeloop)
 870 AM_CONDITIONAL(ENABLE_TIMELOOP, test x$enable_timeloop = xyes)
 871
 872 AC_MSG_CHECKING([if building for some Win32 platform])
 873 case "$host" in
 874   *-*-mingw*|*-*-cygwin*)
 875     platform_win32=yes
 876     ;;
 877   *)
 878     platform_win32=no
 879     ;;
 880 esac
 881 AC_MSG_RESULT($platform_win32)
 882 AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
 883
 884 AC_MSG_CHECKING([if building for pure Win32])
 885 case "$host" in
 886   *-*-mingw*)
 887     os_win32=yes
 888     ;;
 889   *)
 890     os_win32=no
 891     ;;
 892 esac
 893 AC_MSG_RESULT($os_win32)
 894 AM_CONDITIONAL(OS_WIN32, test x$os_win32 = xyes)
 895
 896 dnl ***********************
 897 dnl *** g_thread checks ***
 898 dnl ***********************
 899
 900 AC_ARG_WITH(threads, [  --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
 901         if test "x$with_threads" = x; then
 902                 want_threads=yes
 903         else
 904                 want_threads=$with_threads
 905         fi,
 906         want_threads=yes)
 907 if test "x$enable_threads" = "xno"; then
 908         want_threads=no
 909 fi
 910 if test "x$want_threads" = "xnone"; then
 911         want_threads=no
 912 fi
 913
 914 dnl error and warning message
 915 dnl *************************
 916
 917 THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
 918                 computer. GLib will not have a default thread implementation."
 919
 920 FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
 921                 platform (normally it's "_REENTRANT"). I'll not use any flag on
 922                 compilation now, but then your programs might not work.
 923                 Please provide information on how it is done on your system."
 924
 925 LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
 926                 "
 927
 928 LIBS_NOT_FOUND_2=". Please choose another thread implementation or
 929                 provide information on your thread implementation.
 930                 You can also run 'configure --disable-threads'
 931                 to compile without thread support."
 932
 933 FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
 934                 functions will not be MT-safe during their first call because
 935                 there is no working 'getpwuid_r' on your system."
 936
 937 FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
 938                 because there is no 'localtime_r' on your system."
 939
 940 POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
 941                 crude surrogate will be used. If you happen to know a
 942                 yield function for your system, please inform the GLib
 943                 developers."
 944
 945 POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
 946                 threads on your system. Thus threads can only have the default
 947                 priority. If you happen to know these main/max
 948                 priorities, please inform the GLib developers."
 949
 950
 951 dnl determination of thread implementation
 952 dnl ***************************************
 953
 954 have_threads=none
 955 if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
 956         case $host in
 957                 *-*-solaris*)
 958                 AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
 959                 ;;
 960         esac
 961 fi
 962 if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
 963                                 || test "x$want_threads" = xdce; then
 964         # -D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
 965         # -U_OSF_SOURCE is for Digital UNIX 4.0d
 966         GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4_DRAFT_SOURCE -D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
 967         glib_save_CPPFLAGS="$CPPFLAGS"
 968         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
 969         if test "x$have_threads" = xnone; then
 970                 AC_TRY_COMPILE([#include <pthread.h>],
 971                         [pthread_attr_t attr; pthread_attr_init(&attr);],
 972                         have_threads=posix)
 973         fi
 974         if test "x$have_threads" = xnone; then
 975                 AC_TRY_COMPILE([#include <pthread.h>],
 976                         [pthread_attr_t attr; pthread_attr_create(&attr);],
 977                         have_threads=posix)
 978         fi
 979         CPPFLAGS="$glib_save_CPPFLAGS"
 980 fi
 981
 982 AC_MSG_CHECKING(for thread implementation)
 983
 984 if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
 985         AC_MSG_RESULT(none available)
 986         AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
 987 else
 988         AC_MSG_RESULT($have_threads)
 989 fi
 990
 991
 992 dnl determination of G_THREAD_CFLAGS
 993 dnl ********************************
 994
 995 G_THREAD_LIBS=
 996 G_THREAD_LIBS_EXTRA=
 997 G_THREAD_CFLAGS=
 998
 999 if test x"$have_threads" != xnone; then
1000
1001     G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
1002
1003     case $host in
1004         *-aix*)
1005                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1006                 if test x"$GCC" = xyes; then
1007                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
1008                 fi
1009                 ;;
1010         *-freebsd2.2*)
1011                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
1012
1013                 # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
1014                 # -mthreads flag.
1015                 ;;
1016         *-sysv5uw7*)  # UnixWare 7
1017                 if test "$GCC" != "yes"; then
1018                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
1019                 else
1020                         G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
1021                 fi
1022                 ;;
1023         *-dg-dgux*)  # DG/UX
1024                 G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
1025     esac
1026
1027     # if we are not finding the localtime_r function, then we probably are
1028     # not using the proper multithread flag
1029
1030     glib_save_CPPFLAGS="$CPPFLAGS"
1031     CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
1032
1033     # First we test, whether localtime_r is declared in time.h
1034     # directly. Then we test whether a macro localtime_r exists, in
1035     # which case localtime_r in the test program is replaced and thus
1036     # if we still find localtime_r in the output, it is not defined as
1037     # a macro.
1038
1039     AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
1040       [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
1041                                                            localtime_r(a,b)],
1042                    AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
1043
1044     CPPFLAGS="$glib_save_CPPFLAGS"
1045
1046     AC_MSG_CHECKING(thread related cflags)
1047     AC_MSG_RESULT($G_THREAD_CFLAGS)
1048     CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
1049 fi
1050
1051 dnl determination of G_THREAD_LIBS
1052 dnl ******************************
1053
1054 mutex_has_default=no
1055 case $have_threads in
1056         posix|dce)
1057            glib_save_CPPFLAGS="$CPPFLAGS"
1058            CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1059            G_THREAD_LIBS=error
1060            glib_save_LIBS="$LIBS"
1061            case $host in
1062              *-sysv5uw7*) # UnixWare 7
1063                 if test "$GCC" != "yes"; then
1064                         G_THREAD_LIBS="-Kthread"
1065                 else
1066                         G_THREAD_LIBS="-pthread"
1067                 fi
1068                 ;;
1069              *)
1070                 for thread_lib in "" pthread pthread32 pthreads c_r thread dce; do
1071                         if test x"$thread_lib" = x; then
1072                                 add_thread_lib=""
1073                                 IN=""
1074                         else
1075                                 add_thread_lib="-l$thread_lib"
1076                                 IN=" in -l$thread_lib"
1077                         fi
1078                         if test x"$have_threads" = xposix; then
1079                                 defattr=0
1080                         else
1081                                 defattr=pthread_attr_default
1082                         fi
1083
1084                         LIBS="$glib_save_LIBS $add_thread_lib"
1085
1086                         AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
1087                         AC_TRY_RUN([#include <pthread.h>
1088                                 int check_me = 0;
1089                                 void* func(void* data) {check_me = 42;}
1090                                 main()
1091                                 { pthread_t t;
1092                                   void *ret;
1093                                   pthread_create (&t, $defattr, func, 0);
1094                                   pthread_join (t, &ret);
1095                                   exit (check_me != 42);
1096                                 }],
1097                                 [AC_MSG_RESULT(yes)
1098                                 G_THREAD_LIBS="$add_thread_lib"
1099                                 break],
1100                                 [AC_MSG_RESULT(no)])
1101                 done
1102                 if test "x$G_THREAD_LIBS" = xerror; then
1103                   AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1104                 fi
1105                 for thread_lib in "" rt rte; do
1106                         if test x"$thread_lib" = x; then
1107                                 add_thread_lib=""
1108                                 IN=""
1109                         else
1110                                 add_thread_lib="-l$thread_lib"
1111                                 IN=" in -l$thread_lib"
1112                         fi
1113                         LIBS="$glib_save_LIBS $add_thread_lib"
1114
1115                         AC_MSG_CHECKING(for sched_get_priority_min$IN)
1116                         AC_TRY_RUN([#include <sched.h>
1117                                 #include <errno.h>
1118                                 int main() {
1119                                 errno = 0;
1120                                 return sched_get_priority_min(SCHED_OTHER)==-1
1121                                         && errno != 0;
1122                                 }],
1123                                 [AC_MSG_RESULT(yes)
1124                                 G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
1125                                 posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
1126                                 posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
1127                                 break],
1128                                 [AC_MSG_RESULT(no)])
1129                 done
1130                 LIBS="$glib_save_LIBS"
1131                 ;;
1132            esac
1133            mutex_has_default=yes
1134            mutex_default_type='pthread_mutex_t'
1135            mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
1136            mutex_header_file='pthread.h'
1137            if test "x$have_threads" = "xposix"; then
1138              g_threads_impl="POSIX"
1139            else
1140              g_threads_impl="DCE"
1141              have_threads="posix"
1142            fi
1143            AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
1144            CPPFLAGS="$glib_save_CPPFLAGS"
1145            ;;
1146         solaris)
1147            G_THREAD_LIBS=error
1148            AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
1149            mutex_has_default=yes
1150            mutex_default_type='mutex_t'
1151            mutex_default_init="DEFAULTMUTEX"
1152            mutex_header_file='thread.h'
1153            g_threads_impl="SOLARIS"
1154            ;;
1155         none)
1156            g_threads_impl="NONE"
1157            ;;
1158         *)
1159            g_threads_impl="NONE"
1160            G_THREAD_LIBS=error
1161            ;;
1162 esac
1163
1164 if test "x$G_THREAD_LIBS" = xerror; then
1165         AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
1166 fi
1167
1168 case $host in
1169   *-*-beos*)
1170     G_THREAD_LIBS="-lbe -lroot -lglib "
1171     G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
1172     ;;
1173   *)
1174     ;;
1175 esac
1176
1177 AC_MSG_CHECKING(thread related libraries)
1178 AC_MSG_RESULT($G_THREAD_LIBS)
1179
1180 dnl check for mt safe function variants and some posix functions
1181 dnl ************************************************************
1182
1183 if test x"$have_threads" != xnone; then
1184         glib_save_LIBS="$LIBS"
1185         # we are not doing the following for now, as this might require glib
1186         # to always be linked with the thread libs on some platforms.
1187         # LIBS="$LIBS $G_THREAD_LIBS"
1188         AC_CHECK_FUNCS(localtime_r)
1189         if test "$ac_cv_header_pwd_h" = "yes"; then
1190                 AC_CACHE_CHECK([for posix getpwuid_r],
1191                         ac_cv_func_posix_getpwuid_r,
1192                         [AC_TRY_RUN([#include <errno.h>
1193                                 #include <pwd.h>
1194                                 int main () { char buffer[10000];
1195                                 struct passwd pwd, *pwptr = &pwd;
1196                                 int error;
1197                                 errno = 0;
1198                                 error = getpwuid_r (0, &pwd, buffer,
1199                                         sizeof (buffer), &pwptr);
1200                                 return (error < 0 && errno == ENOSYS)
1201                                         || error == ENOSYS; }],
1202                                 [ac_cv_func_posix_getpwuid_r=yes],
1203                                 [ac_cv_func_posix_getpwuid_r=no])])
1204                 if test "$ac_cv_func_posix_getpwuid_r" = yes; then
1205                         AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
1206                                 [Have POSIX function getpwuid_r])
1207                 else
1208                         AC_CACHE_CHECK([for nonposix getpwuid_r],
1209                                 ac_cv_func_nonposix_getpwuid_r,
1210                                 [AC_TRY_LINK([#include <pwd.h>],
1211                                         [char buffer[10000];
1212                                         struct passwd pwd;
1213                                         getpwuid_r (0, &pwd, buffer,
1214                                                         sizeof (buffer));],
1215                                         [ac_cv_func_nonposix_getpwuid_r=yes],
1216                                         [ac_cv_func_nonposix_getpwuid_r=no])])
1217                         if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
1218                                 AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
1219                                         [Have non-POSIX function getpwuid_r])
1220                         fi
1221                 fi
1222         fi
1223         LIBS="$LIBS $G_THREAD_LIBS"
1224         if test x"$have_threads" = xposix; then
1225                 glib_save_CPPFLAGS="$CPPFLAGS"
1226                 CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1227                 dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
1228                 GLIB_SIZEOF([#include <pthread.h>], pthread_t, system_thread)
1229                 # This is not AC_CHECK_FUNC to also work with function
1230                 # name mangling in header files.
1231                 AC_MSG_CHECKING(for pthread_attr_setstacksize)
1232                 AC_TRY_LINK([#include <pthread.h>],
1233                         [pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
1234                         [AC_MSG_RESULT(yes)
1235                         AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE,1,
1236                                   [Have function pthread_attr_setstacksize])],
1237                         [AC_MSG_RESULT(no)])
1238                 AC_MSG_CHECKING(for minimal/maximal thread priority)
1239                 if test x"$posix_priority_min" = xnone; then
1240                         AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
1241                                 PX_PRIO_MIN],,[
1242                                 posix_priority_min=PX_PRIO_MIN
1243                                 posix_priority_max=PX_PRIO_MAX])
1244                 fi
1245                 if test x"$posix_priority_min" = xnone; then
1246                         AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
1247                                 PRI_OTHER_MIN],,[
1248                                 posix_priority_min=PRI_OTHER_MIN
1249                                 posix_priority_max=PRI_OTHER_MAX])
1250                 fi
1251                 if test x"$posix_priority_min" = x; then
1252                         AC_MSG_RESULT(none found)
1253                         AC_MSG_WARN($POSIX_NO_PRIORITIES)
1254                         posix_priority_min=-1
1255                         posix_priority_max=-1
1256                 else
1257                         AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
1258                         AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
1259                         AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])
1260                 fi
1261                 posix_yield_func=none
1262                 AC_MSG_CHECKING(for posix yield function)
1263                 for yield_func in sched_yield pthread_yield_np pthread_yield \
1264                                                         thr_yield; do
1265                         AC_TRY_LINK([#include <pthread.h>],
1266                                 [$yield_func()],
1267                                 [posix_yield_func="$yield_func"
1268                                 break])
1269                 done
1270                 if test x"$posix_yield_func" = xnone; then
1271                         AC_MSG_RESULT(none found)
1272                         AC_MSG_WARN($POSIX_NO_YIELD)
1273                         posix_yield_func="g_usleep(1000)"
1274                 else
1275                         AC_MSG_RESULT($posix_yield_func)
1276                         posix_yield_func="$posix_yield_func()"
1277                 fi
1278                 AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func,[The POSIX RT yield function])
1279                 CPPFLAGS="$glib_save_CPPFLAGS"
1280
1281                 AC_MSG_CHECKING(whether to use the PID niceness surrogate for thread priorities)
1282                 AC_TRY_RUN([#include <pthread.h>
1283                         #include <sys/types.h>
1284                         #include <unistd.h>
1285                         pid_t other_pid = 0;
1286
1287                         void* func(void* data) {other_pid = getpid();}
1288                         main()
1289                         { pthread_t t;
1290                           void *ret;
1291                           pthread_create (&t, $defattr, func, NULL);
1292                           pthread_join (t, &ret);
1293                           exit (getpid()==other_pid ||
1294                                 $posix_priority_min != $posix_priority_max);
1295                         }],
1296                         [AC_MSG_RESULT(yes)
1297                           AC_DEFINE(G_THREAD_USE_PID_SURROGATE, 1, [whether to use the PID niceness surrogate for thread priorities])
1298                         ],
1299                         [AC_MSG_RESULT(no)])
1300         else # solaris threads
1301                 GLIB_SIZEOF([#include <thread.h>], thread_t, system_thread)
1302         fi
1303
1304         LIBS="$glib_save_LIBS"
1305
1306         # now spit out all the warnings.
1307         if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
1308            test "$ac_cv_func_nonposix_getpwuid_r" != "yes"; then
1309                 AC_MSG_WARN($FUNC_NO_GETPWUID_R)
1310         fi
1311         if test "$ac_cv_func_localtime_r" != "yes"; then
1312                 AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
1313         fi
1314 else
1315         # If no thread implementation exists, we will provide enough
1316         # space for a pointer
1317         GLIB_SIZEOF(, void*, system_thread)
1318 fi
1319
1320 AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
1321                    [Source file containing theread implementation])
1322 AC_SUBST(G_THREAD_CFLAGS)
1323 AC_SUBST(G_THREAD_LIBS)
1324 AC_SUBST(G_THREAD_LIBS_EXTRA)
1325
1326 dnl **********************************************
1327 dnl *** GDefaultMutex setup and initialization ***
1328 dnl **********************************************
1329 dnl
1330 dnl if mutex_has_default = yes, we also got
1331 dnl mutex_default_type, mutex_default_init and mutex_header_file
1332 GLIB_IF_VAR_EQ(mutex_has_default, yes,
1333         glib_save_CPPFLAGS="$CPPFLAGS"
1334         glib_save_LIBS="$LIBS"
1335         LIBS="$LIBS $G_THREAD_LIBS"
1336         CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
1337         GLIB_SIZEOF([#include <$mutex_header_file>],
1338                     $mutex_default_type,
1339                     gmutex,
1340                     )
1341         GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
1342                            $mutex_default_type,
1343                            gmutex,
1344                            $glib_cv_sizeof_gmutex,
1345                            $mutex_default_init)
1346         if test x"$glib_cv_byte_contents_gmutex" = xno; then
1347                 mutex_has_default=no
1348         fi
1349         CPPFLAGS="$glib_save_CPPFLAGS"
1350         LIBS="$glib_save_LIBS"
1351         ,
1352 )
1353
1354
1355 dnl ****************************************
1356 dnl *** GLib POLL* compatibility defines ***
1357 dnl ****************************************
1358 GLIB_SYSDEFS(
1359 [#include <sys/types.h>
1360 #include <sys/poll.h>],
1361         POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
1362         glibconfig-sysdefs.h,
1363         =)
1364
1365 dnl **********************
1366 dnl *** Win32 API libs ***
1367 dnl **********************
1368
1369 case $host in
1370   *-*-cygwin*)
1371         G_LIBS_EXTRA="-luser32 -lwsock32 -lkernel32"
1372     ;;
1373   *-*-mingw*)
1374         G_LIBS_EXTRA="-lwsock32"
1375     ;;
1376   *)
1377         G_LIBS_EXTRA=""
1378     ;;
1379 esac
1380 AC_SUBST(G_LIBS_EXTRA)
1381
1382 dnl ***********************
1383 dnl *** Tests for iconv ***
1384 dnl ***********************
1385
1386 AC_ARG_WITH(libiconv, [ --with-libiconv     Use the libiconv library ],,with_libiconv=maybe)
1387
1388 found_iconv=no
1389
1390 if test "x$with_libiconv" != "xyes" ; then
1391    #
1392    # Check in the C library
1393    #
1394    AC_CHECK_FUNC(iconv_open, with_libiconv=no; found_iconv=yes)
1395 fi
1396
1397 if test "x$with_libiconv" != "xno" ; then
1398    #
1399    # Check for libiconv
1400    #
1401    AC_CHECK_LIB(iconv, libiconv_open, with_libiconv=yes; found_iconv=yes)
1402 fi
1403
1404 if test "x$found_iconv" = "xno" ; then
1405    AC_MSG_ERROR([*** No iconv() implementation found in C library or libiconv])
1406 fi
1407
1408 if test "x$with_libiconv" = "xyes" ; then
1409   ICONV_LIBS="-liconv"
1410   AC_DEFINE(USE_LIBICONV)
1411 fi
1412 AC_SUBST(ICONV_LIBS)
1413
1414 dnl If the system doesn't define EILSEQ, we should define EILSEQ ourselves
1415 dnl since we need it for g_iconv()
1416
1417 AC_MSG_CHECKING([for EILSEQ])
1418 AC_TRY_COMPILE([
1419 #include <errno.h>
1420 ],
1421 [
1422 int error = EILSEQ;
1423 ], have_eilseq=yes, have_eilseq=no);
1424 AC_MSG_RESULT($have_eilseq)
1425
1426 dnl **************************
1427 dnl *** Checks for gtk-doc ***
1428 dnl **************************
1429
1430 AC_ARG_WITH(html-dir, [  --with-html-dir=PATH path to installed docs ])
1431
1432 if test "x$with_html_dir" = "x" ; then
1433   HTML_DIR='${datadir}/gtk-doc/html'
1434 else
1435   HTML_DIR=$with_html_dir
1436 fi
1437
1438 AC_SUBST(HTML_DIR)
1439
1440 AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
1441
1442 gtk_doc_min_version=0.6
1443 if $GTKDOC ; then
1444     gtk_doc_version=`gtkdoc-mkdb --version`
1445     AC_MSG_CHECKING([gtk-doc version ($gtk_doc_version) >= $gtk_doc_min_version])
1446     if perl <<EOF ; then
1447       exit (("$gtk_doc_version" =~ /^[[0-9]]+\.[[0-9]]+$/) &&
1448             ("$gtk_doc_version" >= "$gtk_doc_min_version") ? 0 : 1);
1449 EOF
1450       AC_MSG_RESULT(yes)
1451    else
1452       AC_MSG_RESULT(no)
1453       GTKDOC=false
1454    fi
1455 fi
1456
1457 AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
1458 AC_SUBST(HAVE_GTK_DOC)
1459
1460 AC_CHECK_PROG(DB2HTML, db2html, true, false)
1461 AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
1462
1463 dnl Let people disable the gtk-doc stuff.
1464 AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc  Use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)
1465
1466 if test x$enable_gtk_doc = xauto ; then
1467   if test x$GTKDOC = xtrue ; then
1468     enable_gtk_doc=yes
1469   else
1470     enable_gtk_doc=no
1471   fi
1472 fi
1473
1474 dnl NOTE: We need to use a separate automake conditional for this
1475 dnl       to make this work with the tarballs.
1476 AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
1477
1478 dnl ******************************
1479 dnl *** output the whole stuff ***
1480 dnl ******************************
1481
1482 AC_OUTPUT_COMMANDS([
1483
1484 ## Generate `glibconfig.h' in two cases
1485 ## 1. `config.status' is run either explicitly, or via configure.
1486 ##     Esp. not when it is run in `Makefile' to generate makefiles and
1487 ##     config.h
1488 ## 2. CONFIG_OTHER is set explicitly
1489 ##
1490 ## Case 1 is difficult.  We know that `automake' sets one of
1491 ## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
1492 ## only when AM_CONFIG_HEADER is set, however.
1493
1494 if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
1495   # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
1496   CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
1497 fi
1498 case "$CONFIG_OTHER" in
1499 *glibconfig.h*)
1500         echo creating glibconfig.h
1501         outfile=glibconfig.h-tmp
1502         cat > $outfile <<\_______EOF
1503 /* glibconfig.h
1504  *
1505  * This is a generated file.  Please modify 'configure.in'
1506  */
1507
1508 #ifndef __G_LIBCONFIG_H__
1509 #define __G_LIBCONFIG_H__
1510
1511 #include <gmacros.h>
1512
1513 _______EOF
1514
1515         if test x$glib_limits_h = xyes; then
1516           echo '#include <limits.h>' >> $outfile
1517         fi
1518         if test x$glib_float_h = xyes; then
1519           echo '#include <float.h>' >> $outfile
1520         fi
1521         if test x$glib_values_h = xyes; then
1522           echo '#include <values.h>' >> $outfile
1523         fi
1524         if test "$glib_header_alloca_h" = "yes"; then
1525           echo '#define GLIB_HAVE_ALLOCA_H' >> $outfile
1526         fi
1527         if test x$glib_sys_poll_h = xyes; then
1528           echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
1529         fi
1530
1531         cat >> $outfile <<_______EOF
1532
1533 G_BEGIN_DECLS
1534
1535 #define G_MINFLOAT      $glib_mf
1536 #define G_MAXFLOAT      $glib_Mf
1537 #define G_MINDOUBLE     $glib_md
1538 #define G_MAXDOUBLE     $glib_Md
1539 #define G_MINSHORT      $glib_ms
1540 #define G_MAXSHORT      $glib_Ms
1541 #define G_MAXUSHORT     $glib_Mus
1542 #define G_MININT        $glib_mi
1543 #define G_MAXINT        $glib_Mi
1544 #define G_MAXUINT       $glib_Mui
1545 #define G_MINLONG       $glib_ml
1546 #define G_MAXLONG       $glib_Ml
1547 #define G_MAXULONG      $glib_Mul
1548
1549 _______EOF
1550
1551
1552         ### this should always be true in a modern C/C++ compiler
1553         cat >>$outfile <<_______EOF
1554 typedef signed char gint8;
1555 typedef unsigned char guint8;
1556 _______EOF
1557
1558
1559         if test -n "$gint16"; then
1560           cat >>$outfile <<_______EOF
1561 typedef signed $gint16 gint16;
1562 typedef unsigned $gint16 guint16;
1563 #define G_GINT16_FORMAT $gint16_format
1564 #define G_GUINT16_FORMAT $guint16_format
1565 _______EOF
1566         fi
1567
1568
1569         if test -n "$gint32"; then
1570           cat >>$outfile <<_______EOF
1571 typedef signed $gint32 gint32;
1572 typedef unsigned $gint32 guint32;
1573 #define G_GINT32_FORMAT $gint32_format
1574 #define G_GUINT32_FORMAT $guint32_format
1575 _______EOF
1576         fi
1577
1578
1579         if test -n "$gint64"; then
1580           cat >>$outfile <<_______EOF
1581 #define G_HAVE_GINT64 1
1582
1583 ${glib_extension}typedef signed $gint64 gint64;
1584 ${glib_extension}typedef unsigned $gint64 guint64;
1585
1586 #define G_GINT64_CONSTANT(val)  $gint64_constant
1587 _______EOF
1588                 if test -n "$gint64_format"; then
1589           cat >>$outfile <<_______EOF
1590 #define G_GINT64_FORMAT $gint64_format
1591 #define G_GUINT64_FORMAT $guint64_format
1592 _______EOF
1593                 fi
1594         fi
1595
1596         cat >>$outfile <<_______EOF
1597
1598 #define GLIB_SIZEOF_VOID_P $glib_void_p
1599 #define GLIB_SIZEOF_LONG   $glib_long
1600
1601 _______EOF
1602
1603         case x$glib_size_t in
1604         x2) echo "typedef gint16  gssize;" >> $outfile
1605             echo "typedef guint16 gsize;"  >> $outfile
1606             ;;
1607         x4) echo "typedef gint32  gssize;" >> $outfile
1608             echo "typedef guint32 gsize;"  >> $outfile
1609             ;;
1610         x8) echo "typedef gint64  gssize;" >> $outfile
1611             echo "typedef guint64 gsize;"  >> $outfile
1612             ;;
1613         *)  echo "#error size of size_t is unknown" >> $outfile
1614             ;;
1615         esac
1616
1617         if test -z "$glib_unknown_void_p"; then
1618           cat >>$outfile <<_______EOF
1619
1620 #define GPOINTER_TO_INT(p)      ((gint)  ${glib_gpi_cast} (p))
1621 #define GPOINTER_TO_UINT(p)     ((guint) ${glib_gpui_cast} (p))
1622
1623 #define GINT_TO_POINTER(i)      ((gpointer) ${glib_gpi_cast} (i))
1624 #define GUINT_TO_POINTER(u)     ((gpointer) ${glib_gpui_cast} (u))
1625 _______EOF
1626         else
1627           echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
1628         fi
1629
1630
1631
1632         cat >>$outfile <<_______EOF
1633 $glib_atexit
1634 $glib_memmove
1635 $glib_defines
1636 $glib_os
1637
1638 $glib_vacopy
1639
1640 #ifdef  __cplusplus
1641 #define G_HAVE_INLINE   1
1642 #else   /* !__cplusplus */
1643 $glib_inline
1644 #endif  /* !__cplusplus */
1645 _______EOF
1646
1647         if test x$g_have_iso_varargs = xyes ; then
1648                 cat >>$outfile <<_______EOF
1649
1650 #define G_HAVE_ISO_VARARGS 1
1651 _______EOF
1652         fi
1653         if test x$g_have_gnuc_varargs = xyes ; then
1654                 cat >>$outfile <<_______EOF
1655
1656 #define G_HAVE_GNUC_VARARGS 1
1657 _______EOF
1658         fi
1659
1660
1661         echo >>$outfile
1662         if test x$g_have_eilseq = xno; then
1663                 cat >>$outfile <<_______EOF
1664 #ifndef EILSEQ
1665 /* On some systems, like SunOS and NetBSD, EILSEQ is not defined.
1666  * The correspondence between this and the corresponding definition
1667  * in libiconv is essential.
1668  */
1669 #  define EILSEQ ENOENT
1670 #endif
1671 _______EOF
1672
1673         fi
1674
1675         echo >>$outfile
1676         if test x$g_mutex_has_default = xyes; then
1677                 cat >>$outfile <<_______EOF
1678 $g_enable_threads_def G_THREADS_ENABLED
1679 #define G_THREADS_IMPL_$g_threads_impl_def
1680 typedef struct _GStaticMutex GStaticMutex;
1681 struct _GStaticMutex
1682 {
1683   struct _GMutex *runtime_mutex;
1684   union {
1685     char   pad[$g_mutex_sizeof];
1686     double dummy_double;
1687     void  *dummy_pointer;
1688     long   dummy_long;
1689   } static_mutex;
1690 };
1691 #define G_STATIC_MUTEX_INIT     { NULL, { { $g_mutex_contents} } }
1692 #define g_static_mutex_get_mutex(mutex) \
1693   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
1694    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
1695 _______EOF
1696         else
1697                 cat >>$outfile <<_______EOF
1698 $g_enable_threads_def G_THREADS_ENABLED
1699 #define G_THREADS_IMPL_$g_threads_impl_def
1700 typedef struct _GMutex* GStaticMutex;
1701 #define G_STATIC_MUTEX_INIT NULL
1702 #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
1703 _______EOF
1704         fi
1705
1706         cat >>$outfile <<_______EOF
1707 /* This represents a system thread as used by the implementation. An
1708  * alien implementaion, as loaded by g_thread_init can only count on
1709  * "sizeof (gpointer)" bytes to store their info. We however need more
1710  * for some of our native implementations. */
1711 typedef union _GSystemThread GSystemThread;
1712 union _GSystemThread
1713 {
1714   char   data[$g_system_thread_sizeof];
1715   double dummy_double;
1716   void  *dummy_pointer;
1717   long   dummy_long;
1718 };
1719 _______EOF
1720
1721         echo >>$outfile
1722         g_bit_sizes="16 32"
1723         if test -n "$gint64"; then
1724           g_bit_sizes="$g_bit_sizes 64"
1725         fi
1726         for bits in $g_bit_sizes; do
1727           cat >>$outfile <<_______EOF
1728 #define GINT${bits}_TO_${g_bs_native}(val)      ((gint${bits}) (val))
1729 #define GUINT${bits}_TO_${g_bs_native}(val)     ((guint${bits}) (val))
1730 #define GINT${bits}_TO_${g_bs_alien}(val)       ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
1731 #define GUINT${bits}_TO_${g_bs_alien}(val)      (GUINT${bits}_SWAP_LE_BE (val))
1732 _______EOF
1733         done
1734
1735         cat >>$outfile <<_______EOF
1736 #define GLONG_TO_LE(val)        ((glong) GINT${glongbits}_TO_LE (val))
1737 #define GULONG_TO_LE(val)       ((gulong) GUINT${glongbits}_TO_LE (val))
1738 #define GLONG_TO_BE(val)        ((glong) GINT${glongbits}_TO_BE (val))
1739 #define GULONG_TO_BE(val)       ((gulong) GUINT${glongbits}_TO_BE (val))
1740 #define GINT_TO_LE(val)         ((gint) GINT${gintbits}_TO_LE (val))
1741 #define GUINT_TO_LE(val)        ((guint) GUINT${gintbits}_TO_LE (val))
1742 #define GINT_TO_BE(val)         ((gint) GINT${gintbits}_TO_BE (val))
1743 #define GUINT_TO_BE(val)        ((guint) GUINT${gintbits}_TO_BE (val))
1744 #define G_BYTE_ORDER $g_byte_order
1745
1746 _______EOF
1747
1748         if test -r glibconfig-sysdefs.h; then
1749           cat glibconfig-sysdefs.h >>$outfile
1750         fi
1751
1752         cat >>$outfile <<_______EOF
1753
1754 #define G_MODULE_SUFFIX "$g_module_suffix"
1755
1756 G_END_DECLS
1757
1758 #endif /* GLIBCONFIG_H */
1759 _______EOF
1760
1761
1762         if cmp -s $outfile glibconfig.h; then
1763           echo glibconfig.h is unchanged
1764           rm -f $outfile
1765         else
1766           mv $outfile glibconfig.h
1767         fi ;;
1768 esac
1769 ],[
1770
1771 # Note that if two cases are the same, case goes with the first one.
1772 # Note also that this is inside an AC_OUTPUT_COMMAND.  We do not depend
1773 # on variable expansion in case labels.  Look at the generated config.status
1774 # for a hint.
1775
1776 glib_header_alloca_h="$ac_cv_header_alloca_h"
1777
1778 case xyes in
1779 x$ac_cv_header_float_h)
1780   glib_float_h=yes
1781   glib_mf=FLT_MIN glib_Mf=FLT_MAX
1782   glib_md=DBL_MIN glib_Md=DBL_MAX
1783   ;;
1784 x$ac_cv_header_values_h)
1785   glib_values_h=yes
1786   glib_mf=MINFLOAT  glib_Mf=MAXFLOAT
1787   glib_md=MINDOUBLE glib_Md=MAXDOUBLE
1788   ;;
1789 esac
1790
1791 case xyes in
1792 x$ac_cv_header_limits_h)
1793   glib_limits_h=yes
1794   glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
1795   glib_mi=INT_MIN  glib_Mi=INT_MAX  glib_Mui=UINT_MAX
1796   glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
1797   ;;
1798 x$ac_cv_header_values_h)
1799   glib_values_h=yes
1800   glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
1801   glib_mi=MININT   glib_Mi=MAXINT   glib_Mui="(((guint)G_MAXINT)*2+1)"
1802   glib_ml=MINLONG  glib_Ml=MAXLONG  glib_Mul="(((gulong)G_MAXLONG)*2+1)"
1803   ;;
1804 esac
1805
1806 if test x$ac_cv_header_sys_poll_h = xyes ; then
1807   glib_sys_poll_h=yes
1808 fi
1809
1810 case 2 in
1811 $ac_cv_sizeof_short)
1812   gint16=short
1813   gint16_format='"hi"'
1814   guint16_format='"hu"'
1815   ;;
1816 $ac_cv_sizeof_int)
1817   gint16=int
1818   gint16_format='"i"'
1819   guint16_format='"u"'
1820   ;;
1821 esac
1822 case 4 in
1823 $ac_cv_sizeof_short)
1824   gint32=short
1825   gint32_format='"hi"'
1826   guint32_format='"hu"'
1827   ;;
1828 $ac_cv_sizeof_int)
1829   gint32=int
1830   gint32_format='"i"'
1831   guint32_format='"u"'
1832   ;;
1833 $ac_cv_sizeof_long)
1834   gint32=long
1835   gint32_format='"li"'
1836   guint32_format='"lu"'
1837   ;;
1838 esac
1839 case 8 in
1840 $ac_cv_sizeof_int)
1841   gint64=int
1842   gint64_format='"i"'
1843   guint64_format='"u"'
1844   glib_extension=
1845   gint64_constant='(val)'
1846   ;;
1847 $ac_cv_sizeof_long)
1848   gint64=long
1849   gint64_format='"li"'
1850   guint64_format='"lu"'
1851   glib_extension=
1852   gint64_constant='(val##L)'
1853   ;;
1854 $ac_cv_sizeof_long_long)
1855   gint64='long long'
1856   if test -n "$glib_cv_long_long_format"; then
1857     gint64_format='"'$glib_cv_long_long_format'i"'
1858     guint64_format='"'$glib_cv_long_long_format'u"'
1859   fi
1860   glib_extension='G_GNUC_EXTENSION '
1861   gint64_constant='(G_GNUC_EXTENSION (val##LL))'
1862   ;;
1863 esac
1864 glib_size_t=$glib_cv_sizeof_size_t
1865 glib_void_p=$ac_cv_sizeof_long
1866 glib_long=$ac_cv_sizeof_void_p
1867
1868 gintbits=`expr $ac_cv_sizeof_int \* 8`
1869 glongbits=`expr $ac_cv_sizeof_long \* 8`
1870
1871
1872 case $ac_cv_sizeof_void_p in
1873 $ac_cv_sizeof_int)      glib_gpi_cast=''        glib_gpui_cast=''         ;;
1874 $ac_cv_sizeof_long)     glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
1875 *)                      glib_unknown_void_p=yes ;;
1876 esac
1877
1878
1879 case xyes in
1880 x$ac_cv_func_atexit)
1881   glib_atexit="
1882 #ifdef NeXT /* @#%@! NeXTStep */
1883 # define g_ATEXIT(proc) (!atexit (proc))
1884 #else
1885 # define g_ATEXIT(proc) (atexit (proc))
1886 #endif"
1887   ;;
1888 x$ac_cv_func_on_exit)
1889   glib_atexit="
1890 #define g_ATEXIT(proc)  (on_exit ((void (*)(int, void*))(proc), NULL))"
1891   ;;
1892 esac
1893
1894 case xyes in
1895 x$ac_cv_func_memmove)
1896   glib_memmove='
1897 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
1898   ;;
1899 x$glib_cv_working_bcopy)
1900   glib_memmove="
1901 /* memmove isn't available, but bcopy can copy overlapping memory regions */
1902 #define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
1903   ;;
1904 *)
1905   glib_memmove="
1906 /* memmove isn't found and bcopy can't copy overlapping memory regions,
1907  * so we have to roll our own copy routine. */
1908 void g_memmove (void* dest, const void * src, unsigned long len);"
1909   ;;
1910 esac
1911
1912 glib_defines="
1913 #define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
1914 #define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
1915 #define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
1916 "
1917
1918 case xyes in
1919 x$glib_cv_va_copy)      glib_vacopy='#define G_VA_COPY  va_copy' ;;
1920 x$glib_cv___va_copy)    glib_vacopy='#define G_VA_COPY  __va_copy' ;;
1921 *)                      glib_vacopy=''
1922 esac
1923
1924 if test x$glib_cv_va_val_copy = xno; then
1925   glib_vacopy="\$glib_vacopy
1926 #define G_VA_COPY_AS_ARRAY 1"
1927 fi
1928
1929 if test x$glib_cv_hasinline = xyes; then
1930     glib_inline='#define G_HAVE_INLINE 1'
1931 fi
1932 if test x$glib_cv_has__inline = xyes; then
1933     glib_inline="\$glib_inline
1934 #define G_HAVE___INLINE 1"
1935 fi
1936 if test x$glib_cv_has__inline__ = xyes; then
1937     glib_inline="\$glib_inline
1938 #define G_HAVE___INLINE__ 1"
1939 fi
1940
1941 g_have_gnuc_varargs=$g_have_gnuc_varargs
1942 g_have_iso_varargs=$g_have_iso_varargs
1943
1944 case xyes in
1945 x$ac_cv_c_bigendian)
1946   g_byte_order=G_BIG_ENDIAN
1947   g_bs_native=BE
1948   g_bs_alien=LE
1949   ;;
1950 *)
1951   g_byte_order=G_LITTLE_ENDIAN
1952   g_bs_native=LE
1953   g_bs_alien=BE
1954   ;;
1955 esac
1956
1957 g_have_eilseq=$have_eilseq
1958
1959 case x$have_threads in
1960 xnone)  g_enable_threads_def="#undef";;
1961 *)      g_enable_threads_def="#define";;
1962 esac
1963
1964 g_threads_impl_def=$g_threads_impl
1965
1966 g_mutex_has_default="$mutex_has_default"
1967 g_mutex_sizeof="$glib_cv_sizeof_gmutex"
1968 g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
1969 g_mutex_contents="$glib_cv_byte_contents_gmutex"
1970
1971 g_module_suffix="$glib_gmodule_suffix"
1972
1973 case $host in
1974   *-*-beos*)
1975     glib_os="#define G_OS_BEOS"
1976     ;;
1977   *-*-cygwin*)
1978     glib_os="#define G_OS_UNIX
1979 #define G_PLATFORM_WIN32
1980 #define G_WITH_CYGWIN"
1981     ;;
1982   *-*-mingw*)
1983     glib_os="#define G_OS_WIN32
1984 #define G_PLATFORM_WIN32"
1985     ;;
1986   *)
1987     glib_os="#define G_OS_UNIX"
1988     ;;
1989 esac
1990 ])
1991
1992 AC_OUTPUT([
1993 glib-2.0.pc
1994 glib-config-2.0
1995 gmodule-2.0.pc
1996 gthread-2.0.pc
1997 gobject-2.0.pc
1998 glib.spec
1999 Makefile
2000 build/Makefile
2001 build/win32/Makefile
2002 gmodule/gmoduleconf.h
2003 gmodule/Makefile
2004 gobject/Makefile
2005 gthread/Makefile
2006 po/Makefile.in
2007 docs/Makefile
2008 docs/glib-config.1
2009 docs/reference/Makefile
2010 docs/reference/glib/Makefile
2011 docs/reference/gobject/Makefile
2012 tests/Makefile
2013 m4macros/Makefile
2014 ],[case "$CONFIG_FILES" in
2015 *glib-config-2.0*)chmod +x glib-config-2.0;;
2016 esac
2017 echo ""
2018 echo " *** IMPORTANT *** "
2019 echo ""
2020 echo "This is a development version of GLib.  You should be using a stable"
2021 echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/.  The"
2022 echo "version you just configured is meant for developers of GLib only:"
2023 echo ""
2024 echo "  * You should not base stable software on this version of GLib."
2025 echo "  * GNOME developers should use a stable version of GLib."
2026 echo ""
2027 echo " *** You should be using GLib 1.2 instead. ***"
2028 ])