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)

])