mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-10 03:16:17 +01:00
5ccc68d010
-fstack-check generates non-working code for at least a few compilers (egcs 1.1 included) and the benefits are dubious (your program is going to crash anyways if you run out of stack) so comment that out for now.
1093 lines
29 KiB
Plaintext
1093 lines
29 KiB
Plaintext
# 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}
|
|
|
|
# The following version number definitions apply to GLib and GModule
|
|
# as a whole, so if changes occoured in either of them, they are both
|
|
# 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=1
|
|
GLIB_MICRO_VERSION=7
|
|
GLIB_INTERFACE_AGE=1
|
|
GLIB_BINARY_AGE=1
|
|
GLIB_VERSION=$GLIB_MAJOR_VERSION.$GLIB_MINOR_VERSION.$GLIB_MICRO_VERSION
|
|
AC_SUBST(GLIB_VERSION)
|
|
|
|
# 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_ARG_ENABLE(debug, [ --enable-debug=[no/minimum/yes] turn on debugging [default=minimum]],,enable_debug=minimum)
|
|
AC_ARG_ENABLE(mem_check, [ --enable-mem-check=[no/yes] turn on malloc/free sanity checking [default=no]],,enable_mem_check=no)
|
|
AC_ARG_ENABLE(mem_profile, [ --enable-mem-profile=[no/yes] turn on malloc profiling atexit [default=no]],,enable_mem_profile=no)
|
|
|
|
AC_ARG_ENABLE(ansi, [ --enable-ansi turn on strict ansi [default=no]],
|
|
, enable_ansi=no)
|
|
|
|
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
|
|
|
|
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}")
|
|
|
|
# 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_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)
|
|
|
|
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
|
|
|
|
dnl for bytesex stuff
|
|
AC_C_BIGENDIAN
|
|
|
|
dnl header file checks
|
|
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))
|
|
|
|
# Check for some functions
|
|
AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf strcasecmp strncasecmp poll)
|
|
|
|
# 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[];
|
|
sys_siglist[1][0] = 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 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_mask, 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
|
|
|
|
# These are used only in GDK (gdki18n.h)
|
|
# This stuff is here only so that we can define these
|
|
# things in glibconfig.h. If gtk+ started using an installed
|
|
# gdkconfig.h file, then the definitions would belong there.
|
|
|
|
# Check for wchar.h
|
|
|
|
AC_MSG_CHECKING(for wchar.h)
|
|
AC_TRY_CPP([#include <wchar.h>], glib_wchar_h=yes, glib_wchar_h=no)
|
|
if test $glib_wchar_h = yes; then
|
|
AC_DEFINE(HAVE_WCHAR_H)
|
|
fi
|
|
AC_MSG_RESULT($glib_wchar_h)
|
|
|
|
# Check for wctype.h (for iswalnum)
|
|
|
|
AC_MSG_CHECKING(for wctype.h)
|
|
AC_TRY_CPP([#include <wctype.h>], glib_wctype_h=yes, glib_wctype_h=no)
|
|
if test $glib_wctype_h = yes; then
|
|
AC_DEFINE(HAVE_WCTYPE_H)
|
|
fi
|
|
AC_MSG_RESULT($glib_wctype_h)
|
|
|
|
oLIBS="$LIBS"
|
|
# in Solaris 2.5, `iswalnum' is in -lw
|
|
AC_CHECK_FUNC(iswalnum,,[AC_CHECK_LIB(w,iswalnum)])
|
|
|
|
# The following is necessary for Linux libc-5.4.38
|
|
AC_MSG_CHECKING(if iswalnum() and friends are properly defined)
|
|
AC_TRY_LINK([#include <stdlib.h>],[
|
|
#if (defined(HAVE_WCTYPE_H) || defined(HAVE_WCHAR_H))
|
|
# ifdef HAVE_WCTYPE_H
|
|
# include <wctype.h>
|
|
# else
|
|
# ifdef HAVE_WCHAR_H
|
|
# include <wchar.h>
|
|
# endif
|
|
# endif
|
|
#else
|
|
# define iswalnum(c) ((wchar_t)(c) <= 0xFF && isalnum(c))
|
|
#endif
|
|
iswalnum((wchar_t) 0);
|
|
], glib_working_wctype=yes, glib_working_wctype=no)
|
|
LIBS="$oLIBS"
|
|
|
|
if test $glib_working_wctype = no; then
|
|
AC_DEFINE(HAVE_BROKEN_WCTYPE)
|
|
fi
|
|
AC_MSG_RESULT($glib_working_wctype)
|
|
|
|
|
|
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_LDFLAGS=
|
|
G_MODULE_IMPL=
|
|
G_MODULE_NEED_USCORE=0
|
|
G_MODULE_HAVE_DLERROR=0
|
|
dnl *** dlopen() in system libraries
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_FUNC(dlopen,
|
|
G_MODULE_IMPL=G_MODULE_IMPL_DL
|
|
,)
|
|
fi
|
|
dnl *** dlopen() in libdl
|
|
if test -z "$G_MODULE_IMPL"; then
|
|
AC_CHECK_LIB(dl, dlopen,
|
|
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_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/solaris/nspr] 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$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 be thread safe on your computer."
|
|
|
|
THREAD_UNKNOWN_COMPILER="Your compiler is not known, so I cannot
|
|
determine the necessary compiler options to compile programs
|
|
which are using threads. Please provide such information."
|
|
|
|
FLAG_DOES_NOT_WORK="I can't find the MACRO, that enables 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 informationon your thread implementation."
|
|
|
|
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; then
|
|
if test "x$have_threads" = xnone; then
|
|
AC_CHECK_LIB(pthread, pthread_cond_init, have_threads=posix)
|
|
fi
|
|
if test "x$have_threads" = xnone; then
|
|
AC_CHECK_LIB(pthreads, pthread_cond_init, have_threads=posix)
|
|
fi
|
|
if test "x$have_threads" = xnone; then
|
|
# dont let us be fooled by a defined pthread_cond_init
|
|
# function in the standard c-lib, that doesn't have too mean,
|
|
# there is full thread support, it might be a weak symbol.
|
|
AC_CHECK_FUNC(pthread_attr_init, have_threads=posix)
|
|
fi
|
|
fi
|
|
if test "x$want_threads" = xyes || test "x$want_threads" = xnspr; then
|
|
if test "x$have_threads" = xnone; then
|
|
AC_CHECK_LIB(nspr21, PRP_NewNakedCondVar, have_threads=nspr)
|
|
fi
|
|
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_LIBS
|
|
dnl ******************************
|
|
|
|
G_THREAD_LIBS=
|
|
|
|
case $have_threads in
|
|
posix)
|
|
G_THREAD_LIBS=error
|
|
AC_CHECK_LIB(pthread, pthread_cond_init,
|
|
G_THREAD_LIBS="-lpthread")
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_CHECK_LIB(pthreads, pthread_cond_init,
|
|
G_THREAD_LIBS="-lpthreads")
|
|
fi
|
|
if test "x$G_THREAD_LIBS" = xerror; then
|
|
AC_CHECK_FUNC(pthread_cond_init, G_THREAD_LIBS="")
|
|
fi
|
|
;;
|
|
solaris)
|
|
G_THREAD_LIBS=error
|
|
AC_CHECK_LIB(thread, cond_init, G_THREAD_LIBS="-lthread")
|
|
# solaris has a broken initializer for mutexes, if we find it,
|
|
# we will replace it.
|
|
AC_MSG_CHECKING(for broken solaris mutex initialization)
|
|
AC_EGREP_CPP([ *begin *{ *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *, *0 *} *end *],
|
|
[#include <thread.h>
|
|
begin DEFAULTMUTEX end],
|
|
[solaris_mutex_init_broken=yes],
|
|
[solaris_mutex_init_broken=no])
|
|
AC_MSG_RESULT($solaris_mutex_init_broken)
|
|
;;
|
|
nspr)
|
|
AC_CHECK_LIB(nspr21, PRP_NewNakedCondVar,
|
|
G_THREAD_LIBS="-lnspr21")
|
|
;;
|
|
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
|
|
|
|
AC_MSG_CHECKING(necessary linker options)
|
|
AC_MSG_RESULT($G_THREAD_LIBS)
|
|
|
|
dnl determination of G_THREAD_CFLAGS
|
|
dnl ********************************
|
|
|
|
if test x"$have_threads" != xnone; then
|
|
G_THREAD_CFLAGS="-D_REENTRANT" # good default
|
|
|
|
case $host in
|
|
-aix*)
|
|
# FIXME: can somebody confirm this -D_THREAD_SAFE ???
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -D_THREAD_SAFE"
|
|
if test x"$GCC" = xyes; then
|
|
G_THREAD_CFLAGS="$G_THREAD_CFLAGS -mthreads"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
# if we are not finding the ctime_r function, then we probably are
|
|
# not using the proper multithread flag
|
|
old_CPPFLAGS=$CPPFLAGS
|
|
CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
|
|
AC_EGREP_HEADER([[^a-zA-Z_]ctime_r[^a-zA-Z_]], time.h, ,
|
|
G_THREAD_CFLAGS=
|
|
AC_MSG_WARN($FLAG_DOES_NOT_WORK))
|
|
CPPFLAGS=$old_CPPFLAGS
|
|
|
|
# if test x"$GCC" = xyes; then
|
|
# # older gcc's do not know the -fstack-check option and will
|
|
# # stop compiling, so just check this here
|
|
# old_CPPFLAGS="$CPPFLAGS"
|
|
# CPPFLAGS="$CPPFLAGS -fstack-check"
|
|
# AC_TRY_COMPILE(,,
|
|
# G_THREAD_CFLAGS="$G_THREAD_CFLAGS -fstack-check")
|
|
# CPPFLAGS=$old_CPPFLAGS
|
|
# else
|
|
# AC_MSG_WARN($THREAD_UNKNOWN_COMPILER)
|
|
# fi
|
|
|
|
AC_MSG_CHECKING(necessary compiler options)
|
|
|
|
AC_MSG_RESULT($G_THREAD_CFLAGS)
|
|
else
|
|
G_THREAD_CFLAGS=
|
|
fi
|
|
|
|
AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c")
|
|
AC_SUBST(G_THREAD_CFLAGS)
|
|
AC_SUBST(G_THREAD_LIBS)
|
|
|
|
CFLAGS="$CFLAGS $G_THREAD_CFLAGS"
|
|
|
|
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 <<\outfile_EOF
|
|
/* glibconfig.h */
|
|
/* This is a generated file. Please modify `configure.in' */
|
|
|
|
#ifndef GLIBCONFIG_H
|
|
#define GLIBCONFIG_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
outfile_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 x$glib_sys_poll_h = xyes; then
|
|
echo '#include <sys/types.h>' >> $outfile
|
|
echo '#include <sys/poll.h>' >> $outfile
|
|
fi
|
|
|
|
cat >> $outfile <<outfile_EOF
|
|
|
|
#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_MININT $glib_mi
|
|
#define G_MAXINT $glib_Mi
|
|
#define G_MINLONG $glib_ml
|
|
#define G_MAXLONG $glib_Ml
|
|
|
|
outfile_EOF
|
|
|
|
## this should always be true in a modern C/C++ compiler
|
|
cat >>$outfile <<outfile_EOF
|
|
typedef signed char gint8;
|
|
typedef unsigned char guint8;
|
|
outfile_EOF
|
|
|
|
if test -n "$gint16"; then
|
|
cat >>$outfile <<outfile_EOF
|
|
typedef signed $gint16 gint16;
|
|
typedef unsigned $gint16 guint16;
|
|
outfile_EOF
|
|
fi
|
|
if test -n "$gint32"; then
|
|
cat >>$outfile <<outfile_EOF
|
|
typedef signed $gint32 gint32;
|
|
typedef unsigned $gint32 guint32;
|
|
outfile_EOF
|
|
fi
|
|
if test -n "$gint64"; then
|
|
cat >>$outfile <<outfile_EOF
|
|
${glib_warning_guard}#define G_HAVE_GINT64 1
|
|
|
|
${glib_extension}typedef signed $gint64 gint64;
|
|
${glib_extension}typedef unsigned $gint64 guint64;
|
|
|
|
#define G_GINT64_CONSTANT(val) $gint64_constant
|
|
outfile_EOF
|
|
fi
|
|
|
|
if test -z "$glib_unknown_void_p"; then
|
|
cat >>$outfile <<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))
|
|
outfile_EOF
|
|
else
|
|
echo '#error SIZEOF_VOID_P unknown - This should never happen' >>$outfile
|
|
fi
|
|
|
|
cat >>$outfile <<outfile_EOF
|
|
$glib_atexit
|
|
$glib_memmove
|
|
$glib_defines
|
|
|
|
$glib_vacopy
|
|
|
|
#ifdef __cplusplus
|
|
#define G_HAVE_INLINE 1
|
|
#else /* !__cplusplus */
|
|
$glib_inline
|
|
#endif /* !__cplusplus */
|
|
|
|
#define G_BYTE_ORDER $g_byte_order
|
|
outfile_EOF
|
|
|
|
cat >>$outfile <<outfile_EOF
|
|
|
|
/* definitions for the default mutex implementation */
|
|
outfile_EOF
|
|
|
|
if test x$g_mutex_has_default = xyes; then
|
|
cat >>$outfile <<outfile_EOF
|
|
|
|
typedef struct _GStaticMutex GStaticMutex;
|
|
struct _GStaticMutex
|
|
{
|
|
$g_mutex_default_type default_mutex;
|
|
struct _GMutex* runtime_mutex;
|
|
};
|
|
#define G_STATIC_MUTEX_INIT { $g_mutex_default_init, NULL }
|
|
#define g_static_mutex_get_mutex(mutex) \
|
|
( g_thread_use_default_impl ? (GMutex*)&mutex.default_mutex : \
|
|
g_static_mutex_get_mutex_impl(&mutex.runtime_mutex) )
|
|
outfile_EOF
|
|
else
|
|
cat >>$outfile <<outfile_EOF
|
|
|
|
typedef struct _GMutex* GStaticMutex;
|
|
#define G_STATIC_MUTEX_INIT NULL
|
|
#define g_static_mutex_get_mutex(mutex) g_static_mutex_get_mutex_impl(&mutex)
|
|
outfile_EOF
|
|
fi
|
|
|
|
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 <<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))
|
|
outfile_EOF
|
|
done
|
|
|
|
cat >>$outfile <<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))
|
|
$glib_wc
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* GLIBCONFIG_H */
|
|
|
|
outfile_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.
|
|
|
|
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_mi=INT_MIN glib_Mi=INT_MAX
|
|
glib_ml=LONG_MIN glib_Ml=LONG_MAX
|
|
;;
|
|
x$ac_cv_header_values_h)
|
|
glib_values_h=yes
|
|
glib_ms=MINSHORT glib_Ms=MAXSHORT
|
|
glib_mi=MININT glib_Mi=MAXINT
|
|
glib_ml=MINLONG glib_Ml=MAXLONG
|
|
;;
|
|
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;;
|
|
$ac_cv_sizeof_int) gint16=int;;
|
|
esac
|
|
case 4 in
|
|
$ac_cv_sizeof_short) gint32=short;;
|
|
$ac_cv_sizeof_int) gint32=int;;
|
|
$ac_cv_sizeof_long) gint32=long;;
|
|
esac
|
|
case 8 in
|
|
$ac_cv_sizeof_int)
|
|
gint64=int
|
|
glib_extension=
|
|
glib_warning_guard=
|
|
gint64_constant='(val)'
|
|
;;
|
|
$ac_cv_sizeof_long)
|
|
gint64=long
|
|
glib_extension=
|
|
glib_warning_guard=
|
|
gint64_constant='(val##L)'
|
|
;;
|
|
$ac_cv_sizeof_long_long)
|
|
gint64='long long'
|
|
glib_extension='GLIB_WARNINGS_MAKE_PEOPLE_CRY '
|
|
glib_warning_guard="
|
|
#if defined (__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 8
|
|
# define GLIB_WARNINGS_MAKE_PEOPLE_CRY __extension__
|
|
#else
|
|
# define GLIB_WARNINGS_MAKE_PEOPLE_CRY
|
|
#endif
|
|
|
|
"
|
|
gint64_constant='(GLIB_WARNINGS_MAKE_PEOPLE_CRY (val##LL))'
|
|
;;
|
|
esac
|
|
|
|
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'
|
|
;;
|
|
*)
|
|
glib_memmove="
|
|
/* We make the assumption that if memmove isn't available, then
|
|
* bcopy will do the job. This isn't safe everywhere. (bcopy can't
|
|
* necessarily handle overlapping copies) */
|
|
#define g_memmove(d,s,n) G_STMT_START { bcopy ((s), (d), (n)); } G_STMT_END"
|
|
;;
|
|
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
|
|
|
|
if test x$glib_wchar_h = xyes; then
|
|
glib_wc='
|
|
#define G_HAVE_WCHAR_H 1'
|
|
fi
|
|
if test x$glib_wctype_h = xyes; then
|
|
glib_wc="\$glib_wc
|
|
#define G_HAVE_WCTYPE_H 1"
|
|
fi
|
|
if test x$glib_working_wctype = xno; then
|
|
glib_wc="\$glib_wc
|
|
#define G_HAVE_BROKEN_WCTYPE 1"
|
|
fi
|
|
|
|
case $have_threads in
|
|
posix)
|
|
g_mutex_has_default=yes
|
|
g_mutex_default_type='pthread_mutex_t'
|
|
g_mutex_default_init='PTHREAD_MUTEX_INITIALIZER'
|
|
g_mutex_header_file='pthread.h'
|
|
;;
|
|
solaris)
|
|
g_mutex_has_default=yes
|
|
g_mutex_default_type='mutex_t'
|
|
if test x$solaris_mutex_init_broken = xyes; then
|
|
g_mutex_default_init="{ { { 0, 0, 0, 0 }, USYNC_THREAD }, { { { 0, 0, 0, 0, 0, 0, 0, 0 } } }, 0}"
|
|
else
|
|
g_mutex_default_init="DEFAULTMUTEX"
|
|
fi
|
|
g_mutex_header_file='thread.h'
|
|
;;
|
|
nspr)
|
|
g_mutex_has_default=no
|
|
;;
|
|
*)
|
|
g_mutex_has_default=no
|
|
;;
|
|
esac
|
|
])
|
|
|
|
AC_OUTPUT([
|
|
Makefile
|
|
glib-config
|
|
gmodule/gmoduleconf.h
|
|
gmodule/Makefile
|
|
gthread/Makefile
|
|
docs/Makefile
|
|
],[case "$CONFIG_FILES" in
|
|
*glib-config*)chmod +x glib-config;;
|
|
esac])
|