# if backwards compatibility has been broken,
# set glib_binary_age _and_ glib_interface_age to 0.
#
+# in easier to understand terms:
+#
+# <mclasen> on the stable branch, interface age == micro
+# <mclasen> on the unstable (ie master), interface age = 0
+
m4_define([glib_major_version], [2])
-m4_define([glib_minor_version], [27])
-m4_define([glib_micro_version], [94])
+m4_define([glib_minor_version], [31])
+m4_define([glib_micro_version], [0])
m4_define([glib_interface_age], [0])
m4_define([glib_binary_age],
[m4_eval(100 * glib_minor_version + glib_micro_version)])
# Save this value here, since automake will set cflags later
cflags_set=${CFLAGS+set}
-AM_INIT_AUTOMAKE([1.10 no-define])
+AM_INIT_AUTOMAKE([1.11 no-define no-dist-gzip dist-xz tar-ustar])
+AM_MAINTAINER_MODE([enable])
-# Support silent build rules, requires at least automake-1.11. Disable
+# Support silent build rules. Disable
# by either passing --disable-silent-rules to configure or passing V=1
# to make
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+AM_SILENT_RULES([yes])
GLIB_MAJOR_VERSION=glib_major_version
GLIB_MINOR_VERSION=glib_minor_version
AC_SUBST(LT_AGE)
AC_SUBST(LT_CURRENT_MINUS_AGE)
-dnl Initialize maintainer mode
-AM_MAINTAINER_MODE
-
dnl Checks for programs.
AC_PROG_CC
AC_PROG_CPP
+AM_CONDITIONAL(HAVE_GCC, [test "$GCC" = "yes"])
+
AC_CANONICAL_HOST
AC_MSG_CHECKING([for the BeOS])
LDFLAGS="$LDFLAGS -framework Carbon"
fi
+gl_GLIBC21
+if test "x$GLIBC21" = "xyes"; then
+ AC_DEFINE([_GNU_SOURCE], 1, [Make all glibc extensions visible])
+fi
dnl declare --enable-* args and collect ac_help strings
AC_ARG_ENABLE(debug,
[AC_HELP_STRING([--disable-mem-pools],
[disable all glib memory pools])],,
[disable_mem_pools=no])
-AC_ARG_ENABLE(threads,
- [AC_HELP_STRING([--enable-threads],
- [turn on basic thread support [default=yes]
-([=no] will override --with-threads)])],,
- [enable_threads=yes])
AC_ARG_ENABLE(rebuilds,
[AC_HELP_STRING([--disable-rebuilds],
[disable all source autogeneration rules])],,
[enable_rebuilds=yes])
-if test "x$enable_threads" != "xyes"; then
- enable_threads=no
-fi
-
AC_MSG_CHECKING([whether to enable garbage collector friendliness])
if test "x$enable_gc_friendly" = "xyes"; then
AC_DEFINE(ENABLE_GC_FRIENDLY_DEFAULT, 1, [Whether to enable GC friendliness by default])
dnl to /lib if libdir is /usr/lib
AC_ARG_WITH(runtime-libdir,
[AC_HELP_STRING([--with-runtime-libdir=RELPATH],
- [Install runtime libraries relative to libdir])],
+ [install runtime libraries relative to libdir])],
[],
[with_runtime_libdir=""])
GLIB_RUNTIME_LIBDIR="$with_runtime_libdir"
AC_SUBST(PERL_PATH)
# Need suitable python path for greport
-AM_PATH_PYTHON(2.4,,PYTHON="/usr/bin/env python2.4")
+AM_PATH_PYTHON(2.5,,PYTHON="/usr/bin/env python2.5")
dnl ***********************
fi
fi
-gl_GLIBC21
AC_ARG_ENABLE(iconv-cache,
[AC_HELP_STRING([--enable-iconv-cache=@<:@yes/no/auto@:>@],
[cache iconv descriptors [default=auto]])],,
[enable_iconv_cache=auto])
-AC_MSG_CHECKING([Whether to cache iconv descriptors])
+AC_MSG_CHECKING([whether to cache iconv descriptors])
case $enable_iconv_cache in
auto)
if test $ac_cv_gnu_library_2_1 = yes; then
AC_SUBST(ZLIB_LIBS)
fi
+PKG_CHECK_MODULES(LIBFFI, [libffi >= 3.0.0])
+AC_SUBST(LIBFFI_CFLAGS)
+AC_SUBST(LIBFFI_LIBS)
+
dnl
dnl gettext support
dnl
AC_CHECK_FUNCS(mmap posix_memalign memalign valloc fsync pipe2)
AC_CHECK_FUNCS(atexit on_exit timegm gmtime_r)
+dnl don't use AC_CHECK_FUNCS here, otherwise HAVE_QSORT_R will
+dnl be automatically defined, which we don't want to do
+dnl until we have checked this function is actually usable
+AC_CHECK_FUNC([qsort_r])
+
+# BSD has a qsort_r with wrong argument order
+if test x$ac_cv_func_qsort_r = xyes ; then
+ AC_CACHE_CHECK([if qsort_r uses glibc compatible argument order], glib_cv_have_qsort_r, [
+ AC_RUN_IFELSE([AC_LANG_SOURCE([[
+ #define _GNU_SOURCE
+ #include <stdlib.h>
+
+ static int
+ cmp (const void *a, const void *b, void *c)
+ {
+ const int *ia = a;
+ const int *ib = b;
+
+ if (*ia < *ib)
+ return -1;
+ else if (*ia > *ib)
+ return 1;
+ else
+ return 0;
+ }
+
+ int
+ main (int argc, char **argv)
+ {
+ int arr[3] = { 1, 2, 0 };
+ int d = 3;
+
+ qsort_r (arr, 3, sizeof (int), cmp, &d);
+
+ if (arr[0] == 0 && arr[1] == 1 && arr[2] == 2)
+ return 0;
+ else
+ return 1;
+ }]])],[glib_cv_have_qsort_r=yes],[glib_cv_have_qsort_r=no])])
+fi
+
+if test x$glib_cv_have_qsort_r = xyes ; then
+ AC_DEFINE(HAVE_QSORT_R, 1, [Define to 1 if you have the 'qsort_r' function])
+fi
+
AC_CHECK_SIZEOF(char)
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(long)
dnl truely know which ones of `inline', `__inline' and `__inline__' are
dnl actually supported.
AC_CACHE_CHECK([for __inline],glib_cv_has__inline,[
- AC_COMPILE_IFELSE([
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
__inline int foo () { return 0; }
int main () { return foo (); }
- ],
+ ]])],
glib_cv_has__inline=yes
,
glib_cv_has__inline=no
xyes) AC_DEFINE(G_HAVE___INLINE,1,[Have __inline keyword])
esac
AC_CACHE_CHECK([for __inline__],glib_cv_has__inline__,[
- AC_COMPILE_IFELSE([
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
__inline__ int foo () { return 0; }
int main () { return foo (); }
- ],
+ ]])],
glib_cv_has__inline__=yes
,
glib_cv_has__inline__=no
xyes) AC_DEFINE(G_HAVE___INLINE__,1,[Have __inline__ keyword])
esac
AC_CACHE_CHECK([for inline], glib_cv_hasinline,[
- AC_COMPILE_IFELSE([
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#undef inline
inline int foo () { return 0; }
int main () { return foo (); }
- ],
+ ]])],
glib_cv_hasinline=yes
,
glib_cv_hasinline=no
# if we can use inline functions in headers
AC_MSG_CHECKING(if inline functions in headers work)
-AC_LINK_IFELSE([
+AC_LINK_IFELSE([AC_LANG_SOURCE([[
#if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__)
# undef inline
# define inline __inline__
int
main (void) {
int i = 1;
-}],[g_can_inline=yes],[g_can_inline=no])
+}]])],[g_can_inline=yes],[g_can_inline=no])
AC_MSG_RESULT($g_can_inline)
dnl *** check for working do while(0) macros ***
# check for GNUC visibility support
AC_MSG_CHECKING(for GNUC visibility attribute)
-GLIB_CHECK_COMPILE_WARNINGS([
+GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
void
__attribute__ ((visibility ("hidden")))
f_hidden (void)
f_default();
return 0;
}
-],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
+]])],g_have_gnuc_visibility=yes,g_have_gnuc_visibility=no)
AC_MSG_RESULT($g_have_gnuc_visibility)
AM_CONDITIONAL(HAVE_GNUC_VISIBILITY, [test x$g_have_gnuc_visibility = xyes])
AC_CHECK_HEADERS([sys/vfs.h sys/mount.h sys/vmount.h sys/statfs.h sys/statvfs.h])
AC_CHECK_HEADERS([mntent.h sys/mnttab.h sys/vfstab.h sys/mntctl.h sys/sysctl.h fstab.h])
AC_CHECK_HEADERS([sys/uio.h sys/mkdev.h])
+AC_CHECK_HEADERS([linux/magic.h])
+AC_CHECK_HEADERS([sys/prctl.h])
# check for structure fields
AC_CHECK_MEMBERS([struct stat.st_mtimensec, struct stat.st_mtim.tv_nsec, struct stat.st_atimensec, struct stat.st_atim.tv_nsec, struct stat.st_ctimensec, struct stat.st_ctim.tv_nsec])
#endif])
# struct statvfs.f_basetype is available on Solaris but not for Linux.
AC_CHECK_MEMBERS([struct statvfs.f_basetype],,, [#include <sys/statvfs.h>])
-AC_CHECK_MEMBERS([struct tm.tm_gmtoff])
+AC_CHECK_MEMBERS([struct statvfs.f_fstypename],,, [#include <sys/statvfs.h>])
+AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[#include <time.h>])
# Checks for libcharset
AM_LANGINFO_CODESET
-gl_GLIBC21
AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
AC_CHECK_FUNCS(setlocale)
dnl
if test $ac_cv_sizeof_size_t = $ac_cv_sizeof_int &&
test $ac_cv_sizeof_size_t = $ac_cv_sizeof_long ; then
- GLIB_CHECK_COMPILE_WARNINGS([
+ GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
#if defined(_AIX) && !defined(__GNUC__)
#pragma options langlvl=stdc89
#endif
unsigned int *size_int = &s;
return (int)*size_int;
}
- ],glib_size_type=int,
- [GLIB_CHECK_COMPILE_WARNINGS([
+ ]])],glib_size_type=int,
+ [GLIB_CHECK_COMPILE_WARNINGS([AC_LANG_SOURCE([[
#if defined(_AIX) && !defined(__GNUC__)
#pragma options langlvl=stdc89
#endif
unsigned long *size_long = &s;
return (int)*size_long;
}
- ],glib_size_type=long)])
+ ]])],glib_size_type=long)])
fi
AC_MSG_RESULT(unsigned $glib_size_type)
# Check for some functions
AC_CHECK_FUNCS(lstat strerror strsignal memmove vsnprintf stpcpy strcasecmp strncasecmp poll getcwd vasprintf setenv unsetenv getc_unlocked readlink symlink fdwalk memmem)
-AC_CHECK_FUNCS(chown lchmod lchown fchmod fchown link statvfs statfs utimes getgrgid getpwuid)
-AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getmntinfo)
+AC_CHECK_FUNCS(chown lchmod lchown fchmod fchown link utimes getgrgid getpwuid)
+AC_CHECK_FUNCS(getmntent_r setmntent endmntent hasmntopt getfsstat getvfsstat)
# Check for high-resolution sleep functions
AC_CHECK_FUNCS(splice)
+# To avoid finding a compatibility unusable statfs, which typically
+# successfully compiles, but warns to use the newer statvfs interface:
+AS_IF([test $ac_cv_header_sys_statvfs_h = yes], [AC_CHECK_FUNCS([statvfs])])
+AS_IF([test $ac_cv_header_sys_statfs_h = yes -o $ac_cv_header_sys_mount_h = yes], [AC_CHECK_FUNCS([statfs])])
+
+AC_MSG_CHECKING([whether to use statfs or statvfs])
+# Some systems have both statfs and statvfs, pick the most "native" for these
+AS_IF([test x$ac_cv_func_statfs = xyes && test x$ac_cv_func_statvfs = xyes],
+ [
+ # on solaris and irix, statfs doesn't even have the f_bavail field
+ AS_IF([test x$ac_cv_member_struct_statfs_f_bavail = xno],
+ [ac_cv_func_statfs=no],
+ # else, at least on linux, statfs is the actual syscall
+ [ac_cv_func_statvfs=no])
+ ])
+
+AS_IF([test x$ac_cv_func_statfs = xyes],
+ [
+ AC_DEFINE([USE_STATFS], [1], [Define to use statfs()])
+ AC_MSG_RESULT([statfs])
+ ],
+ [test x$ac_cv_func_statvfs = xyes],
+ [
+ AC_DEFINE([USE_STATVFS], [1], [Define to use statvfs()])
+ AC_MSG_RESULT([statvfs])
+ ],
+ [ AC_MSG_RESULT([neither])])
+
AC_CHECK_HEADERS(crt_externs.h)
AC_CHECK_FUNCS(_NSGetEnviron)
+AC_CHECK_FUNCS(newlocale uselocale strtod_l strtoll_l strtoull_l)
+
AC_FUNC_VSNPRINTF_C99
AC_FUNC_PRINTF_UNIX98
fi
AC_CHECK_FUNCS(getprotobyname_r endservent)
-AC_CHECK_HEADERS([netdb.h wspiapi.h])
+AC_CHECK_HEADERS([netdb.h wspiapi.h arpa/nameser_compat.h])
-# For gio/libasyncns
if test $glib_native_win32 = no; then
- AC_CHECK_FUNCS(strndup setresuid setreuid)
- AC_CHECK_HEADERS(sys/prctl.h arpa/nameser_compat.h)
-
# We can't just use AC_CHECK_FUNC/AC_CHECK_LIB here. Bug 586150
+ NETWORK_LIBS=""
AC_MSG_CHECKING([for res_query])
AC_TRY_LINK([#include <sys/types.h>
-#include <netinet/in.h>
-#include <arpa/nameser.h>
-#include <resolv.h>],
- [res_query("test", 0, 0, (void *)0, 0);],
- [AC_MSG_RESULT([yes])],
+ #include <netinet/in.h>
+ #include <arpa/nameser.h>
+ #include <resolv.h>
+ ],[
+ res_query("test", 0, 0, (void *)0, 0);
+ ],[AC_MSG_RESULT([yes])],
[save_libs="$LIBS"
LIBS="-lresolv $LIBS"
AC_TRY_LINK([#include <sys/types.h>
-#include <netinet/in.h>
-#include <arpa/nameser.h>
-#include <resolv.h>],
- [res_query("test", 0, 0, (void *)0, 0);],
- [AC_MSG_RESULT([in -lresolv])
- LIBASYNCNS_LIBADD="-lresolv"],
+ #include <netinet/in.h>
+ #include <arpa/nameser.h>
+ #include <resolv.h>
+ ],[
+ res_query("test", 0, 0, (void *)0, 0);
+ ],[AC_MSG_RESULT([in -lresolv])
+ NETWORK_LIBS="-lresolv $NETWORK_LIBS"],
[LIBS="-lbind $save_libs"
AC_TRY_LINK([#include <resolv.h>],
[res_query("test", 0, 0, (void *)0, 0);],
[AC_MSG_RESULT([in -lbind])
- LIBASYNCNS_LIBADD="-lbind"],
+ NETWORK_LIBS="-lbind $NETWORK_LIBS"],
[AC_MSG_ERROR(not found)])])
LIBS="$save_libs"])
- AC_SUBST(LIBASYNCNS_LIBADD)
+ AC_CHECK_FUNC(socket, :, AC_CHECK_LIB(socket, socket,
+ [NETWORK_LIBS="-lsocket $NETWORK_LIBS"],
+ [AC_MSG_ERROR(Could not find socket())]))
fi
+AC_SUBST(NETWORK_LIBS)
case $host in
*-*-solaris* )
AC_DEFINE(HAVE_CODESET,1,[Have nl_langinfo (CODESET)])
fi
+dnl Check for nl_langinfo and LC_TIME parts that are needed in gdatetime.c
+AC_CACHE_CHECK([for nl_langinfo (PM_STR)],glib_cv_langinfo_time,[
+ AC_TRY_COMPILE([#include <langinfo.h>],
+ [char *str;
+ str = nl_langinfo (PM_STR);
+ str = nl_langinfo (D_T_FMT);
+ str = nl_langinfo (D_FMT);
+ str = nl_langinfo (T_FMT);
+ str = nl_langinfo (T_FMT_AMPM);
+ str = nl_langinfo (MON_1);
+ str = nl_langinfo (ABMON_12);
+ str = nl_langinfo (DAY_1);
+ str = nl_langinfo (ABDAY_7);],
+ [glib_cv_langinfo_time=yes],
+ [glib_cv_langinfo_time=no])])
+if test x$glib_cv_langinfo_time = xyes; then
+ AC_DEFINE(HAVE_LANGINFO_TIME,1,[Have nl_langinfo (PM_STR)])
+fi
+
+dnl Check for nl_langinfo and _NL_CTYPE_OUTDIGITn_WC
+AC_CACHE_CHECK([for nl_langinfo (_NL_CTYPE_OUTDIGITn_WC)], glib_cv_langinfo_outdigit,[
+ AC_TRY_COMPILE([#include <langinfo.h>],
+ [char *str;
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT0_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT1_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT2_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT3_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT4_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT5_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT6_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT7_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT8_WC);
+ str = nl_langinfo (_NL_CTYPE_OUTDIGIT9_WC);],
+ [glib_cv_langinfo_outdigit=yes],
+ [glib_cv_langinfo_outdigit=no])])
+if test x$glib_cv_langinfo_outdigit = xyes; then
+ AC_DEFINE(HAVE_LANGINFO_OUTDIGIT,1,[Have nl_langinfo (_NL_CTYPE_OUTDIGITn_WC)])
+fi
+
dnl ****************************************
dnl *** posix_memalign ***
dnl ****************************************
dnl we currently check for all three va_copy possibilities, so we get
dnl all results in config.log for bug reports.
AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
- AC_LINK_IFELSE([#include <stdarg.h>
+ AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
#include <stdlib.h>
void f (int i, ...) {
va_list args1, args2;
int main() {
f (0, 42);
return 0;
- }],
+ }]])],
[glib_cv_va_copy=yes],
[glib_cv_va_copy=no])
])
AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
- AC_LINK_IFELSE([#include <stdarg.h>
+ AC_LINK_IFELSE([AC_LANG_SOURCE([[#include <stdarg.h>
#include <stdlib.h>
void f (int i, ...) {
va_list args1, args2;
int main() {
f (0, 42);
return 0;
- }],
+ }]])],
[glib_cv___va_copy=yes],
[glib_cv___va_copy=no])
])
dnl *********************************
AC_ARG_WITH(gio-module-dir,
- [AC_HELP_STRING([--with-gio-module-dir=PATH],
- [Load gio modules from this directory [LIBDIR/gio/modules]])],
+ [AC_HELP_STRING([--with-gio-module-dir=DIR],
+ [load gio modules from this directory [LIBDIR/gio/modules]])],
[],
[with_gio_module_dir='${libdir}/gio/modules'])
GIO_MODULE_DIR=$with_gio_module_dir
dnl **********************************
dnl *** Check for libselinux (GIO) ***
dnl **********************************
-AC_ARG_ENABLE(selinux, [ --disable-selinux build without selinux support])
+AC_ARG_ENABLE(selinux,
+ AC_HELP_STRING([--disable-selinux],
+ [build without selinux support]))
msg_selinux=no
SELINUX_LIBS=
if test "x$enable_selinux" != "xno"; then
dnl ** Check for Solaris FEN (GIO) **
dnl *********************************
fen_support=no
-AC_COMPILE_IFELSE([
+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include <port.h>
#ifndef PORT_SOURCE_FILE
#error "Please upgrade to Nevada 72 or above to suppoert FEN"
#endif
-int main() { return 0; } ],
+int main() { return 0; } ]])],
[
fen_support=yes
],)
should_disable_fam=no
-AC_ARG_ENABLE(fam, [ --disable-fam build without enabling fam for file system monitoring],
+AC_ARG_ENABLE(fam,
+ AC_HELP_STRING([--disable-fam],
+ [don't use fam for file system monitoring]),
[
if test "x$enable_fam" = "xno"; then
should_disable_fam=yes
- echo "Not building FAM support"
fi
]
)
dnl *****************************
dnl *** Check for xattr (GIO) ***
dnl *****************************
-AC_ARG_ENABLE(xattr, [ --disable-xattr build without xattr support])
+AC_ARG_ENABLE(xattr,
+ AC_HELP_STRING([--disable-xattr], [build without xattr support]))
msg_xattr=no
XATTR_LIBS=
if test "x$enable_xattr" != "xno"; then
dnl ***********************
AC_ARG_WITH(threads,
- [AC_HELP_STRING([--with-threads=@<:@none/posix/dce/win32@:>@],
+ [AC_HELP_STRING([--with-threads=@<:@posix/win32@:>@],
[specify a thread implementation to use])],
[if test "x$with_threads" = x; then
want_threads=yes
want_threads=$with_threads
fi],
[want_threads=yes])
-if test "x$enable_threads" = "xno"; 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."
+ computer."
FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your
platform (normally it's "_REENTRANT"). I'll not use any flag on
"
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."
+ provide information on your thread implementation."
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
dnl determination of thread implementation
dnl ***************************************
-# have_threads=no means no thread support
-# have_threads=none means no default thread implementation
-
have_threads=no
if test "x$want_threads" = xyes || test "x$want_threads" = xposix \
|| test "x$want_threads" = xdce; then
[pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;],
have_threads=posix)
fi
- if test "x$have_threads" = xno; then
- AC_TRY_COMPILE([#include <pthread.h>],
- [pthread_mutex_t m;
- pthread_mutex_init (&m, pthread_mutexattr_default);],
- have_threads=dce)
- fi
# Tru64Unix requires -pthread to find pthread.h. See #103020
CPPFLAGS="$CPPFLAGS -pthread"
if test "x$have_threads" = xno; then
;;
esac
fi
-if test "x$want_threads" = xnone; then
- have_threads=none
-fi
AC_MSG_CHECKING(for thread implementation)
-if test "x$have_threads" = xno && test "x$want_threads" != xno; then
+if test "x$have_threads" = xno; then
AC_MSG_RESULT(none available)
- AC_MSG_WARN($THREAD_NO_IMPLEMENTATION)
+ AC_MSG_ERROR($THREAD_NO_IMPLEMENTATION)
else
AC_MSG_RESULT($have_threads)
fi
&& errno != 0;
}])
-if test x"$have_threads" != xno; then
-
- if test x"$have_threads" = xposix; then
- # First we test for posix, whether -pthread or -pthreads do the trick as
- # both CPPFLAG and LIBS.
- # One of them does for most gcc versions and some other platforms/compilers
- # too and could be considered as the canonical way to go.
- case $host in
- *-*-cygwin*|*-*-darwin*)
- # skip cygwin and darwin -pthread or -pthreads test
- ;;
- *-solaris*)
- # These compiler/linker flags work with both Sun Studio and gcc
- # Sun Studio expands -mt to -D_REENTRANT and -lthread
- # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
- G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
- G_THREAD_LIBS="-lpthread -lthread"
- ;;
- *)
- for flag in pthread pthreads mt; do
- glib_save_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS -$flag"
- AC_TRY_RUN(glib_thread_test(0),
- glib_flag_works=yes,
- glib_flag_works=no,
- [AC_LINK_IFELSE(glib_thread_test(0),
- glib_flag_works=yes,
- glib_flag_works=no)])
- CFLAGS="$glib_save_CFLAGS"
- if test $glib_flag_works = yes ; then
- G_THREAD_CFLAGS=-$flag
- G_THREAD_LIBS=-$flag
- break;
- fi
- done
- ;;
- esac
- fi
+if test x"$have_threads" = xposix; then
+ # First we test for posix, whether -pthread or -pthreads do the trick as
+ # both CPPFLAG and LIBS.
+ # One of them does for most gcc versions and some other platforms/compilers
+ # too and could be considered as the canonical way to go.
+ case $host in
+ *-*-cygwin*|*-*-darwin*)
+ # skip cygwin and darwin -pthread or -pthreads test
+ ;;
+ *-solaris*)
+ # These compiler/linker flags work with both Sun Studio and gcc
+ # Sun Studio expands -mt to -D_REENTRANT and -lthread
+ # gcc expands -pthreads to -D_REENTRANT -D_PTHREADS -lpthread
+ G_THREAD_CFLAGS="-D_REENTRANT -D_PTHREADS"
+ G_THREAD_LIBS="-lpthread -lthread"
+ ;;
+ *)
+ for flag in pthread pthreads mt; do
+ glib_save_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -$flag"
+ AC_TRY_RUN(glib_thread_test(0),
+ glib_flag_works=yes,
+ glib_flag_works=no,
+ [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test(0))],
+ glib_flag_works=yes,
+ glib_flag_works=no)])
+ CFLAGS="$glib_save_CFLAGS"
+ if test $glib_flag_works = yes ; then
+ G_THREAD_CFLAGS=-$flag
+ G_THREAD_LIBS=-$flag
+ break;
+ fi
+ done
+ ;;
+ esac
+fi
- if test x"$G_THREAD_CFLAGS" = x; then
+if test x"$G_THREAD_CFLAGS" = x; then
- # The canonical -pthread[s] does not work. Try something different.
+ # The canonical -pthread[s] does not work. Try something different.
- case $host in
+ case $host in
*-aix*)
if test x"$GCC" = xyes; then
# GCC 3.0 and above needs -pthread.
*-dg-dgux*) # DG/UX
G_THREAD_CFLAGS="-D_REENTRANT -D_POSIX4A_DRAFT10_SOURCE"
;;
- *-osf*)
- # So we are using dce threads. posix threads are already
- # catched above.
- G_THREAD_CFLAGS="-threads"
- G_THREAD_LIBS=$G_THREAD_CFLAGS
- ;;
*-sysv5uw7*) # UnixWare 7
# We are not using gcc with -pthread. Catched above.
G_THREAD_CFLAGS="-Kthread"
*)
G_THREAD_CFLAGS="-D_REENTRANT" # good default guess otherwise
;;
- esac
-
- fi
+ esac
+
+fi
- # if we are not finding the localtime_r function, then we probably are
- # not using the proper multithread flag
+# if we are not finding the localtime_r function, then we probably are
+# not using the proper multithread flag
- glib_save_CPPFLAGS="$CPPFLAGS"
- CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
+glib_save_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
- # First we test, whether localtime_r is declared in time.h
- # directly. Then we test whether a macro localtime_r exists, in
- # which case localtime_r in the test program is replaced and thus
- # if we still find localtime_r in the output, it is not defined as
- # a macro.
+# First we test, whether localtime_r is declared in time.h
+# directly. Then we test whether a macro localtime_r exists, in
+# which case localtime_r in the test program is replaced and thus
+# if we still find localtime_r in the output, it is not defined as
+# a macro.
- AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
- [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
+AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>], ,
+ [AC_EGREP_CPP([[^a-zA-Z1-9_]localtime_r[^a-zA-Z1-9_]], [#include <time.h>
localtime_r(a,b)],
- AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
+ AC_MSG_WARN($FLAG_DOES_NOT_WORK))])
- CPPFLAGS="$glib_save_CPPFLAGS"
+CPPFLAGS="$glib_save_CPPFLAGS"
- AC_MSG_CHECKING(thread related cflags)
- AC_MSG_RESULT($G_THREAD_CFLAGS)
- CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
-fi
+AC_MSG_CHECKING(thread related cflags)
+AC_MSG_RESULT($G_THREAD_CFLAGS)
+CPPFLAGS="$CPPFLAGS $G_THREAD_CFLAGS"
dnl determination of G_THREAD_LIBS
dnl ******************************
-mutex_has_default=no
case $have_threads in
- posix|dce)
+ posix)
glib_save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
if test x"$G_THREAD_LIBS" = x; then
*)
G_THREAD_LIBS=error
glib_save_LIBS="$LIBS"
- for thread_lib in "" pthread pthread32 pthreads thread dce; do
+ for thread_lib in "" pthread pthread32 pthreads thread; do
if test x"$thread_lib" = x; then
add_thread_lib=""
IN=""
AC_TRY_RUN(glib_thread_test($defattr),
glib_result=yes,
glib_result=no,
- [AC_LINK_IFELSE(glib_thread_test($defattr),
+ [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_thread_test($defattr))],
glib_result=yes,
glib_result=no)])
AC_MSG_RESULT($glib_result)
AC_TRY_RUN(glib_sched_priority_test,
glib_result=yes,
glib_result=no,
- [AC_LINK_IFELSE(glib_sched_priority_test,
+ [AC_LINK_IFELSE([AC_LANG_SOURCE(glib_sched_priority_test)],
glib_result=yes,
glib_result=no)])
AC_MSG_RESULT($glib_result)
fi
done
LIBS="$glib_save_LIBS"
- 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
+ g_threads_impl="POSIX"
AC_SUBST(GTHREAD_COMPILE_IMPL_DEFINES)
CPPFLAGS="$glib_save_CPPFLAGS"
;;
win32)
g_threads_impl="WIN32"
;;
- none|no)
- g_threads_impl="NONE"
- ;;
*)
g_threads_impl="NONE"
G_THREAD_LIBS=error
dnl check for mt safe function variants and some posix functions
dnl ************************************************************
-if test x"$have_threads" != xno; 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 gmtime_r)
- if test "$ac_cv_header_pwd_h" = "yes"; then
- AC_CACHE_CHECK([for posix getpwuid_r],
- ac_cv_func_posix_getpwuid_r,
- [AC_TRY_RUN([
+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 gmtime_r)
+if test "$ac_cv_header_pwd_h" = "yes"; then
+ AC_CACHE_CHECK([for posix getpwuid_r],
+ ac_cv_func_posix_getpwuid_r,
+ [AC_TRY_RUN([
#include <errno.h>
#include <pwd.h>
int main () {
return (error < 0 && errno == ENOSYS)
|| error == ENOSYS;
} ],
- [ac_cv_func_posix_getpwuid_r=yes],
- [ac_cv_func_posix_getpwuid_r=no])])
- GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
- if test "$ac_cv_func_posix_getpwuid_r" = yes; then
- AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
- [Have POSIX function getpwuid_r])
- else
- AC_CACHE_CHECK([for nonposix getpwuid_r],
- ac_cv_func_nonposix_getpwuid_r,
- [AC_TRY_LINK([#include <pwd.h>],
- [char buffer[10000];
- struct passwd pwd;
- getpwuid_r (0, &pwd, buffer,
- sizeof (buffer));],
- [ac_cv_func_nonposix_getpwuid_r=yes],
- [ac_cv_func_nonposix_getpwuid_r=no])])
- GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
- if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
- AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
- [Have non-POSIX function getpwuid_r])
- fi
+ [ac_cv_func_posix_getpwuid_r=yes],
+ [ac_cv_func_posix_getpwuid_r=no])])
+ GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
+ if test "$ac_cv_func_posix_getpwuid_r" = yes; then
+ AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
+ [Have POSIX function getpwuid_r])
+ else
+ AC_CACHE_CHECK([for nonposix getpwuid_r],
+ ac_cv_func_nonposix_getpwuid_r,
+ [AC_TRY_LINK([#include <pwd.h>],
+ [char buffer[10000];
+ struct passwd pwd;
+ getpwuid_r (0, &pwd, buffer,
+ sizeof (buffer));],
+ [ac_cv_func_nonposix_getpwuid_r=yes],
+ [ac_cv_func_nonposix_getpwuid_r=no])])
+ GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
+ if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
+ AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
+ [Have non-POSIX function getpwuid_r])
fi
fi
- if test "$ac_cv_header_grp_h" = "yes"; then
- AC_CACHE_CHECK([for posix getgrgid_r],
- ac_cv_func_posix_getgrgid_r,
- [AC_TRY_RUN([
+fi
+if test "$ac_cv_header_grp_h" = "yes"; then
+ AC_CACHE_CHECK([for posix getgrgid_r],
+ ac_cv_func_posix_getgrgid_r,
+ [AC_TRY_RUN([
#include <errno.h>
#include <grp.h>
int main () {
return (error < 0 && errno == ENOSYS)
|| error == ENOSYS;
} ],
- [ac_cv_func_posix_getgrgid_r=yes],
- [ac_cv_func_posix_getgrgid_r=no])])
- GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
- if test "$ac_cv_func_posix_getgrgid_r" = yes; then
- AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
- [Have POSIX function getgrgid_r])
- else
- AC_CACHE_CHECK([for nonposix getgrgid_r],
- ac_cv_func_nonposix_getgrgid_r,
- [AC_TRY_LINK([#include <grp.h>],
- [char buffer[10000];
- struct group grp;
- getgrgid_r (0, &grp, buffer,
- sizeof (buffer));],
- [ac_cv_func_nonposix_getgrgid_r=yes],
- [ac_cv_func_nonposix_getgrgid_r=no])])
- GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
- if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
- AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
- [Have non-POSIX function getgrgid_r])
- fi
+ [ac_cv_func_posix_getgrgid_r=yes],
+ [ac_cv_func_posix_getgrgid_r=no])])
+ GLIB_ASSERT_SET(ac_cv_func_posix_getgrgid_r)
+ if test "$ac_cv_func_posix_getgrgid_r" = yes; then
+ AC_DEFINE(HAVE_POSIX_GETGRGID_R,1,
+ [Have POSIX function getgrgid_r])
+ else
+ AC_CACHE_CHECK([for nonposix getgrgid_r],
+ ac_cv_func_nonposix_getgrgid_r,
+ [AC_TRY_LINK([#include <grp.h>],
+ [char buffer[10000];
+ struct group grp;
+ getgrgid_r (0, &grp, buffer,
+ sizeof (buffer));],
+ [ac_cv_func_nonposix_getgrgid_r=yes],
+ [ac_cv_func_nonposix_getgrgid_r=no])])
+ GLIB_ASSERT_SET(ac_cv_func_nonposix_getgrgid_r)
+ if test "$ac_cv_func_nonposix_getgrgid_r" = yes; then
+ AC_DEFINE(HAVE_NONPOSIX_GETGRGID_R,1,
+ [Have non-POSIX function getgrgid_r])
fi
fi
- LIBS="$G_THREAD_LIBS $LIBS"
- if test x"$have_threads" = xposix; then
- glib_save_CPPFLAGS="$CPPFLAGS"
- CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
- dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
- 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)
+fi
+LIBS="$G_THREAD_LIBS $LIBS"
+if test x"$have_threads" = xposix; then
+ glib_save_CPPFLAGS="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES"
+ dnl we might grow sizeof(pthread_t) later on, so use a dummy name here
+ 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,1,
+ [Have function pthread_attr_setstacksize])],
+ [AC_MSG_RESULT(no)])
+ AC_MSG_CHECKING(for minimal/maximal thread priority)
+ if test x"$posix_priority_min" = x; 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" = x; then
+ # AIX
+ AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
+ PTHREAD_PRIO_MIN],,[
+ posix_priority_min=PTHREAD_PRIO_MIN
+ posix_priority_max=PTHREAD_PRIO_MAX])
+ fi
+ if test x"$posix_priority_min" = x; 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_MSG_CHECKING(for pthread_setschedparam)
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,1,
- [Have function pthread_attr_setstacksize])],
- [AC_MSG_RESULT(no)])
- AC_MSG_CHECKING(for minimal/maximal thread priority)
- if test x"$posix_priority_min" = x; 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" = x; then
- # AIX
- AC_EGREP_CPP(PTHREAD_PRIO_MIN,[#include <pthread.h>
- PTHREAD_PRIO_MIN],,[
- posix_priority_min=PTHREAD_PRIO_MIN
- posix_priority_max=PTHREAD_PRIO_MAX])
- fi
- if test x"$posix_priority_min" = x; 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_MSG_CHECKING(for pthread_setschedparam)
- AC_TRY_LINK([#include <pthread.h>],
- [pthread_t t; pthread_setschedparam(t, 0, NULL)],
- [AC_MSG_RESULT(yes)
- AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
- AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
- [AC_MSG_RESULT(no)
- AC_MSG_WARN($POSIX_NO_PRIORITIES)])
- 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,[The POSIX RT yield function])
- CPPFLAGS="$glib_save_CPPFLAGS"
-
- elif test x"$have_threads" = xwin32; then
- # It's a pointer to a private struct
- GLIB_SIZEOF(,struct _GThreadData *, system_thread)
+ [pthread_t t; pthread_setschedparam(t, 0, NULL)],
+ [AC_MSG_RESULT(yes)
+ AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min,[Minimum POSIX RT priority])
+ AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max,[Maximum POSIX RT priority])],
+ [AC_MSG_RESULT(no)
+ AC_MSG_WARN($POSIX_NO_PRIORITIES)])
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,[The POSIX RT yield function])
+ CPPFLAGS="$glib_save_CPPFLAGS"
+
+elif test x"$have_threads" = xwin32; then
+ # It's a pointer to a private struct
+ GLIB_SIZEOF(,struct _GThreadData *, system_thread)
+fi
- LIBS="$glib_save_LIBS"
+LIBS="$glib_save_LIBS"
- # now spit out all the warnings.
- if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
- test "$ac_cv_func_nonposix_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
-fi
+# now spit out all the warnings.
+if test "$ac_cv_func_posix_getpwuid_r" != "yes" &&
+ test "$ac_cv_func_nonposix_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
if test x"$glib_cv_sizeof_system_thread" = x; then
# use a pointer as a fallback.
;;
esac
-AM_CONDITIONAL(HAVE_THREADS, [test "$have_threads" != "none"])
-AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c",
- [Source file containing theread implementation])
AC_SUBST(G_THREAD_CFLAGS)
AC_SUBST(G_THREAD_LIBS)
AC_SUBST(G_THREAD_LIBS_FOR_GTHREAD)
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
-if test $mutex_has_default = yes ; then
- glib_save_CPPFLAGS="$CPPFLAGS"
- glib_save_LIBS="$LIBS"
- LIBS="$G_THREAD_LIBS $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"
-fi
-
AC_CHECK_FUNCS(clock_gettime, [], [
AC_CHECK_LIB(rt, clock_gettime, [
AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
fi
-dnl ********************************
-dnl *** g_atomic_* tests for gcc ***
-dnl ********************************
+dnl ************************
+dnl *** g_atomic_* tests ***
+dnl ************************
-AC_MSG_CHECKING([whether to use assembler code for atomic operations])
+ case $host_cpu in
+ i?86|x86_64|s390|s390x|arm*|crisv32*|etrax*)
+ glib_memory_barrier_needed=no
+ ;;
+ sparc*|alpha*|powerpc*|ia64)
+ glib_memory_barrier_needed=yes
+ ;;
+ *)
+ glib_memory_barrier_needed=yes
+ ;;
+ esac
glib_cv_gcc_has_builtin_atomic_operations=no
if test x"$GCC" = xyes; then
- AC_MSG_CHECKING([whether GCC supports build-in atomic intrinsics])
+ AC_MSG_CHECKING([whether GCC supports built-in atomic intrinsics])
AC_TRY_LINK([],
[int i;
__sync_synchronize ();
[glib_cv_gcc_has_builtin_atomic_operations=no])
AC_MSG_RESULT($glib_cv_gcc_has_builtin_atomic_operations)
- if test $glib_cv_gcc_has_builtin_atomic_operations = yes; then
- glib_memory_barrier_needed=yes
- else
- case $host_cpu in
- i386)
- AC_MSG_RESULT([none])
- glib_memory_barrier_needed=no
- ;;
- i?86)
- AC_MSG_RESULT([i486])
- AC_DEFINE_UNQUOTED(G_ATOMIC_I486, 1,
- [i486 atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- sparc*)
- SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
- when you are using a sparc with v9 instruction set (most
- sparcs nowadays). This will make the code for atomic
- operations much faster. The resulting code will not run
- on very old sparcs though."
-
- AC_LINK_IFELSE([[
- main ()
- {
- int tmp1, tmp2, tmp3;
- __asm__ __volatile__("casx [%2], %0, %1"
- : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
- }]],
- AC_MSG_RESULT([sparcv9])
- AC_DEFINE_UNQUOTED(G_ATOMIC_SPARCV9, 1,
- [sparcv9 atomic implementation]),
- AC_MSG_RESULT([no])
- AC_MSG_WARN([[$SPARCV9_WARNING]]))
- glib_memory_barrier_needed=yes
- ;;
- alpha*)
- AC_MSG_RESULT([alpha])
- AC_DEFINE_UNQUOTED(G_ATOMIC_ALPHA, 1,
- [alpha atomic implementation])
- glib_memory_barrier_needed=yes
- ;;
- x86_64)
- AC_MSG_RESULT([x86_64])
- AC_DEFINE_UNQUOTED(G_ATOMIC_X86_64, 1,
- [x86_64 atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- powerpc*)
- AC_MSG_RESULT([powerpc])
- AC_DEFINE_UNQUOTED(G_ATOMIC_POWERPC, 1,
- [powerpc atomic implementation])
- glib_memory_barrier_needed=yes
- AC_MSG_CHECKING([whether asm supports numbered local labels])
- AC_TRY_COMPILE(
- ,[
- __asm__ __volatile__ ("1: nop\n"
- " bne- 1b")
- ],[
- AC_DEFINE_UNQUOTED(ASM_NUMERIC_LABELS, 1, [define if asm blocks can use numeric local labels])
- AC_MSG_RESULT([yes])
- ],[
- AC_MSG_RESULT([no])
- ])
- ;;
- ia64)
- AC_MSG_RESULT([ia64])
- AC_DEFINE_UNQUOTED(G_ATOMIC_IA64, 1,
- [ia64 atomic implementation])
- glib_memory_barrier_needed=yes
- ;;
- s390|s390x)
- AC_MSG_RESULT([s390])
- AC_DEFINE_UNQUOTED(G_ATOMIC_S390, 1,
- [s390 atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- arm*)
- AC_MSG_RESULT([arm])
- AC_DEFINE_UNQUOTED(G_ATOMIC_ARM, 1,
- [arm atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- crisv32*|etraxfs*)
- AC_MSG_RESULT([crisv32])
- AC_DEFINE_UNQUOTED(G_ATOMIC_CRISV32, 1,
- [crisv32 atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- cris*|etrax*)
- AC_MSG_RESULT([cris])
- AC_DEFINE_UNQUOTED(G_ATOMIC_CRIS, 1,
- [cris atomic implementation])
- glib_memory_barrier_needed=no
- ;;
- *)
- AC_MSG_RESULT([none])
- glib_memory_barrier_needed=yes
- ;;
- esac
- fi
-else
- if test $glib_native_win32 = yes; then
- # For Windows but not using gcc. No barriers needed then either.
- glib_memory_barrier_needed=no
- fi
fi
-
AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS,
[test $glib_cv_gcc_has_builtin_atomic_operations = yes])
+AC_MSG_CHECKING([for Win32 atomic intrinsics])
+glib_cv_has_win32_atomic_operations=no
+AC_TRY_LINK([],
+ [int i; _InterlockedExchangeAdd (&i, 0);],
+ [glib_cv_has_win32_atomic_operations=yes],
+ [glib_cv_has_win32_atomic_operations=no])
+AC_MSG_RESULT($glib_cv_has_win32_atomic_operations)
+if test "x$glib_cv_has_win32_atomic_operations" = xyes; then
+ AC_DEFINE(HAVE_WIN32_BUILTINS_FOR_ATOMIC_OPERATIONS,1,[Have Win32 atomic intrinsics])
+fi
+
dnl ************************
dnl ** Check for futex(2) **
dnl ************************
-AC_MSG_CHECKING([for futex(2) system call])
-AC_COMPILE_IFELSE([
+AC_CACHE_CHECK(for futex(2) system call,
+ glib_cv_futex,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
#include <linux/futex.h>
-#include <syscall.h>
+#include <sys/syscall.h>
#include <unistd.h>
+],[
+int
+main (void)
+{
+ /* it is not like this actually runs or anything... */
+ syscall (__NR_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
+ return 0;
+}
+])],glib_cv_futex=yes,glib_cv_futex=no))
+if test x"$glib_cv_futex" = xyes; then
+ AC_DEFINE(HAVE_FUTEX, 1, [we have the futex(2) system call])
+fi
+AC_CACHE_CHECK(for eventfd(2) system call,
+ glib_cv_eventfd,AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+#include <sys/eventfd.h>
+#include <unistd.h>
+],[
int
main (void)
{
- /* it's not like this actually runs or anything... */
- syscall (SYS_futex, NULL, FUTEX_WAKE, FUTEX_WAIT);
+ eventfd (0, EFD_CLOEXEC);
return 0;
}
-],
-[
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_FUTEX, [test "$have_futex" = "yes"],
- [we have the futex(2) system call])
-],
-[
- AC_MSG_RESULT(no)
-])
+])],glib_cv_eventfd=yes,glib_cv_eventfd=no))
+if test x"$glib_cv_eventfd" = x"yes"; then
+ AC_DEFINE(HAVE_EVENTFD, 1, [we have the eventfd(2) system call])
+fi
+AM_CONDITIONAL(HAVE_EVENTFD, [test "$glib_cv_eventfd" = "yes"])
dnl ****************************************
dnl *** GLib POLL* compatibility defines ***
# Check if we should compile GRegex
AC_ARG_ENABLE(regex, AC_HELP_STRING([--disable-regex],
- [disable the compilation of GRegex]),
+ [disable the compilation of GRegex]),
[case "${enableval}" in
yes) enable_regex=true ;;
no) enable_regex=false ;;
# Check if we should use the internal or the system-supplied pcre
AC_ARG_WITH(pcre,
[AC_HELP_STRING([--with-pcre=@<:@internal/system@:>@],
- [specify whether to use the internal or the
- system-supplied PCRE library])])
+ [whether to use system PCRE [default=internal]])])
AM_CONDITIONAL(USE_SYSTEM_PCRE, [test "x$with_pcre" = xsystem])
AC_ARG_ENABLE([dtrace],
[AS_HELP_STRING([--enable-dtrace],
- [Enable inclusion of dtrace trace support])])
+ [include tracing support for dtrace])])
have_dtrace=no
AC_MSG_CHECKING([whether to include dtrace tracing support])
if test "x$enable_dtrace" != xno; then
AC_MSG_CHECKING([whether to include systemtap tracing support])
AC_ARG_ENABLE([systemtap],
[AS_HELP_STRING([--enable-systemtap],
- [Enable inclusion of systemtap trace support])])
+ [include tracing support for systemtap])])
have_systemtap=no
if test "x$enable_systemtap" != xno -a "x$have_dtrace" = xyes; then
have_systemtap=yes
AM_CONDITIONAL([ENABLE_SYSTEMTAP], [test x$have_systemtap = xyes])
AC_ARG_WITH([tapset-install-dir],
- [AS_HELP_STRING([--with-tapset-install-dir],
- [The absolute path where the systemtap tapsets will be installed])],
+ AS_HELP_STRING([--with-tapset-install-dir=DIR],
+ [path where systemtap tapsets are installed [DATADIR/systemtap/tapset]]),
[if test "x${withval}" = x; then
ABS_TAPSET_DIR="\$(datadir)/systemtap/tapset"
else
AC_ARG_ENABLE(gcov,
AS_HELP_STRING([--enable-gcov],
- [Enable gcov]),
+ [enable coverage testing with gcov]),
[use_gcov=$enableval], [use_gcov=no])
if test "x$use_gcov" = "xyes"; then
AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
fi
- ltp_version_list="1.6 1.7 1.8"
+ ltp_version_list="1.6 1.7 1.8 1.9"
AC_CHECK_PROG(LTP, lcov, lcov)
AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
#endif
_______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;
- union {
- char pad[[$g_mutex_sizeof]];
- double dummy_double;
- void *dummy_pointer;
- long dummy_long;
- } static_mutex;
-};
-#define G_STATIC_MUTEX_INIT { NULL, { { $g_mutex_contents} } }
-#define g_static_mutex_get_mutex(mutex) \\
- (g_thread_use_default_impl ? ((GMutex*)(gpointer) ((mutex)->static_mutex.pad)) : \\
- g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex)))
-_______EOF
- else
- cat >>$outfile <<_______EOF
-$g_enable_threads_def G_THREADS_ENABLED
+ cat >>$outfile <<_______EOF
+#define 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_shortcut (mutex))
_______EOF
- fi
cat >>$outfile <<_______EOF
/* This represents a system thread as used by the implementation. An
echo >>$outfile
echo "#define G_ATOMIC_OP_MEMORY_BARRIER_NEEDED 1" >>$outfile
fi
-
+ if test x"$g_gcc_atomic_ops" != xno; then
+ echo >>$outfile
+ echo "#define G_ATOMIC_OP_USE_GCC_BUILTINS 1" >>$outfile
+ fi
echo >>$outfile
g_bit_sizes="16 32 64"
for bits in $g_bit_sizes; do
g_have_eilseq=$have_eilseq
-case x$have_threads in
-xno) 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"
g_memory_barrier_needed="$glib_memory_barrier_needed"
+g_gcc_atomic_ops="$glib_cv_gcc_has_builtin_atomic_operations"
g_module_suffix="$glib_gmodule_suffix"
build/win32/Makefile
build/win32/dirent/Makefile
build/win32/vs9/Makefile
+build/win32/vs10/Makefile
glib/Makefile
glib/glib.stp
glib/libcharset/Makefile
gthread/Makefile
gthread/tests/Makefile
gio/Makefile
+gio/gdbus-2.0/codegen/Makefile
+gio/gdbus-2.0/codegen/config.py
gio/xdgmime/Makefile
gio/inotify/Makefile
-gio/libasyncns/Makefile
gio/fen/Makefile
gio/fam/Makefile
gio/win32/Makefile
gio/tests/Makefile
+gio/tests/gdbus-object-manager-example/Makefile
po/Makefile.in
docs/Makefile
docs/reference/Makefile
docs/reference/gobject/Makefile
docs/reference/gobject/version.xml
docs/reference/gio/Makefile
+docs/reference/gio/gdbus-object-manager-example/Makefile
docs/reference/gio/version.xml
tests/Makefile
tests/gobject/Makefile
projects / platform / upstream / glib.git / blobdiff