dnl -*-autoconf-*-
AC_DEFUN([LFTP_PROG_CXXLINK],
[
AC_MSG_CHECKING(how to link simple c++ programs)
if test "$GCC" = yes -a "$GXX" = yes; then
old_CXX="$CXX"
CXX="$CC"
AC_LANG_PUSH(C++)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[char *a=new char[10];delete[] a;]])],[],[
old_LIBS="$LIBS"
LIBS="-lsupc++ $LIBS"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[char *a=new char[10];delete[] a;]])],[],[LIBS="$old_LIBS"; CXX="$old_CXX";])
])
AC_LANG_POP(C++)
fi
AC_MSG_RESULT(using $CXX)
])
dnl try to build and run a dummy program
AC_DEFUN([LFTP_CXX_TEST],
[
AC_LANG_PUSH(C++)
AC_MSG_CHECKING(if c++ compiler works)
AC_RUN_IFELSE([AC_LANG_SOURCE([[int main() { return(0); } ]])],[AC_MSG_RESULT(yes)],[
AC_MSG_RESULT(no)
AC_MSG_ERROR(C++ test compile failed; check your C++ compiler)],[AC_MSG_RESULT(cross-compiling)])
AC_LANG_POP(C++)
])
AC_DEFUN([LFTP_FUNC_SSCANF_CONST],
[
AC_MSG_CHECKING(whether sscanf works on const strings)
AC_CACHE_VAL(lftp_cv_func_sscanf_const_works,
[
AC_RUN_IFELSE([AC_LANG_SOURCE([[ #include <stdio.h>
int main() {
int a,b;
return !(sscanf("123x","%d%n",&a,&b)>0);
}]])],[lftp_cv_func_sscanf_const_works=yes;],[lftp_cv_func_sscanf_const_works=no;],[lftp_cv_func_sscanf_const_works=yes;])
])
AC_MSG_RESULT($lftp_cv_func_sscanf_const_works)
if test $lftp_cv_func_sscanf_const_works = no; then
AC_MSG_WARN(sscanf does not work on const strings)
fi
])
dnl Do nothing if the compiler accepts the inline keyword.
dnl Otherwise define c_inline to __inline__ or __inline if one of those work,
dnl otherwise define c_inline to be empty.
AC_DEFUN([LFTP_C_INLINE],
[AC_CACHE_CHECK([for inline], ac_cv_c_inline,
[ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[} $ac_kw foo() {]])],[ac_cv_c_inline=$ac_kw; break],[])
done
])
case "$ac_cv_c_inline" in
inline | yes) ;;
no) AC_DEFINE(c_inline, ) ;;
*) AC_DEFINE_UNQUOTED(c_inline, $ac_cv_c_inline) ;;
esac
])
AC_DEFUN([LFTP_NOIMPLEMENTINLINE],
[
AC_MSG_CHECKING(if -fno-implement-inlines implements virtual functions)
flags="-fno-implement-inlines"
AC_CACHE_VAL(lftp_cv_noimplementinline,
[
AC_LANG_PUSH(C++)
old_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $flags"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
class aaa
{
int var;
public:
virtual void func() { var=1; }
aaa();
virtual ~aaa();
};
aaa::aaa() { var=0; }
aaa::~aaa() {}
]], [[]])],[lftp_cv_noimplementinline=yes],[lftp_cv_noimplementinline=no])
CXXFLAGS="$old_CXXFLAGS"
AC_LANG_POP(C++)
])
AC_MSG_RESULT($lftp_cv_noimplementinline)
if test x$lftp_cv_noimplementinline = xyes; then
CXXFLAGS="$CXXFLAGS $flags"
fi
])
AC_DEFUN([LFTP_CHECK_CXX_FLAGS],
[
flags="$1"
AC_MSG_CHECKING(if $CXX supports $flags)
AC_LANG_PUSH(C++)
old_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $flags"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
class aaa
{
int var;
public:
virtual void func() { var=1; }
aaa();
virtual ~aaa();
};
aaa::aaa() { var=0; }
aaa::~aaa() {}
]], [[]])],[support=yes],[support=no])
CXXFLAGS="$old_CXXFLAGS"
AC_LANG_POP(C++)
AC_MSG_RESULT($support)
if test x$support = xyes; then
CXXFLAGS="$CXXFLAGS $flags"
fi
])
AC_DEFUN([LFTP_CHECK_LIBM],
[
AC_MSG_CHECKING(if math library is needed)
AC_CACHE_VAL(lftp_cv_libm_needed,
[
AC_LANG_PUSH(C++)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <math.h>
double a,b;
]], [[
return int(exp(a)+log(b)+pow(a,b));
]])],[lftp_cv_libm_needed=no],[lftp_cv_libm_needed=yes])
AC_LANG_POP(C++)
])
AC_MSG_RESULT($lftp_cv_libm_needed)
if test x$lftp_cv_libm_needed = xyes; then
AC_SEARCH_LIBS(exp,m)
fi
])
dnl try to build and run a dummy program
AC_DEFUN([LFTP_CXX_BOOL],
[
AC_MSG_CHECKING(whether $CXX supports bool type)
AC_CACHE_VAL(lftp_cv_cxx_bool,
[
AC_LANG_PUSH(C++)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[bool t=true;bool f=false;]], [[]])],[lftp_cv_cxx_bool=yes],[lftp_cv_cxx_bool=no])
AC_LANG_POP(C++)
])
AC_MSG_RESULT($lftp_cv_cxx_bool)
if test x$lftp_cv_cxx_bool = xyes; then
AC_DEFINE(HAVE_CXX_BOOL, 1, [define if c++ compiler supports bool])
fi
AH_VERBATIM([OPT_CPP_BOOL], [
#if defined(__cplusplus) && !defined(HAVE_CXX_BOOL)
typedef unsigned _bool;
#define bool _bool
#define false 0U
#define true 1U
#endif ])
])
dnl try to build and run a dummy program
AC_DEFUN([LFTP_CXX__BOOL],
[
AC_MSG_CHECKING(whether $CXX supports _Bool type)
AC_CACHE_VAL(lftp_cv_cxx__Bool,
[
AC_LANG_PUSH(C++)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[_Bool t=true;bool f=false;]], [[]])],[lftp_cv_cxx__Bool=yes],[lftp_cv_cxx__Bool=no])
AC_LANG_POP(C++)
])
AC_MSG_RESULT($lftp_cv_cxx__Bool)
if test x$lftp_cv_cxx__Bool = xyes; then
AC_DEFINE(HAVE_CXX__BOOL, 1, [define if c++ compiler supports _Bool])
fi
AH_VERBATIM([OPT_CPP__BOOL], [
#if defined(__cplusplus) && !defined(HAVE_CXX__BOOL)
typedef bool _Bool;
#endif ])
])
dnl check if C++ compiler needs extra arguments to grok ANSI scoping rules
AC_DEFUN([LFTP_CXX_ANSI_SCOPE],
[
AC_MSG_CHECKING([whether $CXX understands ANSI scoping rules])
AC_CACHE_VAL(lftp_cv_cxx_ansi_scope,
[
AC_LANG_PUSH(C++)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
for (int i = 0; i < 4; i++) ;
for (int i = 0; i < 4; i++) ;]])],[lftp_cv_cxx_ansi_scope=yes],[
# IRIX C++ needs -LANG:ansi-for-init-scope=ON if
# -LANG:std not used
_cxxflags=$CXXFLAGS
CXXFLAGS="$CXXFLAGS -LANG:ansi-for-init-scope=ON"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
for (int i = 0; i < 4; i++) ;
for (int i = 0; i < 4; i++) ;]])],[lftp_cv_cxx_ansi_scope="-LANG:ansi-for-init-scope=ON"],[lftp_cv_cxx_ansi_scope=no])
CXXFLAGS=$_cxxflags
])
AC_LANG_POP(C++)
])
if test x$lftp_cv_cxx_ansi_scope = xno; then
AC_MSG_RESULT([$lftp_cv_cxx_ansi_scope])
AC_MSG_ERROR([C++ compiler does not understand ANSI scoping rules])
elif test x$lftp_cv_cxx_ansi_scope != xyes; then
AC_MSG_RESULT([$lftp_cv_cxx_ansi_scope added to \$CXXFLAGS])
CXXFLAGS="$CXXFLAGS $lftp_cv_cxx_ansi_scope"
else
AC_MSG_RESULT($lftp_cv_cxx_ansi_scope)
fi
])
AC_DEFUN([LFTP_ENVIRON_CHECK],[
AC_CACHE_CHECK([for environ variable],[lftp_cv_environ],[
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <unistd.h>
extern char **environ;
]], [[
return environ==(char**)0;
]])],[lftp_cv_environ=yes],[lftp_cv_environ=no])
])
if test x$lftp_cv_environ = xyes; then
AC_DEFINE(HAVE_ENVIRON, 1, [define if you have global environ variable])
fi
])
dnl Taken from dovecot
AC_DEFUN([LFTP_POSIX_FALLOCATE_CHECK],[
dnl * Old glibcs have broken posix_fallocate(). Make sure not to use it.
dnl * It may also be broken in AIX.
AC_CACHE_CHECK([whether posix_fallocate() works],[i_cv_posix_fallocate_works],[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#define _XOPEN_SOURCE 600
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#if defined(__GLIBC__) && (__GLIBC__ < 2 || __GLIBC_MINOR__ < 7)
possibly broken posix_fallocate
#endif
int main() {
int fd = creat("conftest.temp", 0600);
int ret;
if (fd == -1) {
perror("creat()");
return 2;
}
ret = posix_fallocate(fd, 1024, 1024) < 0 ? 1 : 0;
unlink("conftest.temp");
return ret;
}
]])],[
i_cv_posix_fallocate_works=yes
],[
i_cv_posix_fallocate_works=no
],[
dnl * Cross-compilation: we can only test if the code compiles and links.
dnl * If it does, assume that it works, because cross-compilation for AIX or old glibc is unlikely.
AC_CACHE_VAL([i_cv_posix_fallocate_works],[
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <fcntl.h>
]], [[
posix_fallocate(0, 0, 0);
]])],[
i_cv_posix_fallocate_works=yes
],[
i_cv_posix_fallocate_works=no
])
])
])
])
if test x$i_cv_posix_fallocate_works = xyes; then
AC_DEFINE(HAVE_POSIX_FALLOCATE, 1, [Define if you have a working posix_fallocate()])
fi
])
AC_DEFUN([LFTP_POSIX_FADVISE_CHECK],[
AC_CACHE_CHECK([for posix_fadvise], [ac_cv_posix_fadvise], [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#define _XOPEN_SOURCE 600
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
]], [[
int res = posix_fadvise ((int)0, (off_t)0, (off_t)0, POSIX_FADV_NORMAL);
int a = POSIX_FADV_SEQUENTIAL;
int b = POSIX_FADV_NOREUSE;
int c = POSIX_FADV_RANDOM;
int d = POSIX_FADV_WILLNEED;
int e = POSIX_FADV_DONTNEED;
]])],[ac_cv_posix_fadvise=yes],[ac_cv_posix_fadvise=no])])
if test x$ac_cv_posix_fadvise = xyes; then
AC_DEFINE(HAVE_POSIX_FADVISE, 1, [Define if posix_fadvise() is available])
fi
])
AC_DEFUN([LFTP_CXX_STDC_LIMIT_MACROS],[
dnl * Old glibcs requires that __STDC_LIMIT_MACROS is defined for using
dnl * stdint.h in c++ mode
AC_MSG_CHECKING(whether stdint.h needs __STDC_LIMIT_MACROS in C++ mode)
AC_CACHE_VAL(lftp_cv_cxx_stdc_limit_macros,
[
AC_LANG_PUSH(C++)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdint.h>
int i = INT_MIN==INT32_MIN && INT_MAX == INT32_MAX;]], [[]])],[lftp_cv_cxx_stdc_limit_macros=no],[lftp_cv_cxx_stdc_limit_macros=yes])
AC_LANG_POP(C++)
])
AC_MSG_RESULT($lftp_cv_cxx_stdc_limit_macros)
if test x$lftp_cv_cxx_stdc_limit_macros = xyes; then
AC_DEFINE(__STDC_LIMIT_MACROS, 1, [Use STDC Limit Macros in C++])
fi
])
AC_DEFUN([LFTP_LIBIDN2_CHECK],[
AC_ARG_WITH(libidn2, AS_HELP_STRING([--with-libidn2@<:@=DIR@:>@],[Support IDN2 (needs GNU Libidn2)]),
libidn2=$withval, libidn2=yes)
if test "$libidn2" != "no"; then
if test "$libidn2" != "yes"; then
LDFLAGS="${LDFLAGS} -L$libidn2/lib"
CPPFLAGS="${CPPFLAGS} -I$libidn2/include"
fi
AC_CHECK_HEADER(idn2.h,
AC_CHECK_LIB(idn2, idn2_check_version,
[libidn2=yes LIBS="${LIBS} -lidn2"], libidn2=no),
libidn2=no)
fi
if test "$libidn2" != "no" ; then
AC_DEFINE(LIBIDN2, 1, [Define to 1 if you want IDN2 support.])
else
AC_MSG_WARN([Libidn2 not found])
fi
AC_MSG_CHECKING([if Libidn2 should be used])
AC_MSG_RESULT($libidn2)
])