AC_DEFUN(APR_CHECK_PTHREADS_H, [
if test "$GCC" = "yes"; then
SAVE_FL="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS -w"
AC_CHECK_HEADERS(pthread.h, [ $1 ] , [ $2 ] )
CPPFLAGS="$SAVE_FL"
else
AC_CHECK_HEADERS(pthread.h, [ $1 ] , [ $2 ] )
fi
])
AC_DEFUN(APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS, [
AC_CACHE_CHECK(whether pthread_getspecific takes two arguments, ac_cv_pthread_getspecific_two_args,[
AC_TRY_COMPILE([
],[
pthread_key_t key;
void *tmp;
pthread_getspecific(key,&tmp);
],[
ac_cv_pthread_getspecific_two_args=yes
],[
ac_cv_pthread_getspecific_two_args=no
])
])
if test "$ac_cv_pthread_getspecific_two_args" = "yes"; then
AC_DEFINE(PTHREAD_GETSPECIFIC_TAKES_TWO_ARGS, 1, [Define if pthread_getspecific() has two args])
fi
])
AC_DEFUN(APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG, [
AC_CACHE_CHECK(whether pthread_attr_getdetachstate takes one argument, ac_cv_pthread_attr_getdetachstate_one_arg,[
AC_TRY_COMPILE([
],[
pthread_attr_t *attr;
pthread_attr_getdetachstate(attr);
],[
ac_cv_pthread_attr_getdetachstate_one_arg=yes
],[
ac_cv_pthread_attr_getdetachstate_one_arg=no
])
])
if test "$ac_cv_pthread_attr_getdetachstate_one_arg" = "yes"; then
AC_DEFINE(PTHREAD_ATTR_GETDETACHSTATE_TAKES_ONE_ARG, 1, [Define if pthread_attr_getdetachstate() has one arg])
fi
])
AC_DEFUN(APR_PTHREADS_TRY_RUN, [
AC_TRY_RUN( [
void *thread_routine(void *data) {
return data;
}
int main() {
pthread_t thd;
pthread_mutexattr_t mattr;
pthread_once_t once_init = PTHREAD_ONCE_INIT;
int data = 1;
pthread_mutexattr_init(&mattr);
return pthread_create(&thd, NULL, thread_routine, &data);
} ], [apr_p_t_r=yes], [apr_p_t_r=no], [apr_p_t_r=no])
if test $apr_p_t_r = yes; then
$1
fi
])
AC_DEFUN([APR_PTHREADS_CHECK], [
AC_CACHE_CHECK([for CFLAGS needed for pthreads], [apr_cv_pthreads_cflags],
[apr_ptc_cflags=$CFLAGS
for flag in none -kthread -pthread -pthreads -mt -mthreads -Kthread -threads; do
CFLAGS=$apr_ptc_cflags
test "x$flag" != "xnone" && CFLAGS="$CFLAGS $flag"
APR_PTHREADS_TRY_RUN([
apr_cv_pthreads_cflags="$flag"
break
])
done
CFLAGS=$apr_ptc_cflags
])
if test -n "$apr_cv_pthreads_cflags"; then
pthreads_working=yes
if test "x$apr_cv_pthreads_cflags" != "xnone"; then
APR_ADDTO(CFLAGS,[$apr_cv_pthreads_cflags])
fi
fi
AC_CACHE_CHECK([for LIBS needed for pthreads], [apr_cv_pthreads_lib], [
apr_ptc_libs=$LIBS
for lib in -lpthread -lpthreads -lc_r; do
LIBS="$apr_ptc_libs $lib"
APR_PTHREADS_TRY_RUN([
apr_cv_pthreads_lib=$lib
break
])
done
LIBS=$apr_ptc_libs
])
if test -n "$apr_cv_pthreads_lib"; then
pthreads_working=yes
APR_ADDTO(LIBS,[$apr_cv_pthreads_lib])
fi
if test "$pthreads_working" = "yes"; then
threads_result="POSIX Threads found"
else
threads_result="POSIX Threads not found"
fi
])
AC_DEFUN(APR_PTHREADS_CHECK_SAVE, [
apr_pthsv_CFLAGS="$CFLAGS"
apr_pthsv_LIBS="$LIBS"
])
AC_DEFUN(APR_PTHREADS_CHECK_RESTORE, [
CFLAGS="$apr_pthsv_CFLAGS"
LIBS="$apr_pthsv_LIBS"
])
AC_DEFUN([APR_CHECK_SIGWAIT_ONE_ARG], [
AC_CACHE_CHECK(whether sigwait takes one argument,ac_cv_sigwait_one_arg,[
AC_TRY_COMPILE([
/* When using the unproven-pthreads package, we need to pull in this
* header to get a prototype for sigwait(). Else things will fail later
* on. XXX Should probably be fixed in the unproven-pthreads package.
* Darwin is declaring sigwait() in the wrong place as well.
*/
],[
sigset_t set;
sigwait(&set);
],[
ac_cv_sigwait_one_arg=yes
],[
ac_cv_sigwait_one_arg=no
])])
if test "$ac_cv_sigwait_one_arg" = "yes"; then
AC_DEFINE(SIGWAIT_TAKES_ONE_ARG,1,[ ])
fi
])
AC_DEFUN([APR_CHECK_PTHREAD_RECURSIVE_MUTEX], [
AC_CACHE_CHECK([for recursive mutex support], [apr_cv_mutex_recursive],
[AC_TRY_RUN([
int main() {
pthread_mutexattr_t attr;
pthread_mutex_t m;
exit (pthread_mutexattr_init(&attr)
|| pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
|| pthread_mutex_init(&m, &attr));
}], [apr_cv_mutex_recursive=yes], [apr_cv_mutex_recursive=no],
[apr_cv_mutex_recursive=no])])
if test "$apr_cv_mutex_recursive" = "yes"; then
AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
[Define if recursive pthread mutexes are available])
fi
])
AC_DEFUN([APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX], [
AC_CACHE_CHECK([for robust cross-process mutex support],
[apr_cv_mutex_robust_shared],
[AC_TRY_RUN([
int main(int argc, char **argv)
{
pthread_mutex_t mutex;
pthread_mutexattr_t attr;
if (pthread_mutexattr_init(&attr))
exit(1);
if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))
exit(2);
if (pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST_NP))
exit(3);
if (pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT))
exit(4);
if (pthread_mutex_init(&mutex, &attr))
exit(5);
if (pthread_mutexattr_destroy(&attr))
exit(6);
if (pthread_mutex_destroy(&mutex))
exit(7);
exit(0);
}], [apr_cv_mutex_robust_shared=yes], [apr_cv_mutex_robust_shared=no])])
if test "$apr_cv_mutex_robust_shared" = "yes"; then
AC_DEFINE([HAVE_PTHREAD_MUTEX_ROBUST], 1,
[Define if cross-process robust mutexes are available])
fi
])