configure.in

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