configure.in

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