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