dnl Copyright (c) 2002 Leon Bottou and Yann Le Cun.
dnl Copyright (c) 2001 AT&T
dnl
dnl Most of these macros are derived from macros listed
dnl at the GNU Autoconf Macro Archive
dnl http://www.gnu.org/software/ac-archive/
dnl
dnl This program is free software; you can redistribute it and/or modify
dnl it under the terms of the GNU General Public License as published by
dnl the Free Software Foundation; either version 2 of the License, or
dnl (at your option) any later version.
dnl
dnl This program 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.
dnl
dnl You should have received a copy of the GNU General Public License
dnl along with this program; if not, write to the Free Software
dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111 USA
dnl
dnl -------------------------------------------------------
dnl @synopsis AC_CHECK_CXX_OPT(OPTION,
dnl ACTION-IF-OKAY,ACTION-IF-NOT-OKAY)
dnl Check if compiler accepts option OPTION.
dnl Default action is to add option to CXXFLAGS.
dnl -------------------------------------------------------
AC_DEFUN([AC_CHECK_CXX_OPT],[
opt="$1"
AC_MSG_CHECKING([if $CXX accepts $opt])
echo 'void f(){}' > conftest.cc
if test -z "`${CXX} ${CXXFLAGS} $opt -c conftest.cc 2>&1`"; then
AC_MSG_RESULT(yes)
rm conftest.*
ifelse($2,,[CXXFLAGS="$CXXFLAGS $opt"],$2)
else
AC_MSG_RESULT(no)
rm conftest.*
ifelse($3,,:,$3)
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CHECK_CC_OPT(OPTION,
dnl ACTION-IF-OKAY,ACTION-IF-NOT-OKAY)
dnl Check if compiler accepts option OPTION.
dnl Default action is to add option to CFLAGS.
dnl -------------------------------------------------------
AC_DEFUN([AC_CHECK_CC_OPT],[
opt="$1"
AC_MSG_CHECKING([if $CXX accepts $opt])
echo 'void f(){}' > conftest.c
if test -z "`${CC} ${CFLAGS} $opt -c conftest.c 2>&1`"; then
AC_MSG_RESULT(yes)
rm conftest.*
ifelse($2,,[CFLAGS="$CFLAGS $opt"],$2)
else
AC_MSG_RESULT(no)
rm conftest.*
ifelse($3,,:,$3)
fi
])
dnl ------------------------------------------------------
dnl @synopsis AC_REMOVE_OPTIONS(VAR,PATTERN)
dnl ------------------------------------------------------
AC_DEFUN([AC_REMOVE_OPTIONS],[
saved_var=${$1}
$1=
for opt in ${saved_var} ; do
case "$opt" in
$2) ;;
*) $1="${$1} $opt" ;;
esac
done
])
dnl -------------------------------------------------------
dnl @synopsis AC_OPTIMIZE
dnl Setup option --enable-debug
dnl Determine optimization options
dnl Add them to CFLAGS and CXXFLAGS
dnl -------------------------------------------------------
AC_DEFUN([AC_OPTIMIZE],[
AC_REQUIRE([AC_CANONICAL_HOST])
AC_ARG_ENABLE(debug,
AS_HELP_STRING([--enable-debug],
[Compile with debugging options (default: no)]),
[ac_debug=$enableval],[ac_debug=no])
defines=
if test x$ac_debug = xno ; then
AC_REMOVE_OPTIONS([CFLAGS],[-O*])
AC_REMOVE_OPTIONS([CXXFLAGS],[-O*])
if test x$GCC != xyes ; then
AC_REMOVE_OPTIONS([CFLAGS],[-g*])
AC_REMOVE_OPTIONS([CXXFLAGS],[-g*])
fi
defines="-DNDEBUG"
AC_CHECK_CC_OPT([-O3],,[AC_CHECK_CC_OPT([-O2])])
AC_CHECK_CXX_OPT([-O3],,[AC_CHECK_CXX_OPT([-O2])])
cpu=`uname -m 2>/dev/null`
test -z "$cpu" && cpu=${host_cpu}
case "${host_cpu}" in
i?86)
opt="-mtune=${host_cpu}"
AC_CHECK_CXX_OPT([-mtune=${host_cpu}],,
[AC_CHECK_CXX_OPT([-mcpu=${host_cpu}])])
AC_CHECK_CC_OPT([-mtune=${host_cpu}],,
[AC_CHECK_CC_OPT([-mcpu=${host_cpu}])])
;;
esac
else
AC_REMOVE_OPTIONS([CFLAGS],[-O*|-g*])
AC_REMOVE_OPTIONS([CXXFLAGS],[-O*|-g*])
AC_CHECK_CC_OPT([-g])
AC_CHECK_CXX_OPT([-g])
AC_CHECK_CXX_OPT([-Wno-non-virtual-dtor])
fi
AC_CHECK_CC_OPT([-Wall])
AC_CHECK_CXX_OPT([-Wall])
case x"$ac_debug" in
changequote(<<, >>)dnl
x[0-9]) defines="-DDEBUGLVL=$ac_debug" ;;
xr*) defines="-DRUNTIME_DEBUG_ONLY" ;;
changequote([, ])dnl
esac
CFLAGS="$CFLAGS $defines"
CXXFLAGS="$CXXFLAGS $defines"
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_INTEL_ATOMIC_BUILTINS
dnl If the compiler supports intel atomic builtins.
dnl define HAVE_INTEL_ATOMIC_BUILTINS
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_INTEL_ATOMIC_BUILTINS],
[AC_CACHE_CHECK(whether the compiler supports intel atomic builtins,
ac_cv_cxx_intel_atomic_builtins,
[AC_LANG_PUSH([C++])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
static int volatile l;
]],
[
__sync_lock_test_and_set(&l,1);
__sync_lock_release(&l);
__sync_add_and_fetch(&l,1);
__sync_bool_compare_and_swap(&l,&l,1);
__sync_synchronize();
return 0;
])],
[ac_cv_cxx_intel_atomic_builtins=yes],
[ac_cv_cxx_intel_atomic_builtins=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_intel_atomic_builtins" = yes; then
AC_DEFINE(HAVE_INTEL_ATOMIC_BUILTINS,1,
[define if the compiler supports intel atomic builtins])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_MEMBER_TEMPLATES
dnl If the compiler supports member templates,
dnl define HAVE_MEMBER_TEMPLATES.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_MEMBER_TEMPLATES],
[AC_CACHE_CHECK(whether the compiler supports member templates,
ac_cv_cxx_member_templates,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
template<class T, int N> class A
{ public:
template<int N2> A<T,N> operator=(const A<T,N2>& z) { return A<T,N>(); }
};
]],
[[
A<double,4> x; A<double,7> y;
x = y;
return 0;
]])],
[ac_cv_cxx_member_templates=yes],
[ac_cv_cxx_member_templates=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_member_templates" = yes; then
AC_DEFINE(HAVE_MEMBER_TEMPLATES,1,
[define if the compiler supports member templates])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_NAMESPACES
dnl Define HAVE_NAMESPACES if the compiler supports
dnl namespaces.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_NAMESPACES],
[AC_CACHE_CHECK(whether the compiler implements namespaces,
ac_cv_cxx_namespaces,
[ AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
namespace Outer { namespace Inner { int i = 0; }}
]],
[[
using namespace Outer::Inner;
return i;
]])],
[ac_cv_cxx_namespaces=yes],
[ac_cv_cxx_namespaces=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_namespaces" = yes && test "$ac_debug" = no; then
AC_DEFINE(HAVE_NAMESPACES,1,
[define if the compiler implements namespaces])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_TYPENAME
dnl Define HAVE_TYPENAME if the compiler recognizes
dnl keyword typename.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_TYPENAME],
[AC_CACHE_CHECK(whether the compiler recognizes typename,
ac_cv_cxx_typename,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
template<typename T>class X {public:X(){}};
]],
[[
X<float> z;
return 0;
]])],
[ac_cv_cxx_typename=yes],
[ac_cv_cxx_typename=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_typename" = yes; then
AC_DEFINE(HAVE_TYPENAME,1,[define if the compiler recognizes typename])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_STDINCLUDES
dnl Define HAVE_STDINCLUDES if the compiler has the
dnl new style include files (without the .h)
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_STDINCLUDES],
[AC_CACHE_CHECK(whether the compiler comes with standard includes,
ac_cv_cxx_stdincludes,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#include <new>
struct X { int a; X(int a):a(a){} };
X* foo(void *x) { return new(x) X(2); }
]],
[[
]])],
[ac_cv_cxx_stdincludes=yes],
[ac_cv_cxx_stdincludes=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_stdincludes" = yes; then
AC_DEFINE(HAVE_STDINCLUDES,1,
[define if the compiler comes with standard includes])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_BOOL
dnl If the compiler recognizes bool as a separate built-in type,
dnl define HAVE_BOOL. Note that a typedef is not a separate
dnl type since you cannot overload a function such that it
dnl accepts either the basic type or the typedef.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_BOOL],
[AC_CACHE_CHECK(whether the compiler recognizes bool as a built-in type,
ac_cv_cxx_bool,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
int f(int x){return 1;}
int f(char x){return 1;}
int f(bool x){return 1;}
]],
[[
bool b = true;
return f(b);
]])],
[ac_cv_cxx_bool=yes],
[ac_cv_cxx_bool=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_bool" = yes; then
AC_DEFINE(HAVE_BOOL,1,[define if bool is a built-in type])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_EXCEPTIONS
dnl If the C++ compiler supports exceptions handling (try,
dnl throw and catch), define HAVE_EXCEPTIONS.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_EXCEPTIONS],
[AC_CACHE_CHECK(whether the compiler supports exceptions,
ac_cv_cxx_exceptions,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
]],
[[
try { throw 1; } catch (int i) { return i; }
]])],
[ac_cv_cxx_exceptions=yes],
[ac_cv_cxx_exceptions=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_exceptions" = yes; then
AC_DEFINE(HAVE_EXCEPTIONS,1,[define if the compiler supports exceptions])
fi
])
dnl -------------------------------------------------------
dnl @synopsis AC_CXX_GCCTLS
dnl Define HAVE_GCCTLS if the compiler recognizes
dnl keyword __thread for TLS variables.
dnl -------------------------------------------------------
AC_DEFUN([AC_CXX_GCCTLS],
[AC_CACHE_CHECK(whether the compiler supports keyword __thread,
ac_cv_cxx_gcctls,
[AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
__thread int i;
]],
[[
return i;
]])],
[ac_cv_cxx_gcctls=yes],
[ac_cv_cxx_gcctls=no])
AC_LANG_POP([C++])
])
if test "$ac_cv_cxx_gcctls" = yes; then
AC_DEFINE(HAVE_GCCTLS,1,[define if the compiler supports keyword __thread])
fi
])
dnl ------------------------------------------------------------------
dnl @synopsis AC_PATH_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
dnl This macro figures out how to build C programs using POSIX
dnl threads. It sets the PTHREAD_LIBS output variable to the threads
dnl library and linker flags, and the PTHREAD_CFLAGS output variable
dnl to any special C compiler flags that are needed. (The user can also
dnl force certain compiler flags/libs to be tested by setting these
dnl environment variables.).
dnl ------------------------------------------------------------------
AC_DEFUN([AC_PATH_PTHREAD], [
AC_REQUIRE([AC_CANONICAL_HOST])
acx_pthread_ok=no
# First, check if the POSIX threads header, pthread.h, is available.
# If it isn't, don't bother looking for the threads libraries.
AC_CHECK_HEADER(pthread.h, , acx_pthread_ok=noheader)
# 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).
# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works.
if test x${PTHREAD_LIBS+set} = xset ||
test x${PTHREAD_CFLAGS+set} = xset ; then
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
AC_MSG_CHECKING([provided PTHREAD_LIBS/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"
CXXFLAGS="$save_CXXFLAGS"
fi
# 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. Also, combinations
# of items (for instance, both a compiler flag and a library name) can be
# specified using a colon separator.
acx_pthread_flags="pthreads none -Kthread -kthread lthread
-pthread -pthreads -mt -mthreads pthread
--thread-safe"
# 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
# -mt: HP aCC (check before -mthreads)
# -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)
# -mthreads: Mingw32/gcc, Lynx/gcc
# pthread: Linux, etcetera
# --thread-safe: KAI C++
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
case "${host_os}-${GCC}" in
*linux*-yes | *kfreebsd*-yes )
# On Linux/GCC, libtool uses -nostdlib for linking, which cancel part
# of the -pthread flag effect (libpthread is not automatically linked).
# So we'll try to link with both -pthread and -lpthread first:
acx_pthread_flags="-pthread:pthread $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])
;;
*:*)
PTHREAD_CFLAGS=""
PTHREAD_LIBS=""
message="whether pthreads work with"
while test x"$flag" != x; do
subflag=`echo $flag | cut -d: -f1`
case $subflag in
-*)
PTHREAD_CFLAGS="$PTHREAD_CFLAGS $subflag"
message="$message $subflag"
;;
*)
PTHREAD_LIBS="$PTHREAD_LIBS -l$subflag"
message="$message -l$subflag"
;;
esac
flag=`echo $flag | cut -s -d: -f2-`
done
AC_MSG_CHECKING([$message])
;;
-*)
AC_MSG_CHECKING([whether pthreads work with $flag])
PTHREAD_CFLAGS="$flag"
;;
*)
AC_MSG_CHECKING([for the pthreads library -l$flag])
PTHREAD_LIBS="-l$flag"
;;
esac
save_LIBS="$LIBS"
save_CFLAGS="$CFLAGS"
save_CXXFLAGS="$CXXFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
CXXFLAGS="$CXXFLAGS $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_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#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],
[acx_pthread_ok=no])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
CXXFLAGS="$save_CXXFLAGS"
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"
save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
AC_MSG_CHECKING([if more special flags are required for pthreads])
flag=no
case "${host_cpu}-${host_os}" in
*-aix* | *-freebsd*) flag="-D_THREAD_SAFE";;
*solaris* | alpha*-osf*) flag="-D_REENTRANT";;
esac
AC_MSG_RESULT(${flag})
if test "x$flag" != xno; then
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
fi
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
CXXFLAGS="$save_CXXFLAGS"
fi
AC_ARG_VAR(PTHREAD_LIBS, [Flags for linking pthread programs.])
AC_ARG_VAR(PTHREAD_CFLAGS, [Flags for compiling pthread programs.])
# execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_pthread_ok" = xyes; then
AC_DEFINE(HAVE_PTHREAD,1,[Define if pthreads are available])
ifelse([$1],,:,[$1])
else
ifelse([$2],,:,[$2])
fi
])
dnl ------------------------------------------------------------------
dnl @synopsis AC_PATH_JPEG([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
dnl Process option --with-jpeg.
dnl Search JPEG. Define HAVE_JPEG.
dnl Set output variable JPEG_CFLAGS and JPEG_LIBS
dnl ------------------------------------------------------------------
AC_DEFUN([AC_PATH_JPEG],
[
AC_ARG_VAR(JPEG_LIBS)
AC_ARG_VAR(JPEG_CFLAGS)
ac_jpeg=no
AC_ARG_WITH(jpeg,
AS_HELP_STRING([--with-jpeg=DIR],
[where the IJG jpeg library is located]),
[ac_jpeg=$withval], [ac_jpeg=yes] )
# Process specification
if test x$ac_jpeg = xyes ; then
test x${JPEG_LIBS+set} != xset && JPEG_LIBS="-ljpeg"
elif test x$ac_jpeg != xno ; then
test x${JPEG_LIBS+set} != xset && JPEG_LIBS="-L$ac_jpeg/lib -ljpeg"
test x${JPEG_CFLAGS+set} != xset && JPEG_CFLAGS="-I$ac_jpeg/include"
fi
# Try linking
if test x$ac_jpeg != xno ; then
AC_MSG_CHECKING([for jpeg library])
save_CFLAGS="$CFLAGS"
save_CXXFLAGS="$CXXFLAGS"
save_LIBS="$LIBS"
CFLAGS="$CFLAGS $JPEG_CFLAGS"
CXXFLAGS="$CXXFLAGS $JPEG_CFLAGS"
LIBS="$LIBS $JPEG_LIBS"
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <jpeglib.h>
#ifdef __cplusplus
}
#endif
]],
[
jpeg_CreateDecompress(0,0,0);
])],
[ac_jpeg=yes],
[ac_jpeg=no])
CFLAGS="$save_CFLAGS"
CXXFLAGS="$save_CXXFLAGS"
LIBS="$save_LIBS"
AC_MSG_RESULT($ac_jpeg)
fi
# Finish
if test x$ac_jpeg = xno; then
JPEG_CFLAGS= ; JPEG_LIBS=
ifelse([$2],,:,[$2])
else
AC_DEFINE(HAVE_JPEG,1,[Define if you have the IJG JPEG library.])
dnl AC_MSG_RESULT([setting JPEG_CFLAGS=$JPEG_CFLAGS])
dnl AC_MSG_RESULT([setting JPEG_LIBS=$JPEG_LIBS])
ifelse([$1],,:,[$1])
fi
])
dnl ------------------------------------------------------------------
dnl @synopsis AC_PATH_TIFF([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
dnl Process option --with-tiff
dnl Search LIBTIFF. Define HAVE_TIFF.
dnl Set output variable TIFF_CFLAGS and TIFF_LIBS
dnl ------------------------------------------------------------------
AC_DEFUN([AC_PATH_TIFF],
[
AC_ARG_VAR(TIFF_LIBS)
AC_ARG_VAR(TIFF_CFLAGS)
ac_tiff=no
AC_ARG_WITH(tiff,
AS_HELP_STRING([--with-tiff=DIR],
[where libtiff is located]),
[ac_tiff=$withval], [ac_tiff=yes] )
# Process specification
if test x$ac_tiff = xyes ; then
test x${TIFF_LIBS+set} != xset && TIFF_LIBS="-ltiff"
elif test x$ac_tiff != xno ; then
test x${TIFF_LIBS+set} != xset && TIFF_LIBS="-L$ac_tiff/lib -ltiff"
test x${TIFF_CFLAGS+set} != xset && TIFF_CFLAGS="-I$ac_tiff/include"
fi
# Try linking
if test x$ac_tiff != xno ; then
AC_MSG_CHECKING([for the libtiff library])
save_CFLAGS="$CFLAGS"
save_CXXFLAGS="$CXXFLAGS"
save_LIBS="$LIBS"
CFLAGS="$CFLAGS $TIFF_CFLAGS"
CXXFLAGS="$CXXFLAGS $TIFF_CFLAGS"
LIBS="$LIBS $TIFF_LIBS"
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <tiffio.h>
#ifdef __cplusplus
}
#endif
]],
[
TIFFOpen(0,0);
])],
[ac_tiff=yes],
[ac_tiff=no])
CFLAGS="$save_CFLAGS"
CXXFLAGS="$save_CXXFLAGS"
LIBS="$save_LIBS"
AC_MSG_RESULT($ac_tiff)
fi
# Finish
if test x$ac_tiff = xno; then
TIFF_CFLAGS= ; TIFF_LIBS=
ifelse([$2],,:,[$2])
else
AC_DEFINE(HAVE_TIFF,1,[Define if you have libtiff.])
dnl AC_MSG_RESULT([setting TIFF_CFLAGS=$TIFF_CFLAGS])
dnl AC_MSG_RESULT([setting TIFF_LIBS=$TIFF_LIBS])
ifelse([$1],,:,[$1])
fi
])
dnl ------------------------------------------------------------------
dnl @synopsis AC_PROG_PKG_CONFIG([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
dnl Sets output variables PKG_CONFIG
dnl ------------------------------------------------------------------
AC_DEFUN([AC_PROG_PKG_CONFIG],
[
AC_ARG_VAR(PKG_CONFIG,[Location of the pkg-config program.])
AC_ARG_VAR(PKG_CONFIG_PATH, [Path for pkg-config descriptors.])
AC_PATH_PROG(PKG_CONFIG, pkg-config)
if test -z "$PKG_CONFIG" ; then
ifelse([$2],,:,[$2])
else
ifelse([$1],,:,[$1])
fi
])