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 A { public: template A operator=(const A& z) { return A(); } }; ]], [[ A x; A 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( [[ templateclass X {public:X(){}}; ]], [[ X 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 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_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 #include #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 #include #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 ])