dnl -------------------------------------------------------- -*- autoconf -*-
dnl Licensed to the Apache Software Foundation (ASF) under one or more
dnl contributor license agreements.  See the NOTICE file distributed with
dnl this work for additional information regarding copyright ownership.
dnl The ASF licenses this file to You under the Apache License, Version 2.0
dnl (the "License"); you may not use this file except in compliance with
dnl the License.  You may obtain a copy of the License at
dnl
dnl     http://www.apache.org/licenses/LICENSE-2.0
dnl
dnl Unless required by applicable law or agreed to in writing, software
dnl distributed under the License is distributed on an "AS IS" BASIS,
dnl WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
dnl See the License for the specific language governing permissions and
dnl limitations under the License.

dnl -----------------------------------------------------------------
dnl apr_threads.m4: APR's autoconf macros for testing thread support
dnl

dnl
dnl APR_CHECK_PTHREADS_H([ ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
dnl
dnl gcc issues warnings when parsing AIX 4.3.3's pthread.h
dnl which causes autoconf to incorrectly conclude that
dnl pthreads is not available.
dnl Turn off warnings if we're using gcc.
dnl
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
])dnl


dnl
dnl APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS
dnl
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([
#include <pthread.h>
],[
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
])dnl


dnl
dnl APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG
dnl
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([
#include <pthread.h>
],[
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
])dnl


dnl
dnl APR_PTHREADS_TRY_RUN(actions-if-success)
dnl
dnl Try running a program which uses pthreads, executing the
dnl actions-if-success commands on success.
dnl
AC_DEFUN(APR_PTHREADS_TRY_RUN, [
AC_TRY_RUN( [
#include <pthread.h>
#include <stddef.h>

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

])dnl


dnl
dnl APR_PTHREADS_CHECK()
dnl
dnl Try to find a way to enable POSIX threads.  Sets the 
dnl pthreads_working variable to "yes" on success.
dnl
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

# The CFLAGS may or may not be sufficient to ensure that libapr
# depends on the pthreads library: some versions of libtool
# drop -pthread when passed on the link line; some versions of
# gcc ignore -pthread when linking a shared object.  So always
# try and add the relevant library to LIBS too.

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
])dnl

dnl
dnl APR_PTHREADS_CHECK_SAVE
dnl APR_PTHREADS_CHECK_RESTORE
dnl
dnl Save the global environment variables that might be modified during
dnl the checks for threading support so that they can restored if the
dnl result is not what the caller wanted.
dnl
AC_DEFUN(APR_PTHREADS_CHECK_SAVE, [
  apr_pthsv_CFLAGS="$CFLAGS"
  apr_pthsv_LIBS="$LIBS"
])dnl

AC_DEFUN(APR_PTHREADS_CHECK_RESTORE, [
  CFLAGS="$apr_pthsv_CFLAGS"
  LIBS="$apr_pthsv_LIBS"
])dnl

dnl
dnl APR_CHECK_SIGWAIT_ONE_ARG
dnl
AC_DEFUN([APR_CHECK_SIGWAIT_ONE_ARG], [
  AC_CACHE_CHECK(whether sigwait takes one argument,ac_cv_sigwait_one_arg,[
  AC_TRY_COMPILE([
#if defined(__NETBSD__) || defined(DARWIN)
    /* 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.
     */
#include <pthread.h>
#endif
#include <signal.h>
],[
  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
])

dnl Check for recursive mutex support (per SUSv3).
AC_DEFUN([APR_CHECK_PTHREAD_RECURSIVE_MUTEX], [
  AC_CACHE_CHECK([for recursive mutex support], [apr_cv_mutex_recursive],
[AC_TRY_RUN([#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>

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
])

dnl Check for robust process-shared mutex support
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([
#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>

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(&attr, PTHREAD_MUTEX_ROBUST))
        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], [
AC_TRY_RUN([
#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>

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=np], [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])
elif test "$apr_cv_mutex_robust_shared" = "np"; then
   AC_DEFINE([HAVE_PTHREAD_MUTEX_ROBUST_NP], 1,
             [Define if non-posix/portable cross-process robust mutexes are available])
fi
])