mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-25 23:16:14 +01:00
7633908c93
2000-09-29 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, glib.h: Added errorcheck mutexes. These are
activated through the preprocessor symbol
G_ERRORCHECK_MUTEXES. Need to add an extra word to StaticMutex in
order to achieve this. g_(static_)mutex_* functions instrument the
mutex operations with mutex name and location, when compiled with
-DG_ERRORCHECK_MUTEXES. g_thread_init activates the errorcheck
mutexes, when compiled with -DG_ERRORCHECK_MUTEXES.
* gthread/gthread-impl.c: Added errorcheck mutexes. New
exported function
g_thread_init_with_errorcheck_mutexes, which is called instead of
g_thread_init, when compiled with -DG_ERRORCHECK_MUTEXES. New
static functions
g_mutex_(new|lock|trylock|unlock|free)_errorcheck_impl to
implement errorcheck mutexes.
* gthread/gthread-posix.impl.c, gthread/gthread-solaris-impl.c:
Define the size of a mutex.
1671 lines
45 KiB
Plaintext
1671 lines
45 KiB
Plaintext
dnl ***********************************
|
|
dnl *** include special GLib macros ***
|
|
dnl ***********************************
|
|
builtin(include, acglib.m4)dnl
|
|
|
|
# require autoconf 2.13
|
|
AC_PREREQ(2.13)
|
|
|
|
# Process this file with autoconf to produce a configure script.
|
|
AC_INIT(glist.c)
|
|
|
|
# Save this value here, since automake will set cflags later
|
|
cflags_set=${CFLAGS+set}
|
|
|
|
# we rewrite this file
|
|
rm -f glibconfig-sysdefs.h
|
|
|
|
dnl we need to AC_DIVERT_PUSH/AC_DIVERT_POP these variable definitions so they
|
|
dnl are available for $ac_help expansion (don't we all *love* autoconf?)
|
|
AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
|
|
#
|
|
# The following version number definitions apply to GLib, GModule, GObject and GThread
|
|
# as a whole, so if changes occoured in any of them, they are all
|
|
# treated with the same interface and binary age.
|
|
#
|
|
# Making releases:
|
|
# GLIB_MICRO_VERSION += 1;
|
|
# GLIB_INTERFACE_AGE += 1;
|
|
# GLIB_BINARY_AGE += 1;
|
|
# if any functions have been added, set GLIB_INTERFACE_AGE to 0.
|
|
# if backwards compatibility has been broken,
|
|
# set GLIB_BINARY_AGE _and_ GLIB_INTERFACE_AGE to 0.
|
|
#
|
|
GLIB_MAJOR_VERSION=1
|
|
GLIB_MINOR_VERSION=3
|
|
GLIB_MICRO_VERSION=1
|
|
GLIB_INTERFACE_AGE=0
|
|
GLIB_BINARY_AGE=0
|
|
GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
|
|
dnl
|
|
AC_DIVERT_POP()dnl
|
|
|
|
AC_SUBST(GLIB_MAJOR_VERSION)
|
|
AC_SUBST(GLIB_MINOR_VERSION)
|
|
AC_SUBST(GLIB_MICRO_VERSION)
|
|
AC_SUBST(GLIB_VERSION)
|
|
AC_SUBST(GLIB_INTERFACE_AGE)
|
|
AC_SUBST(GLIB_BINARY_AGE)
|
|
|
|
# libtool versioning
|
|
LT_RELEASE=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION
|
|
LT_CURRENT=`expr $GLIB_MICRO_VERSION - $GLIB_INTERFACE_AGE`
|
|
LT_REVISION=$GLIB_INTERFACE_AGE
|
|
LT_AGE=`expr $GLIB_BINARY_AGE - $GLIB_INTERFACE_AGE`
|
|
AC_SUBST(LT_RELEASE)
|
|
AC_SUBST(LT_CURRENT)
|
|
AC_SUBST(LT_REVISION)
|
|
AC_SUBST(LT_AGE)
|
|
|
|
VERSION=$GLIB_VERSION
|
|
PACKAGE=glib
|
|
|
|
AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
|
|
|
|
# Specify a configuration file
|
|
AM_CONFIG_HEADER(config.h)
|
|
|
|
AC_DEFINE_UNQUOTED(GLIB_MAJOR_VERSION, $GLIB_MAJOR_VERSION)
|
|
AC_DEFINE_UNQUOTED(GLIB_MINOR_VERSION, $GLIB_MINOR_VERSION)
|
|
AC_DEFINE_UNQUOTED(GLIB_MICRO_VERSION, $GLIB_MICRO_VERSION)
|
|
AC_DEFINE_UNQUOTED(GLIB_INTERFACE_AGE, $GLIB_INTERFACE_AGE)
|
|
AC_DEFINE_UNQUOTED(GLIB_BINARY_AGE, $GLIB_BINARY_AGE)
|
|
|
|
dnl Initialize libtool
|
|
AM_PROG_LIBTOOL
|
|
|
|
dnl Initialize maintainer mode
|
|
AM_MAINTAINER_MODE
|
|
|
|
AC_CANONICAL_HOST
|
|
|
|
AC_MSG_CHECKING(for the BeOS)
|
|
case $host in
|
|
*-*-beos*)
|
|
glib_native_beos="yes"
|
|
;;
|
|
*)
|
|
glib_native_beos="no"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT([$glib_native_beos])
|
|
|
|
dnl figure debugging default, prior to $ac_help setup
|
|
dnl
|
|
AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
|
|
if test `expr $GLIB_MINOR_VERSION \% 2` = 1 ; then
|
|
debug_default=yes
|
|
else
|
|
debug_default=minimum
|
|
fi
|
|
AC_DIVERT_POP()dnl
|
|
|
|
dnl declare --enable-* args and collect ac_help strings
|
|
AC_ARG_ENABLE(debug, [ --enable-debug=[no/minimum/yes] turn on debugging [default=$debug_default]],,enable_debug=$debug_default)
|
|
AC_ARG_ENABLE(msg-prefix, [ --enable-msg-prefix turn on program name and PID prefixing of messages and warnings],,enable_msg_prefix=no)
|
|
AC_ARG_ENABLE(mem_check, [ --enable-mem-check turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
|
|
AC_ARG_ENABLE(mem_profile, [ --enable-mem-profile turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)
|
|
AC_ARG_ENABLE(gc_friendly, [ --enable-gc-friendly turn on garbage collector friendliness [default=no]],,enable_gc_friendly=no)
|
|
AC_ARG_ENABLE(ansi, [ --enable-ansi turn on strict ansi [default=no]],
|
|
, enable_ansi=no)
|
|
AC_ARG_ENABLE(threads, [ --enable-threads turn on basic thread support [default=yes]
|
|
([=no] will override --with-threads)],,enable_threads=yes)
|
|
|
|
if test "x$enable_threads" != "xyes"; then
|
|
enable_threads=no
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether to enable memory checking)
|
|
if test "x$enable_mem_check" = "xyes"; then
|
|
AC_DEFINE(ENABLE_MEM_CHECK, 1)
|
|
AC_SUBST(ENABLE_MEM_CHECK)
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether to enable memory profiling)
|
|
if test "x$enable_mem_profile" = "xyes"; then
|
|
AC_DEFINE(ENABLE_MEM_PROFILE, 1)
|
|
AC_SUBST(ENABLE_MEM_PROFILE)
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether to enable garbage collector friendliness)
|
|
if test "x$enable_gc_friendly" = "xyes"; then
|
|
AC_DEFINE(ENABLE_GC_FRIENDLY, 1)
|
|
AC_SUBST(ENABLE_GC_FRIENDLY)
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
if test "x$enable_debug" = "xyes"; then
|
|
test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
|
|
GLIB_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
|
|
else
|
|
if test "x$enable_debug" = "xno"; then
|
|
GLIB_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS"
|
|
fi
|
|
fi
|
|
|
|
AC_DEFINE_UNQUOTED(G_COMPILED_WITH_DEBUGGING, "${enable_debug}")
|
|
|
|
if test "x$enable_msg_prefix" = "xyes"; then
|
|
AC_DEFINE_UNQUOTED(G_ENABLE_MSG_PREFIX, 1)
|
|
fi
|
|
|
|
# Checks for programs.
|
|
AC_PROG_CC
|
|
AM_PROG_CC_STDC
|
|
AC_PROG_INSTALL
|
|
|
|
changequote(,)dnl
|
|
if test "x$GCC" = "xyes"; then
|
|
case " $CFLAGS " in
|
|
*[\ \ ]-Wall[\ \ ]*) ;;
|
|
*) CFLAGS="$CFLAGS -Wall" ;;
|
|
esac
|
|
|
|
if test "x$enable_ansi" = "xyes"; then
|
|
case " $CFLAGS " in
|
|
*[\ \ ]-ansi[\ \ ]*) ;;
|
|
*) CFLAGS="$CFLAGS -ansi" ;;
|
|
esac
|
|
|
|
case " $CFLAGS " in
|
|
*[\ \ ]-pedantic[\ \ ]*) ;;
|
|
*) CFLAGS="$CFLAGS -pedantic" ;;
|
|
esac
|
|
fi
|
|
fi
|
|
changequote([,])dnl
|
|
|
|
dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
|
|
AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
|
|
glib_save_LIBS=$LIBS
|
|
LIBS="$LIBS -lm"
|
|
AC_TRY_RUN([#include <math.h>
|
|
int main (void) { return (log(1) != log(1.)); }],
|
|
AC_MSG_RESULT(none needed),
|
|
glib_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$CFLAGS -std1"
|
|
AC_TRY_RUN([#include <math.h>
|
|
int main (void) { return (log(1) != log(1.)); }],
|
|
AC_MSG_RESULT(-std1),
|
|
AC_MSG_RESULT()
|
|
CFLAGS=$glib_save_CFLAGS
|
|
AC_MSG_WARN(
|
|
[No ANSI prototypes found in library. (-std1 didn't work.)])
|
|
)
|
|
)
|
|
LIBS=$glib_save_LIBS
|
|
|
|
dnl NeXTStep cc seems to need this
|
|
AC_MSG_CHECKING([for extra flags for POSIX compliance])
|
|
AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
|
|
AC_MSG_RESULT(none needed),
|
|
glib_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$CFLAGS -posix"
|
|
AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
|
|
AC_MSG_RESULT(-posix),
|
|
AC_MSG_RESULT()
|
|
CFLAGS=$glib_save_CFLAGS
|
|
AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))
|
|
|
|
# Checks for header files.
|
|
AC_HEADER_STDC
|
|
|
|
# Checks for library functions.
|
|
AC_FUNC_VPRINTF
|
|
|
|
AC_FUNC_ALLOCA
|
|
|
|
AC_CHECK_FUNCS(atexit on_exit)
|
|
|
|
AC_CHECK_SIZEOF(char)
|
|
AC_CHECK_SIZEOF(short)
|
|
AC_CHECK_SIZEOF(long)
|
|
AC_CHECK_SIZEOF(int)
|
|
AC_CHECK_SIZEOF(void *)
|
|
AC_CHECK_SIZEOF(long long)
|
|
|
|
if test x$ac_cv_sizeof_long_long = x8; then
|
|
# long long is a 64 bit integer.
|
|
AC_MSG_CHECKING(for format to printf and scanf a gint64)
|
|
AC_CACHE_VAL(glib_cv_long_long_format,[
|
|
for format in ll q; do
|
|
AC_TRY_RUN([#include <stdio.h>
|
|
int main()
|
|
{
|
|
long long b, a = -0x3AFAFAFAFAFAFAFALL;
|
|
char buffer[1000];
|
|
sprintf (buffer, "%${format}u", a);
|
|
sscanf (buffer, "%${format}u", &b);
|
|
exit (b!=a);
|
|
}
|
|
],
|
|
glib_cv_long_long_format=${format}
|
|
break)
|
|
done])
|
|
if test -n "$glib_cv_long_long_format"; then
|
|
AC_MSG_RESULT(%${glib_cv_long_long_format}i)
|
|
else
|
|
AC_MSG_RESULT(none)
|
|
fi
|
|
fi
|
|
|
|
dnl long doubles were not used, and a portability problem
|
|
dnl AC_C_LONG_DOUBLE
|
|
AC_C_CONST
|
|
|
|
dnl AC_C_INLINE is useless to us since it bails out too early, we need to
|
|
dnl truely know which ones of `inline', `__inline' and `__inline__' are
|
|
dnl actually supported.
|
|
AC_MSG_CHECKING(for __inline)
|
|
AC_CACHE_VAL(glib_cv_has__inline,[
|
|
AC_TRY_RUN([
|
|
__inline int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_has__inline=yes
|
|
,
|
|
glib_cv_has__inline=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv_has__inline)
|
|
case x$glib_cv_has__inline in
|
|
xyes) AC_DEFINE(G_HAVE___INLINE)
|
|
esac
|
|
AC_MSG_CHECKING(for __inline__)
|
|
AC_CACHE_VAL(glib_cv_has__inline__,[
|
|
AC_TRY_RUN([
|
|
__inline__ int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_has__inline__=yes
|
|
,
|
|
glib_cv_has__inline__=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv_has__inline__)
|
|
case x$glib_cv_has__inline__ in
|
|
xyes) AC_DEFINE(G_HAVE___INLINE__)
|
|
esac
|
|
AC_MSG_CHECKING(for inline)
|
|
AC_CACHE_VAL(glib_cv_hasinline,[
|
|
AC_TRY_RUN([
|
|
inline int foo () { return 0; }
|
|
int main () { return foo (); }
|
|
],
|
|
glib_cv_hasinline=yes
|
|
,
|
|
glib_cv_hasinline=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv_hasinline)
|
|
case x$glib_cv_hasinline in
|
|
xyes) AC_DEFINE(G_HAVE_INLINE)
|
|
esac
|
|
|
|
# check for bytesex stuff
|
|
AC_C_BIGENDIAN
|
|
|
|
# check for header files
|
|
AC_CHECK_HEADERS(float.h, AC_DEFINE(HAVE_FLOAT_H))
|
|
AC_CHECK_HEADERS(limits.h, AC_DEFINE(HAVE_LIMITS_H))
|
|
AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
|
|
AC_CHECK_HEADERS(sys/param.h, AC_DEFINE(HAVE_SYS_PARAM_H))
|
|
AC_CHECK_HEADERS(sys/poll.h, AC_DEFINE(HAVE_SYS_POLL_H))
|
|
AC_CHECK_HEADERS(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
|
|
AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
|
|
AC_CHECK_HEADERS(sys/times.h, AC_DEFINE(HAVE_SYS_TIMES_H))
|
|
AC_CHECK_HEADERS(unistd.h, AC_DEFINE(HAVE_UNISTD_H))
|
|
AC_CHECK_HEADERS(values.h, AC_DEFINE(HAVE_VALUES_H))
|
|
AC_CHECK_HEADERS(stdint.h, AC_DEFINE(HAVE_VALUES_H))
|
|
|
|
AC_MSG_CHECKING(whether make is GNU Make)
|
|
STRIP_BEGIN=
|
|
STRIP_END=
|
|
if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
|
|
STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
|
|
STRIP_END=')'
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
STRIP_DUMMY=
|
|
AC_SUBST(STRIP_DUMMY)
|
|
AC_SUBST(STRIP_BEGIN)
|
|
AC_SUBST(STRIP_END)
|
|
|
|
# check additional type sizes
|
|
size_includes=["
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
"]
|
|
if test "x$ac_cv_header_stdint_h" = "xyes"; then
|
|
size_includes=["$size_includes
|
|
#include <stdint.h>
|
|
"]
|
|
fi
|
|
if test "x$ac_cv_header_unistd_h" = "xyes"; then
|
|
size_includes=["$size_includes
|
|
#include <unistd.h>
|
|
"]
|
|
fi
|
|
GLIB_SIZEOF([$size_includes], size_t, size_t)
|
|
GLIB_SIZEOF([$size_includes], ptrdiff_t, ptrdiff_t)
|
|
GLIB_SIZEOF([$size_includes], intmax_t, intmax_t)
|
|
|
|
# Check for some functions
|
|
AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll getcwd)
|
|
|
|
# Check if bcopy can be used for overlapping copies, if memmove isn't found.
|
|
# The check is borrowed from the PERL Configure script.
|
|
if test "$ac_cv_func_memmove" != "yes"; then
|
|
AC_CACHE_CHECK(whether bcopy can handle overlapping copies,
|
|
glib_cv_working_bcopy,[AC_TRY_RUN([
|
|
int main() {
|
|
char buf[128], abc[128], *b;
|
|
int len, off, align;
|
|
bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
|
|
for (align = 7; align >= 0; align--) {
|
|
for (len = 36; len; len--) {
|
|
b = buf+align; bcopy(abc, b, len);
|
|
for (off = 1; off <= len; off++) {
|
|
bcopy(b, b+off, len); bcopy(b+off, b, len);
|
|
if (bcmp(b, abc, len)) return(1);
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}],glib_cv_working_bcopy=yes,glib_cv_working_bcopy=no)])
|
|
if test "$glib_cv_working_bcopy" == "yes"; then
|
|
AC_DEFINE(HAVE_WORKING_BCOPY)
|
|
fi
|
|
fi
|
|
|
|
# Check for sys_errlist
|
|
AC_MSG_CHECKING(for sys_errlist)
|
|
AC_TRY_LINK(, [
|
|
extern char *sys_errlist[];
|
|
extern int sys_nerr;
|
|
sys_errlist[sys_nerr-1][0] = 0;
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test $glib_ok = no; then
|
|
AC_DEFINE(NO_SYS_ERRLIST)
|
|
fi
|
|
|
|
# Check for sys_siglist
|
|
AC_MSG_CHECKING(for sys_siglist)
|
|
AC_TRY_LINK(, [
|
|
extern char *sys_siglist[];
|
|
exit (sys_siglist[0]);
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test $glib_ok = no; then
|
|
AC_DEFINE(NO_SYS_SIGLIST)
|
|
fi
|
|
|
|
# Check for sys_siglist decl (see Tue Jan 19 00:44:24 1999 in changelog)
|
|
AC_MSG_CHECKING(for sys_siglist declaration)
|
|
AC_TRY_COMPILE([#include <signal.h>], [
|
|
strlen (sys_siglist[0]);
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test $glib_ok = no; then
|
|
AC_DEFINE(NO_SYS_SIGLIST_DECL)
|
|
fi
|
|
|
|
# Check if <sys/select.h> needs to be included for fd_set
|
|
AC_MSG_CHECKING([for fd_set])
|
|
AC_TRY_COMPILE([#include <sys/types.h>],
|
|
[fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
|
|
if test $gtk_ok = yes; then
|
|
AC_MSG_RESULT([yes, found in sys/types.h])
|
|
else
|
|
AC_HEADER_EGREP(fd_set, sys/select.h, gtk_ok=yes)
|
|
if test $gtk_ok = yes; then
|
|
AC_DEFINE(HAVE_SYS_SELECT_H)
|
|
AC_MSG_RESULT([yes, found in sys/select.h])
|
|
else
|
|
AC_DEFINE(NO_FD_SET)
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
fi
|
|
|
|
dnl *** check for sane realloc() ***
|
|
AC_MSG_CHECKING(whether realloc (NULL,) will work)
|
|
AC_CACHE_VAL(glib_cv_sane_realloc,[
|
|
AC_TRY_RUN([
|
|
#include <stdlib.h>
|
|
int main() {
|
|
return realloc (0, sizeof (int)) == 0;
|
|
}],
|
|
glib_cv_sane_realloc=yes
|
|
AC_DEFINE(REALLOC_0_WORKS)
|
|
,
|
|
glib_cv_sane_realloc=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv_sane_realloc)
|
|
|
|
dnl Check for nl_langinfo and CODESET
|
|
|
|
AC_MSG_CHECKING([for nl_langinfo (CODESET)])
|
|
AC_TRY_COMPILE([#include <langinfo.h>],
|
|
[char *codeset = nl_langinfo (CODESET);],
|
|
AC_DEFINE(HAVE_CODESET)
|
|
have_codeset=yes,
|
|
have_codeset=no)
|
|
AC_MSG_RESULT($have_codeset)
|
|
|
|
|
|
dnl ****************************************
|
|
dnl *** strlcpy/strlcat ***
|
|
dnl ****************************************
|
|
# Check for strlcpy
|
|
AC_MSG_CHECKING(for strlcpy/strlcat)
|
|
AC_TRY_LINK([#include <stdlib.h>
|
|
#include <string.h>], [
|
|
char *p = malloc(10);
|
|
(void) strlcpy(p, "hi", 10);
|
|
(void) strlcat(p, "bye", 10);
|
|
], glib_ok=yes, glib_ok=no)
|
|
AC_MSG_RESULT($glib_ok)
|
|
if test $glib_ok = yes; then
|
|
AC_DEFINE(HAVE_STRLCPY)
|
|
fi
|
|
|
|
|
|
dnl **********************
|
|
dnl *** va_copy checks ***
|
|
dnl **********************
|
|
dnl we currently check for all three va_copy possibilities, so we get
|
|
dnl all results in config.log for bug reports.
|
|
AC_MSG_CHECKING(for an implementation of va_copy())
|
|
AC_CACHE_VAL(glib_cv_va_copy,[
|
|
AC_TRY_RUN([
|
|
#include <stdarg.h>
|
|
void f (int i, ...) {
|
|
va_list args1, args2;
|
|
va_start (args1, i);
|
|
va_copy (args2, args1);
|
|
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
|
|
exit (1);
|
|
va_end (args1); va_end (args2);
|
|
}
|
|
int main() {
|
|
f (0, 42);
|
|
return 0;
|
|
}],
|
|
glib_cv_va_copy=yes
|
|
,
|
|
glib_cv_va_copy=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv_va_copy)
|
|
AC_MSG_CHECKING(for an implementation of __va_copy())
|
|
AC_CACHE_VAL(glib_cv___va_copy,[
|
|
AC_TRY_RUN([
|
|
#include <stdarg.h>
|
|
void f (int i, ...) {
|
|
va_list args1, args2;
|
|
va_start (args1, i);
|
|
__va_copy (args2, args1);
|
|
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
|
|
exit (1);
|
|
va_end (args1); va_end (args2);
|
|
}
|
|
int main() {
|
|
f (0, 42);
|
|
return 0;
|
|
}],
|
|
glib_cv___va_copy=yes
|
|
,
|
|
glib_cv___va_copy=no
|
|
,)
|
|
])
|
|
AC_MSG_RESULT($glib_cv___va_copy)
|
|
AC_MSG_CHECKING(whether va_lists can be copied by value)
|
|
AC_CACHE_VAL(glib_cv_va_val_copy,[
|
|
AC_TRY_RUN([
|
|
#include <stdarg.h>
|
|
void f (int i, ...) {
|
|
va_list args1, args2;
|
|
va_start (args1, i);
|
|
args2 = args1;
|
|
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
|
|
exit (1);
|
|
va_end (args1); va_end (args2);
|
|
}
|
|
int main() {
|
|
f (0, 42);
|
|
return 0;
|
|
}],
|
|
glib_cv_va_val_copy=yes
|
|
,
|
|
glib_cv_va_val_copy=no
|
|
,)
|
|
])
|
|
if test "x$glib_cv_va_copy" = "xyes"; then
|
|
AC_DEFINE(G_VA_COPY, va_copy)
|
|
else if test "x$glib_cv___va_copy" = "xyes"; then
|
|
AC_DEFINE(G_VA_COPY, __va_copy)
|
|
fi
|
|
fi
|
|
if test "x$glib_cv_va_val_copy" = "xno"; then
|
|
AC_DEFINE(G_VA_COPY_AS_ARRAY)
|
|
fi
|
|
AC_MSG_RESULT($glib_cv_va_val_copy)
|
|
|
|
|
|
dnl ***********************
|
|
dnl *** g_module checks ***
|
|
dnl ***********************
|
|
G_MODULE_LIBS=
|
|
G_MODULE_LIBS_EXTRA=
|
|
G_MODULE_PLUGIN_LIBS=
|
|
G_MODULE_LDFLAGS=
|
|
dnl G_MODULE_IMPL= don't reset, so cmd-line can override
|
|
G_MODULE_NEED_USCORE=0
|
|
G_MODULE_HAVE_DLERROR=0
|
|
dnl *** dlopen() and dlsym() in system libraries
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_FUNC(dlopen,
|
|
AC_CHECK_FUNC(dlsym,
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DL
|
|
,)
|
|
,)
|
|
fi
|
|
dnl *** load_image (BeOS)
|
|
if test -z "$G_MODULE_IMPL" -a "x$glib_native_beos" = "xyes"; then
|
|
AC_CHECK_LIB(root, load_image,
|
|
G_MODULE_LIBS="-lbe -lroot -lglib"
|
|
G_MODULE_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
|
|
G_MODULE_PLUGIN_LIBS="-L\$(top_builddir_full)/gmodule/.libs -lgmodule"
|
|
G_MODULE_IMPL=G_MODULE_IMPL_BEOS
|
|
,)
|
|
fi
|
|
dnl *** dlopen() and dlsym() in libdl
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_LIB(dl, dlopen,
|
|
AC_CHECK_LIB(dl, dlsym,
|
|
G_MODULE_LIBS=-ldl
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DL
|
|
,)
|
|
,)
|
|
fi
|
|
dnl *** shl_load() in libdld (HP-UX)
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_MSG_CHECKING(how to export all symbols)
|
|
SAVED_LDFLAGS=$LDFLAGS
|
|
LDFLAGS="$LDFLAGS -Wl,-E"
|
|
AC_TRY_LINK(,[ return 0; ],
|
|
[ G_MODULE_LDFLAGS="-Wl,-E" ],[
|
|
LDFLAGS="$SAVED_LDFLAGS -bexpall"
|
|
AC_TRY_LINK(,[ return 0; ],
|
|
G_MODULE_LDFLAGS="-bexpall",
|
|
G_MODULE_LDFLAGS="none"
|
|
)
|
|
])
|
|
LDFLAGS=$SAVED_LDFLAGS
|
|
AC_MSG_RESULT($G_MODULE_LDFLAGS)
|
|
if test "x$G_MODULE_LDFLAGS" = "xnone"; then
|
|
G_MODULE_LDFLAGS=
|
|
fi
|
|
AC_CHECK_LIB(dld, shl_load,
|
|
G_MODULE_LIBS=-ldld
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DLD
|
|
,)
|
|
fi
|
|
dnl *** additional checks for G_MODULE_IMPL_DL
|
|
if test "$G_MODULE_IMPL" = "G_MODULE_IMPL_DL"; then
|
|
case "$host_os" in
|
|
linux*)
|
|
G_MODULE_LDFLAGS='-rdynamic'
|
|
;;
|
|
esac
|
|
LIBS_orig="$LIBS"
|
|
LDFLAGS_orig="$LDFLAGS"
|
|
LIBS="$LIBS $G_MODULE_LIBS"
|
|
LDFLAGS="$LDFLAGS $G_MODULE_LDFLAGS"
|
|
dnl *** check whether we need preceeding underscores
|
|
AC_MSG_CHECKING(for preceeding underscore in symbols)
|
|
AC_CACHE_VAL(glib_cv_uscore,[
|
|
AC_TRY_RUN([
|
|
#include <dlfcn.h>
|
|
int glib_underscore_test (void) { return 42; }
|
|
int main() {
|
|
void *f1 = (void*)0, *f2 = (void*)0, *handle;
|
|
handle = dlopen ((void*)0, 0);
|
|
if (handle) {
|
|
f1 = dlsym (handle, "glib_underscore_test");
|
|
f2 = dlsym (handle, "_glib_underscore_test");
|
|
} return (!f2 || f1);
|
|
}],
|
|
glib_cv_uscore=yes,
|
|
glib_cv_uscore=no,
|
|
)
|
|
rm -f plugin.c plugin.o plugin.lo
|
|
])
|
|
AC_MSG_RESULT($glib_cv_uscore)
|
|
if test "x$glib_cv_uscore" = "xyes"; then
|
|
G_MODULE_NEED_USCORE=1
|
|
else
|
|
G_MODULE_NEED_USCORE=0
|
|
fi
|
|
|
|
LDFLAGS="$LDFLAGS_orig"
|
|
dnl *** check for having dlerror()
|
|
AC_CHECK_FUNC(dlerror,
|
|
G_MODULE_HAVE_DLERROR=1,
|
|
G_MODULE_HAVE_DLERROR=0)
|
|
LIBS="$LIBS_orig"
|
|
fi
|
|
dnl *** done, have e got an implementation?
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
G_MODULE_IMPL=0
|
|
fi
|
|
AC_SUBST(G_MODULE_IMPL)
|
|
AC_SUBST(G_MODULE_LIBS)
|
|
AC_SUBST(G_MODULE_LIBS_EXTRA)
|
|
AC_SUBST(G_MODULE_PLUGIN_LIBS)
|
|
AC_SUBST(G_MODULE_LDFLAGS)
|
|
AC_SUBST(G_MODULE_HAVE_DLERROR)
|
|
AC_SUBST(G_MODULE_NEED_USCORE)
|
|
AC_SUBST(GLIB_DEBUG_FLAGS)
|
|
|
|
|
|
dnl ***********************
|
|
dnl *** g_thread checks ***
|
|
dnl ***********************
|
|
|
|
AC_ARG_WITH(threads, [ --with-threads=[none/posix/dce/solaris] specify a thread implementation to use],
|
|
if test "x$with_threads" = x; then
|
|
want_threads=yes
|
|
else
|
|
want_threads=$with_threads
|
|
fi,
|
|
want_threads=yes)
|
|
if test "x$enable_threads" = "xno"; then
|
|
want_threads=no
|
|
fi
|
|
if test "x$want_threads" = "xnone"; then
|
|
want_threads=no
|
|
fi
|
|
|
|
dnl error and warning message
|
|
dnl *************************
|
|
|
|
THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your
|
|
computer. GLib will not have a default thread implementation."
|
|
|
|
FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
|
|
platform (normaly it's "_REENTRANT"). I'll not use any flag on
|
|
compilation now, but then your programs might not work.
|
|
Please provide information on how it is done on your system."
|
|
|
|
LIBS_NOT_FOUND_1="I can't find the libraries for the thread implementation
|
|
"
|
|
|
|
LIBS_NOT_FOUND_2=". Please choose another thread implementation or
|
|
provide information on your thread implementation.
|
|
You can also run 'configure --disable-threads'
|
|
to compile without thread support."
|
|
|
|
FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)'
|
|
functions will not be MT-safe during their first call because
|
|
there is no working 'getpwuid_r' on your system."
|
|
|
|
FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe
|
|
because there is no 'localtime_r' on your system."
|
|
|
|
POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather
|
|
crude surrogate will be used. If you happen to know a
|
|
yield function for your system, please inform the GLib
|
|
developers."
|
|
|
|
POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for
|
|
threads on your system. Thus threads can only have the default
|
|
priority. If you happen to know these main/max
|
|
priorities, please inform the GLib developers."
|
|
|
|
|
|
dnl determination of thread implementation
|
|
dnl ***************************************
|
|
|
|
have_threads=none
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xsolaris; then
|
|
case $host in
|
|
*-*-solaris*)
|
|
AC_CHECK_LIB(thread, cond_init, have_threads=solaris)
|
|
;;
|
|
esac
|
|
fi
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
|
|
|| test "x$want_threads" = xdce; then
|
|
# -D_POSIX4A_DRAFT10_SOURCE is for DG/UX
|
|
# -U_OSF_SOURCE is for Digital UNIX 4.0d
|
|
GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE"
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
if test "x$have_threads" = xnone; then
|
|
AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_init[^a-zA-Z_]],
|
|
pthread.h,
|
|
have_threads=posix)
|
|
fi
|
|
if test "x$have_threads" = xnone; then
|
|
AC_EGREP_HEADER([(^|[^a-zA-Z_])pthread_attr_create[^a-zA-Z_]],
|
|
pthread.h,
|
|
have_threads=dce)
|
|
fi
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for thread implementation)
|
|
|
|
if test "x$have_threads" = xnone && test "x$want_threads" != xno; then
|
|
AC_MSG_RESULT(none available)
|
|
AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
|
|
else
|
|
AC_MSG_RESULT($have_threads)
|
|
fi
|
|
|
|
|
|
dnl determination of G_THREAD_CFLAGS
|
|
dnl ********************************
|
|
|
|
G_THREAD_LIBS=
|
|
G_THREAD_LIBS_EXTRA=
|
|
G_THREAD_CFLAGS=
|
|
|
|
if test x"$have_threads" != xnone; then
|
|
|
|
G_THREAD_CFLAGS="-D_REENTRANT" # good default guess
|
|
|
|
case $host in
|
|
*-aix*)
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
|
|
if test x"$GCC" = xyes; then
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
|
|
fi
|
|
;;
|
|
*-freebsd2.2*)
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
|
|
|
|
# FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
|
|
# -mthreads flag.
|
|
;;
|
|
*-sysv5uw7*) # UnixWare 7
|
|
if test "$GCC" != "yes"; then
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -Kthread"
|
|
else
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -pthread"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
# if we are not finding the ctime_r function, then we probably are
|
|
# not using the proper multithread flag
|
|
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
|
|
|
# Note: Digital UNIX 4.0d #defines ctime_r to _Pctime_r for gcc.
|
|
AC_EGREP_HEADER([[^a-zA-Z_](_P)?ctime_r[^a-zA-Z_]], time.h, ,
|
|
AC_MSG_WARN($FLAG_DOES_NOT_WORK))
|
|
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
|
|
AC_MSG_CHECKING(thread related cflags)
|
|
AC_MSG_RESULT($G_THREAD_CFLAGS)
|
|
CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
|
|
fi
|
|
|
|
dnl determination of G_THREAD_LIBS
|
|
dnl ******************************
|
|
|
|
mutex_has_default=no
|
|
case $have_threads in
|
|
posix|dce)
|
|
G_THREAD_LIBS=error
|
|
glib_save_LIBS="$LIBS"
|
|
case $host in
|
|
*-sysv5uw7*) # UnixWare 7
|
|
if test "$GCC" != "yes"; then
|
|
G_THREAD_LIBS="-Kthread"
|
|
else
|
|
G_THREAD_LIBS="-pthread"
|
|
fi
|
|
;;
|
|
*)
|
|
for thread_lib in "" pthread pthreads c_r thread dce; do
|
|
if test x"$thread_lib" = x; then
|
|
add_thread_lib=""
|
|
IN=""
|
|
else
|
|
add_thread_lib="-l$thread_lib"
|
|
IN=" in -l$thread_lib"
|
|
fi
|
|
if test x"$have_threads" = xposix; then
|
|
defattr=NULL
|
|
else
|
|
defattr=pthread_attr_default
|
|
fi
|
|
|
|
LIBS="$glib_save_LIBS $add_thread_lib"
|
|
|
|
AC_MSG_CHECKING(for pthread_create/pthread_join$IN)
|
|
AC_TRY_RUN([#include <pthread.h>
|
|
int check_me = 0;
|
|
void* func(void* data) {check_me = 42;}
|
|
main()
|
|
{ pthread_t t;
|
|
void *ret;
|
|
pthread_create (&t, $defattr, func, NULL);
|
|
pthread_join (t, &ret);
|
|
exit (check_me != 42);
|
|
}],
|
|
[AC_MSG_RESULT(yes)
|
|
G_THREAD_LIBS="$add_thread_lib"
|
|
break],
|
|
[AC_MSG_RESULT(no)])
|
|
done
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
|
|
fi
|
|
for thread_lib in "" rt; do
|
|
if test x"$thread_lib" = x; then
|
|
add_thread_lib=""
|
|
IN=""
|
|
else
|
|
add_thread_lib="-l$thread_lib"
|
|
IN=" in -l$thread_lib"
|
|
fi
|
|
LIBS="$glib_save_LIBS $add_thread_lib"
|
|
|
|
AC_MSG_CHECKING(for sched_get_priority_min$IN)
|
|
AC_TRY_RUN([#include <sched.h>
|
|
#include <errno.h>
|
|
int main() {
|
|
errno = 0;
|
|
return sched_get_priority_min(SCHED_OTHER)==-1
|
|
&& errno != 0;
|
|
}],
|
|
[AC_MSG_RESULT(yes)
|
|
G_THREAD_LIBS="$G_THREAD_LIBS $add_thread_lib"
|
|
posix_priority_min="sched_get_priority_min(SCHED_OTHER)"
|
|
posix_priority_max="sched_get_priority_max(SCHED_OTHER)"
|
|
break],
|
|
[AC_MSG_RESULT(no)])
|
|
done
|
|
LIBS="$glib_save_LIBS"
|
|
;;
|
|
esac
|
|
mutex_has_default=yes
|
|
mutex_default_type='pthread_mutex_t'
|
|
mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
|
|
mutex_header_file='pthread.h'
|
|
if test "x$have_threads" = "xposix"; then
|
|
g_threads_impl="POSIX"
|
|
else
|
|
g_threads_impl="DCE"
|
|
have_threads="posix"
|
|
fi
|
|
AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
|
|
;;
|
|
solaris)
|
|
G_THREAD_LIBS=error
|
|
AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
|
|
mutex_has_default=yes
|
|
mutex_default_type='mutex_t'
|
|
mutex_default_init="DEFAULTMUTEX"
|
|
mutex_header_file='thread.h'
|
|
g_threads_impl="SOLARIS"
|
|
;;
|
|
none)
|
|
g_threads_impl="NONE"
|
|
;;
|
|
*)
|
|
g_threads_impl="NONE"
|
|
G_THREAD_LIBS=error
|
|
;;
|
|
esac
|
|
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_MSG_ERROR($LIBS_NOT_FOUND_1$have_threads$LIBS_NOT_FOUND_2)
|
|
fi
|
|
|
|
case $host in
|
|
*-*-beos*)
|
|
G_THREAD_LIBS="-lbe -lroot -lglib "
|
|
G_THREAD_LIBS_EXTRA="-L\$(top_builddir_full)/.libs"
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(thread related libraries)
|
|
AC_MSG_RESULT($G_THREAD_LIBS)
|
|
|
|
dnl check for mt safe function variants and some posix functions
|
|
dnl ************************************************************
|
|
|
|
if test x"$have_threads" != xnone; then
|
|
glib_save_LIBS="$LIBS"
|
|
# we are not doing the following for now, as this might require glib
|
|
# to always be linked with the thread libs on some platforms.
|
|
# LIBS="$LIBS $G_THREAD_LIBS"
|
|
AC_CHECK_FUNCS(localtime_r)
|
|
if test "$ac_cv_header_pwd_h" = "yes"; then
|
|
AC_MSG_CHECKING([for getpwuid_r])
|
|
AC_CACHE_VAL(ac_cv_func_getpwuid_r,
|
|
[AC_TRY_RUN([#include <errno.h>
|
|
int main () { char buffer[10000], *pointer;
|
|
char getpwuid_r (long, void*, void*,
|
|
int, void*);
|
|
int error;
|
|
errno = 0;
|
|
error = getpwuid_r (0, &buffer, &buffer,
|
|
sizeof (buffer), &pointer);
|
|
return errno == ENOSYS || error == ENOSYS;}],
|
|
[ac_cv_func_getpwuid_r=yes],
|
|
[ac_cv_func_getpwuid_r=no])])
|
|
if test "$ac_cv_func_getpwuid_r" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_GETPWUID_R)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
if test "$ac_cv_func_getpwuid_r" = "yes"; then
|
|
AC_MSG_CHECKING(whether getpwuid_r is posix like)
|
|
# The signature for the POSIX version is:
|
|
# int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **)
|
|
AC_TRY_COMPILE([#include <pwd.h>
|
|
#include <sys/types.h>
|
|
#include <stdlib.h>],
|
|
[getpwuid_r((uid_t)0, NULL, NULL, (size_t)0, NULL);],
|
|
[AC_DEFINE(HAVE_GETPWUID_R_POSIX)
|
|
AC_MSG_RESULT(yes)],
|
|
[AC_MSG_RESULT(no)])
|
|
fi
|
|
fi
|
|
LIBS="$LIBS $G_THREAD_LIBS"
|
|
if test x"$have_threads" = xposix; then
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
GLIB_SIZEOF([#include <pthread.h>],
|
|
pthread_t,
|
|
system_thread)
|
|
# This is not AC_CHECK_FUNC to also work with function
|
|
# name mangling in header files.
|
|
AC_MSG_CHECKING(for pthread_attr_setstacksize)
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[pthread_attr_t t; pthread_attr_setstacksize(&t,0)],
|
|
[AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)],
|
|
[AC_MSG_RESULT(no)])
|
|
AC_MSG_CHECKING(for minimal/maximal thread priority)
|
|
if test x"$posix_priority_min" = xnone; then
|
|
AC_EGREP_CPP(PX_PRIO_MIN,[#include <pthread.h>
|
|
PX_PRIO_MIN],,[
|
|
posix_priority_min=PX_PRIO_MIN
|
|
posix_priority_max=PX_PRIO_MAX])
|
|
fi
|
|
if test x"$posix_priority_min" = xnone; then
|
|
AC_EGREP_CPP(PRI_OTHER_MIN,[#include <pthread.h>
|
|
PRI_OTHER_MIN],,[
|
|
posix_priority_min=PRI_OTHER_MIN
|
|
posix_priority_max=PRI_OTHER_MAX])
|
|
fi
|
|
if test x"$posix_priority_min" = x; then
|
|
AC_MSG_RESULT(none found)
|
|
AC_MSG_WARN($POSIX_NO_PRIORITIES)
|
|
posix_priority_min=-1
|
|
posix_priority_max=-1
|
|
else
|
|
AC_MSG_RESULT($posix_priority_min/$posix_priority_max)
|
|
AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min)
|
|
AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max)
|
|
fi
|
|
posix_yield_func=none
|
|
AC_MSG_CHECKING(for posix yield function)
|
|
for yield_func in sched_yield pthread_yield_np pthread_yield \
|
|
thr_yield; do
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[$yield_func()],
|
|
[posix_yield_func="$yield_func"
|
|
break])
|
|
done
|
|
if test x"$posix_yield_func" = xnone; then
|
|
AC_MSG_RESULT(none found)
|
|
AC_MSG_WARN($POSIX_NO_YIELD)
|
|
posix_yield_func="g_usleep(1000)"
|
|
else
|
|
AC_MSG_RESULT($posix_yield_func)
|
|
posix_yield_func="$posix_yield_func()"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func)
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
else # solaris threads
|
|
GLIB_SIZEOF([#include <thread.h>],
|
|
thread_t,
|
|
system_thread)
|
|
fi
|
|
|
|
LIBS="$glib_save_LIBS"
|
|
|
|
# now spit out all the warnings.
|
|
if test "$ac_cv_func_getpwuid_r" != "yes"; then
|
|
AC_MSG_WARN($FUNC_NO_GETPWUID_R)
|
|
fi
|
|
if test "$ac_cv_func_localtime_r" != "yes"; then
|
|
AC_MSG_WARN($FUNC_NO_LOCALTIME_R)
|
|
fi
|
|
else
|
|
# If no thread implementation exists, we will provide enough
|
|
# space for a pointer
|
|
GLIB_SIZEOF(, void*, system_thread)
|
|
fi
|
|
|
|
AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
|
|
AC_SUBST(G_THREAD_CFLAGS)
|
|
AC_SUBST(G_THREAD_LIBS)
|
|
AC_SUBST(G_THREAD_LIBS_EXTRA)
|
|
|
|
dnl **********************************************
|
|
dnl *** GDefaultMutex setup and initialization ***
|
|
dnl **********************************************
|
|
dnl
|
|
dnl if mutex_has_default = yes, we also got
|
|
dnl mutex_default_type, mutex_default_init and mutex_header_file
|
|
GLIB_IF_VAR_EQ(mutex_has_default, yes,
|
|
glib_save_CPPFLAGS="$CPPFLAGS"
|
|
glib_save_LIBS="$LIBS"
|
|
LIBS="$LIBS $G_THREAD_LIBS"
|
|
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
|
|
GLIB_SIZEOF([#include <$mutex_header_file>],
|
|
$mutex_default_type,
|
|
gmutex,
|
|
)
|
|
GLIB_BYTE_CONTENTS([#include <$mutex_header_file>],
|
|
$mutex_default_type,
|
|
gmutex,
|
|
$glib_cv_sizeof_gmutex,
|
|
$mutex_default_init)
|
|
if test x"$glib_cv_byte_contents_gmutex" = xno; then
|
|
mutex_has_default=no
|
|
fi
|
|
CPPFLAGS="$glib_save_CPPFLAGS"
|
|
LIBS="$glib_save_LIBS"
|
|
,
|
|
)
|
|
|
|
|
|
dnl ****************************************
|
|
dnl *** GLib POLL* compatibility defines ***
|
|
dnl ****************************************
|
|
GLIB_SYSDEFS(
|
|
[#include <sys/types.h>
|
|
#include <sys/poll.h>],
|
|
POLLIN:1 POLLOUT:4 POLLPRI:2 POLLERR:8 POLLHUP:16 POLLNVAL:32,
|
|
glibconfig-sysdefs.h,
|
|
=)
|
|
|
|
dnl **************************
|
|
dnl *** Checks for gtk-doc ***
|
|
dnl **************************
|
|
|
|
AC_ARG_WITH(html-dir, [ --with-html-dir=PATH path to installed docs ])
|
|
|
|
if test "x$with_html_dir" = "x" ; then
|
|
HTML_DIR='${datadir}/gtk-doc/html'
|
|
else
|
|
HTML_DIR=$with_html_dir
|
|
fi
|
|
|
|
AC_SUBST(HTML_DIR)
|
|
|
|
|
|
AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
|
|
AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
|
|
AC_SUBST(HAVE_GTK_DOC)
|
|
|
|
AC_CHECK_PROG(DB2HTML, db2html, true, false)
|
|
AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
|
|
|
|
dnl Let people disable the gtk-doc stuff.
|
|
AC_ARG_ENABLE(gtk-doc, [ --enable-gtk-doc Use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)
|
|
|
|
if test x$enable_gtk_doc = xauto ; then
|
|
if test x$GTKDOC = xtrue ; then
|
|
enable_gtk_doc=yes
|
|
else
|
|
enable_gtk_doc=no
|
|
fi
|
|
fi
|
|
|
|
dnl NOTE: We need to use a separate automake conditional for this
|
|
dnl to make this work with the tarballs.
|
|
AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)
|
|
|
|
dnl ******************************
|
|
dnl *** output the whole stuff ***
|
|
dnl ******************************
|
|
|
|
AC_OUTPUT_COMMANDS([
|
|
|
|
## Generate `glibconfig.h' in two cases
|
|
## 1. `config.status' is run either explicitly, or via configure.
|
|
## Esp. not when it is run in `Makefile' to generate makefiles and
|
|
## config.h
|
|
## 2. CONFIG_OTHER is set explicitly
|
|
##
|
|
## Case 1 is difficult. We know that `automake' sets one of
|
|
## CONFIG_FILES or CONFIG_HEADERS to empty. This heuristic works
|
|
## only when AM_CONFIG_HEADER is set, however.
|
|
|
|
if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
|
|
# Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
|
|
CONFIG_OTHER=${CONFIG_OTHER:-glibconfig.h}
|
|
fi
|
|
case "$CONFIG_OTHER" in
|
|
*glibconfig.h*)
|
|
echo creating glibconfig.h
|
|
outfile=glibconfig.h-tmp
|
|
cat > $outfile <<\_______EOF
|
|
/* glibconfig.h
|
|
*
|
|
* This is a generated file. Please modify `configure.in'
|
|
*/
|
|
|
|
#ifndef GLIBCONFIG_H
|
|
#define GLIBCONFIG_H
|
|
|
|
_______EOF
|
|
|
|
if test x$glib_limits_h = xyes; then
|
|
echo '#include <limits.h>' >> $outfile
|
|
fi
|
|
if test x$glib_float_h = xyes; then
|
|
echo '#include <float.h>' >> $outfile
|
|
fi
|
|
if test x$glib_values_h = xyes; then
|
|
echo '#include <values.h>' >> $outfile
|
|
fi
|
|
if test x$g_mutex_header_file != x; then
|
|
echo '#include <'"$g_mutex_header_file"'>' >> $outfile
|
|
fi
|
|
if test "$glib_header_alloca_h" = "yes"; then
|
|
echo '#include <alloca.h>' >> $outfile
|
|
fi
|
|
if test x$glib_sys_poll_h = xyes; then
|
|
echo '#define GLIB_HAVE_SYS_POLL_H' >> $outfile
|
|
fi
|
|
|
|
cat >> $outfile <<_______EOF
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
#define G_MINFLOAT $glib_mf
|
|
#define G_MAXFLOAT $glib_Mf
|
|
#define G_MINDOUBLE $glib_md
|
|
#define G_MAXDOUBLE $glib_Md
|
|
#define G_MINSHORT $glib_ms
|
|
#define G_MAXSHORT $glib_Ms
|
|
#define G_MAXUSHORT $glib_Mus
|
|
#define G_MININT $glib_mi
|
|
#define G_MAXINT $glib_Mi
|
|
#define G_MAXUINT $glib_Mui
|
|
#define G_MINLONG $glib_ml
|
|
#define G_MAXLONG $glib_Ml
|
|
#define G_MAXULONG $glib_Mul
|
|
|
|
_______EOF
|
|
|
|
|
|
### this should always be true in a modern C/C++ compiler
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed char gint8;
|
|
typedef unsigned char guint8;
|
|
_______EOF
|
|
|
|
|
|
if test -n "$gint16"; then
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed $gint16 gint16;
|
|
typedef unsigned $gint16 guint16;
|
|
#define G_GINT16_FORMAT $gint16_format
|
|
#define G_GUINT16_FORMAT $guint16_format
|
|
_______EOF
|
|
fi
|
|
|
|
|
|
if test -n "$gint32"; then
|
|
cat >>$outfile <<_______EOF
|
|
typedef signed $gint32 gint32;
|
|
typedef unsigned $gint32 guint32;
|
|
#define G_GINT32_FORMAT $gint32_format
|
|
#define G_GUINT32_FORMAT $guint32_format
|
|
_______EOF
|
|
fi
|
|
|
|
|
|
if test -n "$gint64"; then
|
|
cat >>$outfile <<_______EOF
|
|
#define G_HAVE_GINT64 1
|
|
|
|
${glib_extension}typedef signed $gint64 gint64;
|
|
${glib_extension}typedef unsigned $gint64 guint64;
|
|
|
|
#define G_GINT64_CONSTANT(val) $gint64_constant
|
|
_______EOF
|
|
if test -n "$gint64_format"; then
|
|
cat >>$outfile <<_______EOF
|
|
#define G_GINT64_FORMAT $gint64_format
|
|
#define G_GUINT64_FORMAT $guint64_format
|
|
_______EOF
|
|
fi
|
|
fi
|
|
|
|
case x$glib_size_t in
|
|
x2) echo "typedef gint16 gssize;" >> $outfile
|
|
echo "typedef guint16 gsize;" >> $outfile
|
|
;;
|
|
x4) echo "typedef gint32 gssize;" >> $outfile
|
|
echo "typedef guint32 gsize;" >> $outfile
|
|
;;
|
|
x8) echo "typedef gint64 gssize;" >> $outfile
|
|
echo "typedef guint64 gsize;" >> $outfile
|
|
;;
|
|
*) echo "#error size of size_t is unknown" >> $outfile
|
|
;;
|
|
esac
|
|
|
|
if test -z "$glib_unknown_void_p"; then
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#define GPOINTER_TO_INT(p) ((gint) ${glib_gpi_cast} (p))
|
|
#define GPOINTER_TO_UINT(p) ((guint) ${glib_gpui_cast} (p))
|
|
|
|
#define GINT_TO_POINTER(i) ((gpointer) ${glib_gpi_cast} (i))
|
|
#define GUINT_TO_POINTER(u) ((gpointer) ${glib_gpui_cast} (u))
|
|
_______EOF
|
|
else
|
|
echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
|
|
fi
|
|
|
|
|
|
|
|
cat >>$outfile <<_______EOF
|
|
$glib_atexit
|
|
$glib_memmove
|
|
$glib_defines
|
|
$glib_os
|
|
|
|
$glib_vacopy
|
|
|
|
#ifdef __cplusplus
|
|
#define G_HAVE_INLINE 1
|
|
#else /* !__cplusplus */
|
|
$glib_inline
|
|
#endif /* !__cplusplus */
|
|
_______EOF
|
|
|
|
echo >>$outfile
|
|
if test x$g_mutex_has_default = xyes; then
|
|
cat >>$outfile <<_______EOF
|
|
$g_enable_threads_def G_THREADS_ENABLED
|
|
#define G_THREADS_IMPL_$g_threads_impl_def
|
|
typedef struct _GStaticMutex GStaticMutex;
|
|
struct _GStaticMutex
|
|
{
|
|
struct _GMutex *runtime_mutex;
|
|
struct {
|
|
union {
|
|
char pad[$g_mutex_sizeof];
|
|
double dummy_double;
|
|
void *dummy_pointer;
|
|
long dummy_long;
|
|
} mutex;
|
|
void *debug_info;
|
|
} static_mutex;
|
|
};
|
|
#define G_STATIC_MUTEX_INIT { NULL, { { { $g_mutex_contents} }, NULL } }
|
|
#define g_static_mutex_get_mutex(mutex) \
|
|
(g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \
|
|
g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
|
|
_______EOF
|
|
else
|
|
cat >>$outfile <<_______EOF
|
|
$g_enable_threads_def G_THREADS_ENABLED
|
|
#define G_THREADS_IMPL_$g_threads_impl_def
|
|
typedef struct _GMutex* GStaticMutex;
|
|
#define G_STATIC_MUTEX_INIT NULL
|
|
#define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex))
|
|
_______EOF
|
|
fi
|
|
|
|
cat >>$outfile <<_______EOF
|
|
/* This represents a system thread as used by the implementation. An
|
|
* alien implementaion, as loaded by g_thread_init can only count on
|
|
* "sizeof (gpointer)" bytes to store their info. We however need more
|
|
* for some of our native implementations. */
|
|
typedef union _GSystemThread GSystemThread;
|
|
union _GSystemThread
|
|
{
|
|
char data[$g_system_thread_sizeof];
|
|
double dummy_double;
|
|
void *dummy_pointer;
|
|
long dummy_long;
|
|
};
|
|
_______EOF
|
|
|
|
echo >>$outfile
|
|
g_bit_sizes="16 32"
|
|
if test -n "$gint64"; then
|
|
g_bit_sizes="$g_bit_sizes 64"
|
|
fi
|
|
for bits in $g_bit_sizes; do
|
|
cat >>$outfile <<_______EOF
|
|
#define GINT${bits}_TO_${g_bs_native}(val) ((gint${bits}) (val))
|
|
#define GUINT${bits}_TO_${g_bs_native}(val) ((guint${bits}) (val))
|
|
#define GINT${bits}_TO_${g_bs_alien}(val) ((gint${bits}) GUINT${bits}_SWAP_LE_BE (val))
|
|
#define GUINT${bits}_TO_${g_bs_alien}(val) (GUINT${bits}_SWAP_LE_BE (val))
|
|
_______EOF
|
|
done
|
|
|
|
cat >>$outfile <<_______EOF
|
|
#define GLONG_TO_LE(val) ((glong) GINT${glongbits}_TO_LE (val))
|
|
#define GULONG_TO_LE(val) ((gulong) GUINT${glongbits}_TO_LE (val))
|
|
#define GLONG_TO_BE(val) ((glong) GINT${glongbits}_TO_BE (val))
|
|
#define GULONG_TO_BE(val) ((gulong) GUINT${glongbits}_TO_BE (val))
|
|
#define GINT_TO_LE(val) ((gint) GINT${gintbits}_TO_LE (val))
|
|
#define GUINT_TO_LE(val) ((guint) GUINT${gintbits}_TO_LE (val))
|
|
#define GINT_TO_BE(val) ((gint) GINT${gintbits}_TO_BE (val))
|
|
#define GUINT_TO_BE(val) ((guint) GUINT${gintbits}_TO_BE (val))
|
|
#define G_BYTE_ORDER $g_byte_order
|
|
|
|
_______EOF
|
|
|
|
if test -r glibconfig-sysdefs.h; then
|
|
cat glibconfig-sysdefs.h >>$outfile
|
|
fi
|
|
|
|
cat >>$outfile <<_______EOF
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* GLIBCONFIG_H */
|
|
_______EOF
|
|
|
|
|
|
if cmp -s $outfile glibconfig.h; then
|
|
echo glibconfig.h is unchanged
|
|
rm -f $outfile
|
|
else
|
|
mv $outfile glibconfig.h
|
|
fi ;;
|
|
esac
|
|
],[
|
|
|
|
# Note that if two cases are the same, case goes with the first one.
|
|
# Note also that this is inside an AC_OUTPUT_COMMAND. We do not depend
|
|
# on variable expansion in case labels. Look at the generated config.status
|
|
# for a hint.
|
|
|
|
glib_header_alloca_h="$ac_cv_header_alloca_h"
|
|
|
|
case xyes in
|
|
x$ac_cv_header_float_h)
|
|
glib_float_h=yes
|
|
glib_mf=FLT_MIN glib_Mf=FLT_MAX
|
|
glib_md=DBL_MIN glib_Md=DBL_MAX
|
|
;;
|
|
x$ac_cv_header_values_h)
|
|
glib_values_h=yes
|
|
glib_mf=MINFLOAT glib_Mf=MAXFLOAT
|
|
glib_md=MINDOUBLE glib_Md=MAXDOUBLE
|
|
;;
|
|
esac
|
|
|
|
case xyes in
|
|
x$ac_cv_header_limits_h)
|
|
glib_limits_h=yes
|
|
glib_ms=SHRT_MIN glib_Ms=SHRT_MAX glib_Mus=USHRT_MAX
|
|
glib_mi=INT_MIN glib_Mi=INT_MAX glib_Mui=UINT_MAX
|
|
glib_ml=LONG_MIN glib_Ml=LONG_MAX glib_Mul=ULONG_MAX
|
|
;;
|
|
x$ac_cv_header_values_h)
|
|
glib_values_h=yes
|
|
glib_ms=MINSHORT glib_Ms=MAXSHORT glib_Mus="(((gushort)G_MAXSHORT)*2+1)"
|
|
glib_mi=MININT glib_Mi=MAXINT glib_Mui="(((guint)G_MAXINT)*2+1)"
|
|
glib_ml=MINLONG glib_Ml=MAXLONG glib_Mul="(((gulong)G_MAXLONG)*2+1)"
|
|
;;
|
|
esac
|
|
|
|
if test x$ac_cv_header_sys_poll_h = xyes ; then
|
|
glib_sys_poll_h=yes
|
|
fi
|
|
|
|
case 2 in
|
|
$ac_cv_sizeof_short)
|
|
gint16=short
|
|
gint16_format='"hi"'
|
|
guint16_format='"hu"'
|
|
;;
|
|
$ac_cv_sizeof_int)
|
|
gint16=int
|
|
gint16_format='"i"'
|
|
guint16_format='"u"'
|
|
;;
|
|
esac
|
|
case 4 in
|
|
$ac_cv_sizeof_short)
|
|
gint32=short
|
|
gint32_format='"hi"'
|
|
guint32_format='"hu"'
|
|
;;
|
|
$ac_cv_sizeof_int)
|
|
gint32=int
|
|
gint32_format='"i"'
|
|
guint32_format='"u"'
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
gint32=long
|
|
gint32_format='"li"'
|
|
guint32_format='"lu"'
|
|
;;
|
|
esac
|
|
case 8 in
|
|
$ac_cv_sizeof_int)
|
|
gint64=int
|
|
gint64_format='"i"'
|
|
guint64_format='"u"'
|
|
glib_extension=
|
|
gint64_constant='(val)'
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
gint64=long
|
|
gint64_format='"li"'
|
|
guint64_format='"lu"'
|
|
glib_extension=
|
|
gint64_constant='(val##L)'
|
|
;;
|
|
$ac_cv_sizeof_long_long)
|
|
gint64='long long'
|
|
if test -n "$glib_cv_long_long_format"; then
|
|
gint64_format='"'$glib_cv_long_long_format'i"'
|
|
guint64_format='"'$glib_cv_long_long_format'u"'
|
|
fi
|
|
glib_extension='G_GNUC_EXTENSION '
|
|
gint64_constant='(G_GNUC_EXTENSION (val##LL))'
|
|
;;
|
|
esac
|
|
glib_size_t=$glib_cv_sizeof_size_t
|
|
|
|
gintbits=`expr $ac_cv_sizeof_int \* 8`
|
|
glongbits=`expr $ac_cv_sizeof_long \* 8`
|
|
|
|
|
|
case $ac_cv_sizeof_void_p in
|
|
$ac_cv_sizeof_int) glib_gpi_cast='' glib_gpui_cast='' ;;
|
|
$ac_cv_sizeof_long) glib_gpi_cast='(glong)' glib_gpui_cast='(gulong)' ;;
|
|
*) glib_unknown_void_p=yes ;;
|
|
esac
|
|
|
|
|
|
case xyes in
|
|
x$ac_cv_func_atexit)
|
|
glib_atexit="
|
|
#ifdef NeXT /* @#%@! NeXTStep */
|
|
# define g_ATEXIT(proc) (!atexit (proc))
|
|
#else
|
|
# define g_ATEXIT(proc) (atexit (proc))
|
|
#endif"
|
|
;;
|
|
x$ac_cv_func_on_exit)
|
|
glib_atexit="
|
|
#define g_ATEXIT(proc) (on_exit ((void (*)(int, void*))(proc), NULL))"
|
|
;;
|
|
esac
|
|
|
|
case xyes in
|
|
x$ac_cv_func_memmove)
|
|
glib_memmove='
|
|
#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END'
|
|
;;
|
|
x$glib_cv_working_bcopy)
|
|
glib_memmove="
|
|
/* memmove isn't available, but bcopy can copy overlapping memory regions */
|
|
#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
|
|
;;
|
|
*)
|
|
glib_memmove="
|
|
/* memmove isn't found and bcopy can't copy overlapping memory regions,
|
|
* so we have to roll our own copy routine. */
|
|
void g_memmove (void* dest, const void * src, unsigned long len);"
|
|
;;
|
|
esac
|
|
|
|
glib_defines="
|
|
#define GLIB_MAJOR_VERSION $GLIB_MAJOR_VERSION
|
|
#define GLIB_MINOR_VERSION $GLIB_MINOR_VERSION
|
|
#define GLIB_MICRO_VERSION $GLIB_MICRO_VERSION
|
|
"
|
|
|
|
case xyes in
|
|
x$glib_cv_va_copy) glib_vacopy='#define G_VA_COPY va_copy' ;;
|
|
x$glib_cv___va_copy) glib_vacopy='#define G_VA_COPY __va_copy' ;;
|
|
*) glib_vacopy=''
|
|
esac
|
|
|
|
if test x$glib_cv_va_val_copy = xno; then
|
|
glib_vacopy="\$glib_vacopy
|
|
#define G_VA_COPY_AS_ARRAY 1"
|
|
fi
|
|
|
|
if test x$glib_cv_hasinline = xyes; then
|
|
glib_inline='#define G_HAVE_INLINE 1'
|
|
fi
|
|
if test x$glib_cv_has__inline = xyes; then
|
|
glib_inline="\$glib_inline
|
|
#define G_HAVE___INLINE 1"
|
|
fi
|
|
if test x$glib_cv_has__inline__ = xyes; then
|
|
glib_inline="\$glib_inline
|
|
#define G_HAVE___INLINE__ 1"
|
|
fi
|
|
|
|
case xyes in
|
|
x$ac_cv_c_bigendian)
|
|
g_byte_order=G_BIG_ENDIAN
|
|
g_bs_native=BE
|
|
g_bs_alien=LE
|
|
;;
|
|
*)
|
|
g_byte_order=G_LITTLE_ENDIAN
|
|
g_bs_native=LE
|
|
g_bs_alien=BE
|
|
;;
|
|
esac
|
|
|
|
case x$have_threads in
|
|
xnone) g_enable_threads_def="#undef";;
|
|
*) g_enable_threads_def="#define";;
|
|
esac
|
|
|
|
g_threads_impl_def=$g_threads_impl
|
|
|
|
g_mutex_has_default="$mutex_has_default"
|
|
g_mutex_sizeof="$glib_cv_sizeof_gmutex"
|
|
g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
|
|
g_mutex_contents="$glib_cv_byte_contents_gmutex"
|
|
|
|
case $host in
|
|
*-*-beos*)
|
|
glib_os="#define G_OS_BEOS"
|
|
;;
|
|
*-*-cygwin*)
|
|
glib_os="#define G_OS_UNIX
|
|
#define G_WITH_CYGWIN"
|
|
v ;;
|
|
*)
|
|
glib_os="#define G_OS_UNIX"
|
|
;;
|
|
esac
|
|
])
|
|
|
|
AC_OUTPUT([
|
|
glib-2.0.pc
|
|
gmodule-2.0.pc
|
|
gthread-2.0.pc
|
|
gobject-2.0.pc
|
|
glib.spec
|
|
Makefile
|
|
glib-config-2.0
|
|
build/Makefile
|
|
build/win32/Makefile
|
|
gmodule/gmoduleconf.h
|
|
gmodule/Makefile
|
|
gobject/Makefile
|
|
gthread/Makefile
|
|
docs/Makefile
|
|
docs/glib-config.1
|
|
docs/reference/Makefile
|
|
docs/reference/glib/Makefile
|
|
docs/reference/gobject/Makefile
|
|
tests/Makefile
|
|
],[case "$CONFIG_FILES" in
|
|
*glib-config-2.0*)chmod +x glib-config-2.0;;
|
|
esac
|
|
echo ""
|
|
echo " *** IMPORTANT *** "
|
|
echo ""
|
|
echo "This is a development version of GLib. You should be using a stable"
|
|
echo "version, which is available at ftp://ftp.gtk.org/pub/gtk/v1.2/. The"
|
|
echo "version you just configured is meant for developers of GLib only:"
|
|
echo ""
|
|
echo " * You should not base stable software on this version of GLib."
|
|
echo " * GNOME developers should use a stable version of GLib."
|
|
echo ""
|
|
echo "If you install this version of GLib, we strongly recommend that you"
|
|
echo "install it in a different prefix than GLib 1.2. Use --prefix as an"
|
|
echo "argument to configure to do this. Otherwise, you will not be able to"
|
|
echo "do development with GLib 1.2 any longer."
|
|
echo ""
|
|
echo " *** You should be using GLib 1.2 instead. ***"
|
|
])
|
|
|