barrier/acinclude.m4

572 lines
20 KiB
Plaintext

dnl synergy -- mouse and keyboard sharing utility
dnl Copyright (C) 2002 Chris Schoeneman
dnl
dnl This package is free software; you can redistribute it and/or
dnl modify it under the terms of the GNU General Public License
dnl found in the file COPYING that should have accompanied this file.
dnl
dnl This package is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
dnl GNU General Public License for more details.
AC_DEFUN([ACX_CHECK_SOCKLEN_T], [
AC_MSG_CHECKING([for socklen_t])
AC_TRY_COMPILE([
#include <unistd.h>
#include <sys/socket.h>
],
[socklen_t len;],[acx_socklen_t_ok=yes],[acx_socklen_t_ok=no])
AC_MSG_RESULT($acx_socklen_t_ok)
if test x"$acx_socklen_t_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_SOCKLEN_T,1,[Define if your compiler defines socklen_t.]),[$1])
:
else
acx_socklen_t_ok=no
$2
fi
])dnl ACX_CHECK_SOCKLEN_T
# HP-UX defines socklen_t but doesn't use it in arg 3 for accept().
AC_DEFUN([ACX_FUNC_ACCEPT], [
AC_MSG_CHECKING([for type of arg 3 for accept])
acx_accept_socklen_t_arg3=int
if test x"$acx_socklen_t_ok" = xyes; then
AC_TRY_COMPILE([
#include <unistd.h>
#include <sys/socket.h>
],
[struct sockaddr addr; socklen_t len; accept(0, &addr, &len);],
[acx_accept_socklen_t_arg3=socklen_t],
[acx_accept_socklen_t_arg3=int])
fi
AC_MSG_RESULT($acx_accept_socklen_t_arg3)
AC_DEFINE_UNQUOTED(ACCEPT_TYPE_ARG3,$acx_accept_socklen_t_arg3,[Define to the base type of arg 3 for `accept'.])
])dnl ACX_FUNC_ACCEPT
AC_DEFUN([ACX_CHECK_CXX], [
AC_MSG_CHECKING([if g++ defines correct C++ macro])
AC_TRY_COMPILE(, [
#if defined(_LANGUAGE_C) && !defined(_LANGUAGE_C_PLUS_PLUS)
#error wrong macro
#endif],[acx_cxx_macro_ok=yes],[acx_cxx_macro_ok=no])
AC_MSG_RESULT($acx_cxx_macro_ok)
if test x"$acx_cxx_macro_ok" = xyes; then
SYNERGY_CXXFLAGS=""
else
SYNERGY_CXXFLAGS="-U_LANGUAGE_C -D_LANGUAGE_C_PLUS_PLUS"
fi
])dnl ACX_CHECK_CXX
AC_DEFUN([ACX_CHECK_CXX_BOOL], [
AC_MSG_CHECKING([for bool support])
AC_TRY_COMPILE(, [bool t = true, f = false;],
[acx_cxx_bool_ok=yes],[acx_cxx_bool_ok=no])
AC_MSG_RESULT($acx_cxx_bool_ok)
if test x"$acx_cxx_bool_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_CXX_BOOL,1,[Define if your compiler has bool support.]),[$1])
:
else
acx_cxx_bool_ok=no
$2
fi
])dnl ACX_CHECK_CXX_BOOL
AC_DEFUN([ACX_CHECK_CXX_EXCEPTIONS], [
AC_MSG_CHECKING([for exception support])
AC_TRY_COMPILE(, [try{throw int(4);}catch(int){throw;}catch(...){}],
[acx_cxx_exception_ok=yes],[acx_cxx_exception_ok=no])
AC_MSG_RESULT($acx_cxx_exception_ok)
if test x"$acx_cxx_exception_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_CXX_EXCEPTIONS,1,[Define if your compiler has exceptions support.]),[$1])
:
else
acx_cxx_exception_ok=no
$2
fi
])dnl ACX_CHECK_CXX_EXCEPTIONS
AC_DEFUN([ACX_CHECK_CXX_CASTS], [
AC_MSG_CHECKING([for C++ cast support])
AC_TRY_COMPILE(, [const char* f="a";const_cast<char*>(f);
reinterpret_cast<const int*>(f);static_cast<int>(4.5);],
[acx_cxx_cast_ok=yes],[acx_cxx_cast_ok=no])
AC_MSG_RESULT($acx_cxx_cast_ok)
if test x"$acx_cxx_cast_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_CXX_CASTS,1,[Define if your compiler has C++ cast support.]),[$1])
:
else
acx_cxx_cast_ok=no
$2
fi
])dnl ACX_CHECK_CXX_CASTS
AC_DEFUN([ACX_CHECK_CXX_MUTABLE], [
AC_MSG_CHECKING([for mutable support])
AC_TRY_COMPILE(, [struct A{mutable int b;void f() const {b=0;}};
A a;a.f();],[acx_cxx_mutable_ok=yes],[acx_cxx_mutable_ok=no])
AC_MSG_RESULT($acx_cxx_mutable_ok)
if test x"$acx_cxx_mutable_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_CXX_MUTABLE,1,[Define if your compiler has mutable support.]),[$1])
:
else
acx_cxx_mutable_ok=no
$2
fi
])dnl ACX_CHECK_CXX_MUTABLE
AC_DEFUN([ACX_CHECK_CXX_STDLIB], [
AC_MSG_CHECKING([for C++ standard library])
AC_TRY_LINK([#include <set>], [std::set<int> a; a.insert(3);],
[acx_cxx_stdlib_ok=yes],[acx_cxx_stdlib_ok=no])
AC_MSG_RESULT($acx_cxx_stdlib_ok)
if test x"$acx_cxx_stdlib_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_CXX_STDLIB,1,[Define if your compiler has standard C++ library support.]),[$1])
:
else
acx_cxx_stdlib_ok=no
$2
fi
])dnl ACX_CHECK_CXX_STDLIB
AC_DEFUN([ACX_CHECK_GETPWUID_R], [
AC_MSG_CHECKING([for working getpwuid_r])
AC_TRY_LINK([#include <pwd.h>],
[char buffer[4096]; struct passwd pwd, *pwdp;
getpwuid_r(0, &pwd, buffer, sizeof(buffer), &pwdp);],
acx_getpwuid_r_ok=yes, acx_getpwuid_r_ok=no)
AC_MSG_RESULT($acx_getpwuid_r_ok)
if test x"$acx_getpwuid_r_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_GETPWUID_R,1,[Define if you have a working \`getpwuid_r\' function.]),[$1])
:
else
acx_getpwuid_r_ok=no
$2
fi
])dnl ACX_CHECK_GETPWUID_R
AC_DEFUN([ACX_CHECK_POLL], [
AC_MSG_CHECKING([for poll])
AC_TRY_LINK([#include <poll.h>],
[#if defined(_POLL_EMUL_H_)
#error emulated poll
#endif
struct pollfd ufds[] = { 0, POLLIN, 0 }; poll(ufds, 1, 10);],
acx_poll_ok=yes, acx_poll_ok=no)
AC_MSG_RESULT($acx_poll_ok)
if test x"$acx_poll_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_POLL,1,[Define if you have the \`poll\' function.]),[$1])
:
else
acx_poll_ok=no
$2
fi
])dnl ACX_CHECK_POLL
dnl See if we need extra libraries for nanosleep
AC_DEFUN([ACX_CHECK_NANOSLEEP], [
acx_nanosleep_ok=no
acx_nanosleep_list=""
dnl check if user has set NANOSLEEP_LIBS
save_user_NANOSLEEP_LIBS="$NANOSLEEP_LIBS"
if test x"$NANOSLEEP_LIBS" != x; then
acx_nanosleep_list=user
fi
dnl check various libraries (including no extra libraries) for
dnl nanosleep. `none' should appear first.
acx_nanosleep_list="none $acx_nanosleep_list rt"
for flag in $acx_nanosleep_list; do
case $flag in
none)
AC_MSG_CHECKING([for nanosleep])
NANOSLEEP_LIBS=""
;;
user)
AC_MSG_CHECKING([for nanosleep in $save_user_NANOSLEEP_LIBS])
NANOSLEEP_LIBS="$save_user_NANOSLEEP_LIBS"
;;
*)
AC_MSG_CHECKING([for nanosleep in -l$flag])
NANOSLEEP_LIBS="-l$flag"
;;
esac
save_LIBS="$LIBS"
LIBS="$NANOSLEEP_LIBS $LIBS"
AC_TRY_LINK([#include <time.h>],
[struct timespec t = { 1, 1000 }; nanosleep(&t, NULL);],
acx_nanosleep_ok=yes, acx_nanosleep_ok=no)
LIBS="$save_LIBS"
AC_MSG_RESULT($acx_nanosleep_ok)
if test x"$acx_nanosleep_ok" = xyes; then
break;
fi
NANOSLEEP_LIBS=""
done
AC_SUBST(NANOSLEEP_LIBS)
# execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_nanosleep_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_NANOSLEEP,1,[Define if you have the \`nanosleep\' function.]),[$1])
:
else
acx_nanosleep_ok=no
$2
fi
])dnl ACX_CHECK_NANOSLEEP
dnl See if we need extra libraries for inet_aton
AC_DEFUN([ACX_CHECK_INET_ATON], [
acx_inet_aton_ok=no
acx_inet_aton_list=""
dnl check if user has set INET_ATON_LIBS
save_user_INET_ATON_LIBS="$INET_ATON_LIBS"
if test x"$INET_ATON_LIBS" != x; then
acx_inet_aton_list=user
fi
dnl check various libraries (including no extra libraries) for
dnl inet_aton. `none' should appear first.
acx_inet_aton_list="none $acx_inet_aton_list resolv"
for flag in $acx_inet_aton_list; do
case $flag in
none)
AC_MSG_CHECKING([for inet_aton])
INET_ATON_LIBS=""
;;
user)
AC_MSG_CHECKING([for inet_aton in $save_user_INET_ATON_LIBS])
INET_ATON_LIBS="$save_user_INET_ATON_LIBS"
;;
*)
AC_MSG_CHECKING([for inet_aton in -l$flag])
INET_ATON_LIBS="-l$flag"
;;
esac
save_LIBS="$LIBS"
LIBS="$INET_ATON_LIBS $LIBS"
AC_TRY_LINK([#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>],
[struct in_addr addr; inet_aton("foo.bar", &addr);],
acx_inet_aton_ok=yes, acx_inet_aton_ok=no)
LIBS="$save_LIBS"
AC_MSG_RESULT($acx_inet_aton_ok)
if test x"$acx_inet_aton_ok" = xyes; then
AC_DEFINE(HAVE_INET_ATON,1,[Define if you have the \`inet_aton\' function.])
break;
fi
INET_ATON_LIBS=""
done
AC_SUBST(INET_ATON_LIBS)
])dnl ACX_CHECK_INET_ATON
dnl The following macros are from http://www.gnu.org/software/ac-archive/
dnl which distributes them under the following license:
dnl
dnl Every Autoconf macro presented on this web site is free software; you can
dnl redistribute it and/or modify it under the terms of the GNU General
dnl Public License as published by the Free Software Foundation; either
dnl version 2, or (at your option) any later version.
dnl
dnl They are distributed in the hope that they will be useful, but WITHOUT
dnl ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
dnl FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
dnl more details. (You should have received a copy of the GNU General Public
dnl License along with this program; if not, write to the Free Software
dnl Foundation, Inc., 59 Temple Place -- Suite 330, Boston, MA 02111-1307,
dnl USA.)
dnl
dnl As a special exception, the Free Software Foundation gives unlimited
dnl permission to copy, distribute and modify the configure scripts that are
dnl the output of Autoconf. You need not follow the terms of the GNU General
dnl Public License when using or distributing such scripts, even though
dnl portions of the text of Autoconf appear in them. The GNU General Public
dnl License (GPL) does govern all other use of the material that constitutes
dnl the Autoconf program.
dnl
dnl Certain portions of the Autoconf source text are designed to be copied
dnl (in certain cases, depending on the input) into the output of Autoconf.
dnl We call these the "data" portions. The rest of the Autoconf source text
dnl consists of comments plus executable code that decides which of the data
dnl portions to output in any given case. We call these comments and
dnl executable code the "non-data" portions. Autoconf never copies any of the
dnl non-data portions into its output.
dnl
dnl This special exception to the GPL applies to versions of Autoconf
dnl released by the Free Software Foundation. When you make and distribute a
dnl modified version of Autoconf, you may extend this special exception to
dnl the GPL to apply to your modified version as well, *unless* your modified
dnl version has the potential to copy into its output some of the text that
dnl was the non-data portion of the version that you started with. (In other
dnl words, unless your change moves or copies text from the non-data portions
dnl to the data portions.) If your modification has such potential, you must
dnl delete any notice of this special exception to the GPL from your modified
dnl version
AC_DEFUN([ACX_PTHREAD], [
AC_REQUIRE([AC_CANONICAL_HOST])
AC_LANG_SAVE
AC_LANG_C
acx_pthread_ok=no
# We used to check for pthread.h first, but this fails if pthread.h
# requires special compiler flags (e.g. on True64 or Sequent).
# It gets checked for in the link test anyway.
# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using
# them:
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
AC_MSG_RESULT($acx_pthread_ok)
if test x"$acx_pthread_ok" = xno; then
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
fi
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
fi
# We must check for the threads library under a number of different
# names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX).
# Create a list of thread flags to try. Items starting with a "-" are
# C compiler flags, and other items are library names, except for "none"
# which indicates that we try without any flags at all, and "pthread-config"
# which is a program returning the flags for the Pth emulation library.
acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
# The ordering *is* (sometimes) important. Some notes on the
# individual items follow:
# pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and
# other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
# -pthreads: Solaris/gcc
# -mthreads: Mingw32/gcc, Lynx/gcc
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
# doesn't hurt to check since this sometimes defines pthreads too;
# also defines -D_REENTRANT)
# pthread: Linux, etcetera
# --thread-safe: KAI C++
# pthread-config: use pthread-config program (for GNU Pth library)
case "${host_cpu}-${host_os}" in
*solaris*)
# On Solaris (at least, for some versions), libc contains stubbed
# (non-functional) versions of the pthreads routines, so link-based
# tests will erroneously succeed. (We need to link with -pthread or
# -lpthread.) (The stubs are missing pthread_cleanup_push, or rather
# a function called by this macro, so we could check for that, but
# who knows whether they'll stub that too in a future libc.) So,
# we'll just look for -pthreads and -lpthread first:
acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
;;
esac
if test x"$acx_pthread_ok" = xno; then
for flag in $acx_pthread_flags; do
case $flag in
none)
AC_MSG_CHECKING([whether pthreads work without any flags])
;;
-*)
AC_MSG_CHECKING([whether pthreads work with $flag])
PTHREAD_CFLAGS="$flag"
;;
pthread-config)
AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
if test x"$acx_pthread_config" = xno; then continue; fi
PTHREAD_CFLAGS="`pthread-config --cflags`"
PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
;;
*)
AC_MSG_CHECKING([for the pthreads library -l$flag])
PTHREAD_LIBS="-l$flag"
;;
esac
save_LIBS="$LIBS"
save_CFLAGS="$CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Check for various functions. We must include pthread.h,
# since some functions may be macros. (On the Sequent, we
# need a special flag -Kthread to make this header compile.)
# We check for pthread_join because it is in -lpthread on IRIX
# while pthread_create is in libc. We check for pthread_attr_init
# due to DEC craziness with -lpthreads. We check for
# pthread_cleanup_push because it is one of the few pthread
# functions on Solaris that doesn't have a non-functional libc stub.
# We try pthread_create on general principles.
AC_TRY_LINK([#include <pthread.h>],
[pthread_t th; pthread_join(th, 0);
pthread_attr_init(0); pthread_cleanup_push(0, 0);
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
[acx_pthread_ok=yes])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
AC_MSG_RESULT($acx_pthread_ok)
if test "x$acx_pthread_ok" = xyes; then
break;
fi
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
done
fi
# Various other checks:
if test "x$acx_pthread_ok" = xyes; then
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
AC_MSG_CHECKING([for joinable pthread attribute])
attr_name=unknown
for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
AC_TRY_LINK([#include <pthread.h>], [int attr=$attr;],
[attr_name=$attr; break])
done
AC_MSG_RESULT($attr_name)
if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
[Define to necessary symbol if this constant
uses a non-standard name on your system.])
fi
AC_MSG_CHECKING([if more special flags are required for pthreads])
flag=no
case "${host_cpu}-${host_os}" in
*-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
*solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
esac
AC_MSG_RESULT(${flag})
if test "x$flag" != xno; then
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
fi
# Detect POSIX sigwait()
AC_MSG_CHECKING([for POSIX sigwait])
AC_TRY_LINK([#include <pthread.h>
#include <signal.h>],
[sigset_t sigset; int signal; sigwait(&sigset, &signal);],
ok=yes, ok=unknown)
if test x"$ok" = xunknown; then
save_CFLAGS2="$CFLAGS"
CFLAGS="$CFLAGS -D_POSIX_PTHREAD_SEMANTICS"
AC_TRY_LINK([#include <pthread.h>
#include <signal.h>],
[sigset_t sigset; int signal; sigwait(&sigset, &signal);],
ok=-D_POSIX_PTHREAD_SEMANTICS, ok=no)
CFLAGS="$save_CFLAGS2"
fi
AC_MSG_RESULT(${ok})
if test x"$ok" != xno; then
AC_DEFINE(HAVE_POSIX_SIGWAIT,1,[Define if you have a POSIX \`sigwait\' function.])
if test x"$ok" != xyes; then
PTHREAD_CFLAGS="$ok $PTHREAD_CFLAGS"
fi
fi
# Detect pthread signal functions
AC_MSG_CHECKING([for pthread signal functions])
AC_TRY_LINK([#include <pthread.h>
#include <signal.h>],
[pthread_kill(pthread_self(), SIGTERM);],
ok=yes, ok=no)
AC_MSG_RESULT(${ok})
if test x"$ok" = xyes; then
AC_DEFINE(HAVE_PTHREAD_SIGNAL,1,[Define if you have \`pthread_sigmask\' and \`pthread_kill\' functions.])
fi
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
# More AIX lossage: must compile with cc_r
AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
else
PTHREAD_CC="$CC"
fi
AC_SUBST(PTHREAD_LIBS)
AC_SUBST(PTHREAD_CFLAGS)
AC_SUBST(PTHREAD_CC)
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_pthread_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
:
else
acx_pthread_ok=no
$2
fi
AC_LANG_RESTORE
])dnl ACX_PTHREAD
dnl enable maximum compiler warnings. must ignore unknown pragmas to
dnl build on solaris.
dnl we only know how to do this for g++
AC_DEFUN([ACX_CXX_WARNINGS], [
AC_MSG_CHECKING([for C++ compiler warning flags])
if test "$GXX" = "yes"; then
acx_cxx_warnings="-Wall -Wno-unknown-pragmas"
fi
if test -n "$acx_cxx_warnings"; then
CXXFLAGS="$CXXFLAGS $acx_cxx_warnings"
else
acx_cxx_warnings="unknown"
fi
AC_MSG_RESULT($acx_cxx_warnings)
])dnl ACX_CXX_WARNINGS
dnl enable compiler warnings are errors
dnl we only know how to do this for g++
AC_DEFUN([ACX_CXX_WARNINGS_ARE_ERRORS], [
AC_MSG_CHECKING([for C++ compiler warning are errors flags])
if test "$GXX" = "yes"; then
acx_cxx_warnings_are_errors="-Werror"
fi
if test -n "$acx_cxx_warnings_are_errors"; then
CXXFLAGS="$CXXFLAGS $acx_cxx_warnings_are_errors"
else
acx_cxx_warnings_are_errors="unknown"
fi
AC_MSG_RESULT($acx_cxx_warnings_are_errors)
])dnl ACX_CXX_WARNINGS_ARE_ERRORS