configure.in

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