path: root/configure.in

dnl Process this file with autoconf to produce a configure script.

dnl !!! WHEN ADDING NEW CONFIGURE TESTS, PLEASE ADD CODE TO MAIN.C !!!
dnl !!! TO DUMP THEIR RESULTS WHEN MUTT -V IS CALLED            !!!

AC_PREREQ(2.12)
AC_INIT(mutt.h)
AM_CONFIG_HEADER(config.h)

mutt_cv_version=`cat $srcdir/VERSION`


AM_INIT_AUTOMAKE(mutt, $mutt_cv_version)


ALL_LINGUAS="de ru it es uk fr pl nl cs id sk ko el zh_TW zh_CN pt_BR eo gl sv da lt tr ja hu et ca"

AC_CANONICAL_HOST

AC_MSG_CHECKING(for prefix)
if test x$prefix = xNONE; then
        mutt_cv_prefix=$ac_default_prefix
else
        mutt_cv_prefix=$prefix
fi
AC_MSG_RESULT($mutt_cv_prefix)

AC_PROG_CC
AC_ISC_POSIX
AM_C_PROTOTYPES
if test "x$U" != "x"; then
  AC_MSG_ERROR(Compiler not ANSI compliant)
fi
AC_PROG_CPP
AC_PROG_MAKE_SET
AC_PROG_INSTALL
AC_PROG_RANLIB
AC_CHECK_TOOL(AR, ar, ar)

AC_C_INLINE
AC_C_CONST

AC_PATH_PROG(DBX, dbx, no)
AC_PATH_PROG(GDB, gdb, no)
AC_PATH_PROG(SDB, sdb, no)

if test $GDB != no ; then
        DEBUGGER=$GDB
elif test $DBX != no ; then
        DEBUGGER=$DBX
elif test $SDB != no ; then
        DEBUGGER=$SDB
else
        DEBUGGER=no
fi

AC_SUBST(DEBUGGER)

ac_aux_path_sendmail=/usr/sbin:/usr/lib
AC_PATH_PROG(SENDMAIL, sendmail, /usr/sbin/sendmail, $PATH:$ac_aux_path_sendmail)
AC_DEFINE_UNQUOTED(SENDMAIL,"$ac_cv_path_SENDMAIL",[ Where to find sendmail on your system. ])

OPS='$(srcdir)/OPS'
if test -f $srcdir/EXPORTABLE ; then
        SUBVERSION="us"
else
        SUBVERSION="i"

        AC_ARG_ENABLE(pgp, [  --disable-pgp              Disable PGP support],
        [       if test x$enableval = xno ; then
                        have_pgp=no
                fi
        ])

        if test x$have_pgp != xno ; then
                AC_DEFINE(HAVE_PGP,1,[ Define if you want PGP support. ])
                PGPAUX_TARGET="pgpring pgpewrap"
                MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS pgp.o pgpinvoke.o pgpkey.o pgplib.o gnupgparse.o pgpmicalg.o pgppacket.o"
                OPS="$OPS \$(srcdir)/OPS.PGP"
        fi

 	AC_ARG_ENABLE(smime, [  --disable-smime              Disable SMIME support],
 	[	if test x$enableval = xno ; then
 			have_smime=no
 		fi
 	])
 
 	if test x$have_smime != xno ; then
 		AC_DEFINE(HAVE_SMIME,1,[ Define if you want S/MIME support. ])
 		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS smime.o "
 		OPS="$OPS \$(srcdir)/OPS.SMIME"
		SMIMEAUX_TARGET="smime_keys"
 	fi
  
 	if test x$HAVE_SMIME != xno -o x$HAVE_PGP != xno ; then
 		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS crypt.o "
 		OPS="$OPS \$(srcdir)/OPS.CRYPT"
 	fi
 
        AC_ARG_WITH(mixmaster, [  --with-mixmaster[=PATH]    Include Mixmaster support],
                [if test -x "$withval" ; then
                        MIXMASTER="$withval"
                 else
                        MIXMASTER="mixmaster"
                 fi
                 OPS="$OPS \$(srcdir)/OPS.MIX"
                 MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS remailer.o"
                 AC_DEFINE_UNQUOTED(MIXMASTER,"$MIXMASTER",
                         [ Where to find mixmaster on your system. ])
                ])

fi
AC_SUBST(OPS)

AC_SUBST(PGPAUX_TARGET)
AC_SUBST(SMIMEAUX_TARGET)

AC_DEFINE_UNQUOTED(SUBVERSION,"$SUBVERSION",[ Is this the international version? ])
AC_SUBST(SUBVERSION)

AC_PATH_PROG(ISPELL, ispell, no)
if test $ISPELL != no; then
        AC_DEFINE_UNQUOTED(ISPELL,"$ISPELL",[ Where to find ispell on your system. ])
fi

AC_ARG_WITH(slang, [  --with-slang[=DIR]         Use S-Lang instead of ncurses],
        [AC_CACHE_CHECK([if this is a BSD system], mutt_cv_bsdish,
                [AC_TRY_RUN([#include <sys/param.h>

main ()
{
#ifdef BSD
        exit (0);
#else
        exit (1);
#endif
}],
                        mutt_cv_bsdish=yes,
                        mutt_cv_bsdish=no,
                        mutt_cv_bsdish=no)])

        AC_MSG_CHECKING(for S-Lang)
        if test $withval = yes; then
                if test -d $srcdir/../slang; then
                        mutt_cv_slang=$srcdir/../slang/src
                        CPPFLAGS="$CPPFLAGS -I${mutt_cv_slang}"
                        LDFLAGS="$LDFLAGS -L${mutt_cv_slang}/objs"
                else
                        if test -d $mutt_cv_prefix/include/slang; then
                                CPPFLAGS="$CPPFLAGS -I$mutt_cv_prefix/include/slang"
                        elif test -d /usr/include/slang; then
                                CPPFLAGS="$CPPFLAGS -I/usr/include/slang"
                        fi
                        mutt_cv_slang=yes
                fi
        else
                dnl ---Check to see if $withval is a source directory
                if test -f $withval/src/slang.h; then
                        mutt_cv_slang=$withval/src
                        CPPFLAGS="$CPPFLAGS -I${mutt_cv_slang}"
                        LDFLAGS="$LDFLAGS -L${mutt_cv_slang}/objs"
                else
                        dnl ---Must be installed somewhere
                        mutt_cv_slang=$withval
                        if test -d $withval/include/slang; then
                                CPPFLAGS="$CPPFLAGS -I${withval}/include/slang"
                        elif test -d $withval/include; then
                                CPPFLAGS="$CPPFLAGS -I${withval}/include"
                        fi
                        LDFLAGS="$LDFLAGS -L${withval}/lib"
                fi
        fi
        AC_MSG_RESULT($mutt_cv_slang)
        if test $mutt_cv_bsdish = yes; then
                AC_CHECK_LIB(termlib, main)
        fi
        AC_DEFINE(USE_SLANG_CURSES,1,
                [ Define if you compile with SLang instead of curses/ncurses. ])
        AC_DEFINE(HAVE_COLOR,1,[ Define if your curses library supports color. ])
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS resize.o"

        dnl --- now that we've found it, check the link

        AC_CHECK_LIB(slang, SLtt_get_terminfo,
                [MUTTLIBS="$MUTTLIBS -lslang -lm"],
                [AC_MSG_ERROR(unable to compile.  check config.log)], -lm)

        ],

        [mutt_cv_curses=/usr
        AC_ARG_WITH(curses, [  --with-curses=DIR          Where ncurses is installed ],
                [if test $withval != yes; then
                        mutt_cv_curses=$withval
                fi
                if test x$mutt_cv_curses != x/usr; then
                        LDFLAGS="-L${mutt_cv_curses}/lib $LDFLAGS"
                        CPPFLAGS="$CPPFLAGS -I${mutt_cv_curses}/include"
                fi])

	AC_CHECK_FUNC(initscr,,[
	cf_ncurses="ncurses"
	for lib in ncurses ncursesw
	do
		AC_CHECK_LIB($lib, waddnwstr, [cf_ncurses="$lib"; break])
	done
        AC_CHECK_LIB($cf_ncurses, initscr,
                [MUTTLIBS="$MUTTLIBS -l$cf_ncurses"
                if test x$mutt_cv_curses = x/usr -a -d /usr/include/ncurses; then
                        CPPFLAGS="$CPPFLAGS -I/usr/include/ncurses"
                fi
		
                if test "$cf_ncurses" = ncursesw; then
			AC_CHECK_HEADERS(ncursesw/ncurses.h,[cf_cv_ncurses_header="ncursesw/ncurses.h"])
		else
			AC_CHECK_HEADERS(ncurses.h,[cf_cv_ncurses_header="ncurses.h"])
		fi],

                [CF_CURSES_LIBS])
		])

        old_LIBS="$LIBS"
        LIBS="$LIBS $MUTTLIBS"
        CF_CHECK_FUNCDECLS([#include <${cf_cv_ncurses_header-curses.h}>], start_color typeahead bkgdset curs_set meta use_default_colors resizeterm)
        if test "$ac_cv_func_decl_start_color" = yes; then
                AC_DEFINE(HAVE_COLOR,1,[ Define if your curses library supports color. ])
        fi
        if test "$ac_cv_func_decl_resizeterm" = yes; then
                MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS resize.o"
        fi
        LIBS="$old_LIBS"
        ])

AC_HEADER_STDC

AC_CHECK_HEADERS(stdarg.h sys/ioctl.h ioctl.h sysexits.h)
AC_CHECK_HEADERS(sys/time.h sys/resource.h)
AC_CHECK_HEADERS(unix.h)

AC_CHECK_FUNCS(setrlimit getsid)

AC_TYPE_SIGNAL

AC_MSG_CHECKING(for sig_atomic_t in signal.h)
AC_EGREP_HEADER(sig_atomic_t,signal.h,
  [
    ac_cv_type_sig_atomic_t=yes;
    AC_EGREP_HEADER(volatile.*sig_atomic_t,
                    signal.h,
                    [
                        is_sig_atomic_t_volatile=yes;
                        AC_MSG_RESULT([yes, volatile])
                    ],
                    [
                        is_sig_atomic_t_volatile=no;
                        AC_MSG_RESULT([yes, non volatile])
                    ])
  ],
  [
    AC_MSG_RESULT(no)
    AC_CHECK_TYPE(sig_atomic_t, int)
    is_sig_atomic_t_volatile=no
  ])
if test $is_sig_atomic_t_volatile = 'yes'
then
    AC_DEFINE(SIG_ATOMIC_VOLATILE_T, sig_atomic_t)
else
    AC_DEFINE(SIG_ATOMIC_VOLATILE_T, [volatile sig_atomic_t])
fi

AC_DECL_SYS_SIGLIST

dnl For MD5 and SHA1 on 64-bit systems
AC_C_BIGENDIAN
AC_CHECK_HEADERS(inttypes.h stdint.h)
dnl This is the method autoconf-2.50's new AC_CHECK_TYPE macro uses.
dnl We need to be backwards compatible to autoconf 2.13, though. -lh
AC_MSG_CHECKING(for uint32_t)
AC_TRY_COMPILE([
#include <sys/types.h>
#if HAVE_INTTYPES_H
#include <inttypes.h>
#else
#if HAVE_STDINT_H
#include <stdint.h>
#endif
#endif],
[if ((uint32_t *) 0)
  return 0;
if (sizeof (uint32_t))
  return 0;
],[
    AC_DEFINE(HAVE_UINT32_T,1,[ Define if you have the uint32_t type. ])
    AC_MSG_RESULT(yes)
  ], AC_MSG_RESULT(no)
)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)

AC_TYPE_PID_T

AC_CHECK_FUNCS(fgetpos memmove setegid srand48 strerror)

AC_REPLACE_FUNCS(strcasecmp strdup)

AC_CHECK_FUNC(getopt)
if test $ac_cv_func_getopt = yes; then
        AC_CHECK_HEADERS(getopt.h)
fi

mutt_cv_snprintf=no
SNPRINTFOBJS=""
AC_CHECK_FUNCS(snprintf, , [mutt_cv_snprintf=yes])
AC_CHECK_FUNCS(vsnprintf, , [mutt_cv_snprintf=yes])
if test $mutt_cv_snprintf = yes; then
        LIBOBJS="$LIBOBJS snprintf.o"
fi

dnl SCO uses chsize() instead of ftruncate()
AC_CHECK_FUNCS(ftruncate, , [AC_CHECK_LIB(x, chsize)])

dnl SCO has strftime() in libintl
AC_CHECK_FUNCS(strftime, , [AC_CHECK_LIB(intl, strftime)])

dnl AIX may not have fchdir()
AC_CHECK_FUNCS(fchdir, , [mutt_cv_fchdir=no])

AC_ARG_WITH(regex, [  --with-regex               Use the GNU regex library ],
        [mutt_cv_regex=yes],
        [AC_CHECK_FUNCS(regcomp, mutt_cv_regex=no, mutt_cv_regex=yes)])

if test $mutt_cv_regex = no ; then
AC_CACHE_CHECK([whether your system's regexp library is completely broken],
        [mutt_cv_regex_broken],
        AC_TRY_RUN([
#include <unistd.h>
#include <regex.h>
main() { regex_t blah ; regmatch_t p; p.rm_eo = p.rm_eo; return regcomp(&blah, "foo.*bar", REG_NOSUB) || regexec (&blah, "foobar", 0, NULL, 0); }],
        mutt_cv_regex_broken=no, mutt_cv_regex_broken=yes, mutt_cv_regex_broken=yes))
        if test $mutt_cv_regex_broken = yes ; then
                echo "Using the included GNU regex instead." >&AC_FD_MSG
                mutt_cv_regex=yes
        fi
fi

if test $mutt_cv_regex = yes; then
        AC_DEFINE(USE_GNU_REGEX,1,[ Define if you want to use the included regex.c. ])
        LIBOBJS="$LIBOBJS regex.o"
fi


AC_ARG_WITH(homespool, [  --with-homespool[=FILE]    File in user's directory where new mail is spooled], with_homespool=${withval})
if test x$with_homespool != x; then
        if test $with_homespool = yes; then
                with_homespool=mailbox
        fi
        AC_DEFINE_UNQUOTED(MAILPATH,"$with_homespool",[ Where new mail is spooled. ])
        AC_DEFINE(HOMESPOOL)
        AC_DEFINE(USE_DOTLOCK,1,[ Define to use dotlocking for mailboxes. ])
        mutt_cv_setgid=no
else
        AC_ARG_WITH(mailpath, [  --with-mailpath=DIR        Directory where spool mailboxes are located],
                [mutt_cv_mailpath=$withval],
                [ AC_CACHE_CHECK(where new mail is stored, mutt_cv_mailpath,
                        [mutt_cv_mailpath=no
                        if test -d /var/mail; then
                                mutt_cv_mailpath=/var/mail
                        elif test -d /var/spool/mail; then
                                mutt_cv_mailpath=/var/spool/mail
                        elif test -d /usr/spool/mail; then
                                mutt_cv_mailpath=/usr/spool/mail
                        elif test -d /usr/mail; then
                                mutt_cv_mailpath=/usr/mail
                        fi])
                ])
        if test $mutt_cv_mailpath = no; then
                AC_MSG_ERROR("Could not determine where new mail is stored.")
        fi
        AC_DEFINE_UNQUOTED(MAILPATH,"$mutt_cv_mailpath",[ Where new mail is spooled. ])

        AC_CACHE_CHECK(if $mutt_cv_mailpath is world writable, mutt_cv_worldwrite, [AC_TRY_RUN([#include <sys/types.h>
#include <sys/stat.h>

int main (int argc, char **argv)
{
        struct stat s;

        stat ("$mutt_cv_mailpath", &s);
        if (s.st_mode & S_IWOTH) exit (0);
        exit (1);
}], mutt_cv_worldwrite=yes, mutt_cv_worldwrite=no, mutt_cv_worldwrite=no)])

        mutt_cv_setgid=no
        if test $mutt_cv_worldwrite = yes; then
                AC_DEFINE(USE_DOTLOCK,1,[ Define to use dotlocking for mailboxes. ])
        else

                AC_CACHE_CHECK(if $mutt_cv_mailpath is group writable, mutt_cv_groupwrite, [AC_TRY_RUN([#include <sys/types.h>
#include <sys/stat.h>

int main (int argc, char **argv)
{
        struct stat s;

        stat ("$mutt_cv_mailpath", &s);
        if (s.st_mode & S_IWGRP) exit (0);
        exit (1);
}], mutt_cv_groupwrite=yes, mutt_cv_groupwrite=no, mutt_cv_groupwrite=no)])

                if test $mutt_cv_groupwrite = yes; then
                        AC_DEFINE(USE_DOTLOCK,1,[ Define to use dotlocking for mailboxes. ])
                        AC_DEFINE(USE_SETGID,1,[ Define if mutt should run setgid "mail". ])
                        mutt_cv_setgid=yes
                fi
        fi
fi

AC_ARG_ENABLE(external_dotlock, [  --enable-external-dotlock  Force use of an external dotlock program],
        [mutt_cv_external_dotlock="$enableval"])

if test "x$mutt_cv_setgid" = "xyes" || test "x$mutt_cv_fchdir" = "xno" \
        || test "x$mutt_cv_external_dotlock" = "xyes"
then
        AC_DEFINE(DL_STANDALONE,1,[ Define if you want to use an external dotlocking program. ])
        DOTLOCK_TARGET="mutt_dotlock"
else
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS dotlock.o"
fi

AC_SUBST(DOTLOCK_TARGET)


AC_MSG_CHECKING(where to put the documentation)
AC_ARG_WITH(docdir, [  --with-docdir=PATH         Specify where to put the documentation],
        [mutt_cv_docdir=$withval],
        [mutt_cv_docdir="$mutt_cv_prefix/doc/mutt"])
AC_MSG_RESULT($mutt_cv_docdir)

docdir=$mutt_cv_docdir
AC_SUBST(docdir)

if test x$mutt_cv_setgid = xyes; then
        DOTLOCK_GROUP='mail'
        DOTLOCK_PERMISSION=2755
else
        DOTLOCK_GROUP=''
        DOTLOCK_PERMISSION=755
fi
AC_SUBST(DOTLOCK_GROUP)
AC_SUBST(DOTLOCK_PERMISSION)

AC_ARG_WITH(domain, [  --with-domain=DOMAIN       Specify your DNS domain name],
        [if test $withval != yes; then
                AC_DEFINE_UNQUOTED(DOMAIN,"$withval",[ Define your domain name. ])
        fi])

need_socket="no"

dnl -- socket dependencies --

AC_ARG_ENABLE(pop,  [  --enable-pop               Enable POP3 support],
[       if test x$enableval = xyes ; then
                AC_DEFINE(USE_POP,1,[ Define if you want support for the POP3 protocol. ])
                MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS pop.o pop_lib.o pop_auth.o"
                need_socket="yes"
                need_md5="yes"
        fi
])

AC_ARG_ENABLE(imap, [  --enable-imap              Enable IMAP support],
[       if test x$enableval = xyes ; then
                AC_DEFINE(USE_IMAP,1,[ Define if you want support for the IMAP protocol. ])
                LIBIMAP="-Limap -limap"
                LIBIMAPDEPS="\$(top_srcdir)/imap/imap.h imap/libimap.a"
                need_imap="yes"
                need_socket="yes"
                need_md5="yes"
        fi
])
AM_CONDITIONAL(BUILD_IMAP, test x$need_imap = xyes)

dnl -- end socket dependencies --

if test "$need_socket" = "yes"
then
        AC_MSG_CHECKING([for socklen_t])
        AC_EGREP_HEADER(socklen_t, sys/socket.h, AC_MSG_RESULT([yes]),
                AC_MSG_RESULT([no])
                AC_DEFINE(socklen_t,int,
                        [ Define to 'int' if <sys/socket.h> doesn't have it. ]))
        AC_CHECK_FUNC(gethostent, , AC_CHECK_LIB(nsl, gethostent))
        AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt))
        AC_CHECK_FUNCS(getaddrinfo)
        AC_DEFINE(USE_SOCKET,1,
                [ Include code for socket support. Set automatically if you enable POP3 or IMAP ])
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS account.o mutt_socket.o mutt_tunnel.o"
fi

dnl -- imap dependencies --

AC_ARG_WITH(gss, [    --with-gss[=PFX]         Compile in GSSAPI authentication for IMAP], 
    gss_prefix="$withval", gss_prefix="no")
if test "$gss_prefix" != "no"
then
  if test "$need_imap" = "yes"
  then
    MUTT_AM_PATH_GSSAPI(gss_prefix)
    AC_MSG_CHECKING(GSSAPI implementation)
    AC_MSG_RESULT($GSSAPI_IMPL)
    if test "$GSSAPI_IMPL" = "none"
    then
      AC_CACHE_SAVE
      AC_MSG_RESULT([GSSAPI libraries not found])
    fi
    if test "$GSSAPI_IMPL" = "Heimdal"
    then
      AC_DEFINE(HAVE_HEIMDAL,1,[ Define if your GSSAPI implementation is Heimdal ])
    fi
    CPPFLAGS="$CPPFLAGS $GSSAPI_CFLAGS"
    MUTTLIBS="$MUTTLIBS $GSSAPI_LIBS"
    AC_DEFINE(USE_GSS,1,[ Define if you have GSSAPI libraries available ])
    need_gss="yes"
  else
    AC_MSG_WARN([GSS was requested but IMAP is not enabled])
  fi
fi
AM_CONDITIONAL(USE_GSS, test x$need_gss = xyes)

dnl -- end imap dependencies --

AC_ARG_WITH(ssl, [  --with-ssl[=PFX]           Compile in SSL support for POP/IMAP],
[       if test "$with_ssl" != "no"
        then
          if test "$need_socket" != "yes"; then
           AC_MSG_ERROR([SSL support is only useful with POP or IMAP support])
          fi

          if test "$with_ssl" != "yes"
          then
           LDFLAGS="$LDFLAGS -L$withval/lib"
           CPPFLAGS="$CPPFLAGS -I$withval/include"
          fi
          saved_LIBS="$LIBS"

          AC_CHECK_LIB(crypto, X509_new,, AC_MSG_ERROR([Unable to find SSL library]))
          AC_CHECK_LIB(ssl, SSL_new,, AC_MSG_ERROR([Unable to find SSL library]), -lcrypto)

          AC_CHECK_FUNCS(RAND_status RAND_egd)

          AC_DEFINE(USE_SSL,1,[ Define if you want support for SSL. ])
          LIBS="$saved_LIBS"
          MUTTLIBS="$MUTTLIBS -lssl -lcrypto"
          MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl.o"
          need_ssl=yes

        fi
])
AM_CONDITIONAL(USE_SSL, test x$need_ssl = xyes)

dnl SSL support via NSS
AC_ARG_WITH(nss, [  --with-nss[=PFX]           Compile in SSL support for POP/IMAP via NSS],
[       if test "$with_nss" != no
        then
          if test "$need_socket" != "yes"; then
           AC_MSG_ERROR([SSL support is only useful with POP or IMAP support])
          fi

          if test "$with_nss" != "yes"
          then
           LDFLAGS="$LDFLAGS -L$withval/lib"
           CPPFLAGS="$CPPFLAGS -I$withval/include -I$withval/public/security"
          fi

          AC_DEFINE(USE_NSS,1,[ Define if you want support for SSL via the NSS library. ])
          MUTTLIBS="$MUTTLIBS -lssl -lnss -lcertdb -lcerthi -lcryptohi"
          MUTTLIBS="$MUTTLIBS -lpk11wrap -lsoftoken -lsecutil -ldbm -lplds4 -lplc4 -lfreebl"
          MUTTLIBS="$MUTTLIBS -lnspr4"

          MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl_nss.o"
          need_ssl=yes
        fi
])

AC_ARG_WITH(sasl, [  --with-sasl[=PFX]          Use Cyrus SASL library for POP/IMAP authentication],
        [
        if test "$need_socket" != "yes"
        then
          AC_MSG_ERROR([SASL support is only useful with POP or IMAP support])
        fi

        if test "$with_sasl" != "no"
        then
          if test "$with_sasl" != "yes"
          then
            CPPFLAGS="$CPPFLAGS -I$with_sasl/include"
            LDFLAGS="$LDFLAGS -L$with_sasl/lib"
          fi

          saved_LIBS="$LIBS"

          AC_CHECK_LIB(sasl, sasl_client_init,,
            AC_MSG_ERROR([could not find libsasl]),)

          MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_sasl.o"
          MUTTLIBS="$MUTTLIBS -lsasl"
          LIBS="$saved_LIBS"
          AC_DEFINE(USE_SASL,1,
                  [ Define if want to use the Cyrus SASL library for POP/IMAP authentication. ])
          need_sasl=yes
          need_md5=no
        fi
        ])
AM_CONDITIONAL(USE_SASL, test x$need_sasl = xyes)

if test "$need_md5" = "yes"
then
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS md5c.o"
fi

dnl -- end socket --

AC_ARG_ENABLE(debug, [  --enable-debug             Enable debugging support],
        [ if test x$enableval = xyes ; then
                AC_DEFINE(DEBUG,1,[ Define to enable debugging info. ])
          fi
         ])

AC_ARG_ENABLE(flock, [  --enable-flock             Use flock() to lock files],
        [if test $enableval = yes; then
                AC_DEFINE(USE_FLOCK,1, [ Define to use flock() to lock mailboxes. ])
        fi])

mutt_cv_fcntl=yes
AC_ARG_ENABLE(fcntl, [  --disable-fcntl            Do NOT use fcntl() to lock files ],
        [if test $enableval = no; then mutt_cv_fcntl=no; fi])

if test $mutt_cv_fcntl = yes; then
        AC_DEFINE(USE_FCNTL,1, [ Define to use fcntl() to lock folders. ])
fi

mutt_cv_warnings=yes
AC_ARG_ENABLE(warnings, [  --disable-warnings         Turn off compiler warnings (not recommended)],
[if test $enableval = no; then
        mutt_cv_warnings=no
fi])

if test x$GCC = xyes -a $mutt_cv_warnings = yes; then
        CFLAGS="-Wall -pedantic $CFLAGS"
fi

AC_ARG_ENABLE(nfs-fix, [  --enable-nfs-fix           Work around an NFS with broken attributes caching ],
        [if test x$enableval = xyes; then
                AC_DEFINE(NFS_ATTRIBUTE_HACK)
        fi])

AC_ARG_ENABLE(buffy-size, [  --enable-buffy-size        Use file size attribute instead of access time ],
        [if test x$enableval = xyes; then
                AC_DEFINE(BUFFY_SIZE,1,[ Define to enable the "buffy_size" feature. ])
        fi])

AC_ARG_ENABLE(mailtool, [  --enable-mailtool          Enable Sun mailtool attachments support ],
        [if test x$enableval = xyes; then
                AC_DEFINE(SUN_ATTACHMENT,1,[ Define to enable Sun mailtool attachments support. ])
        fi])

AC_ARG_ENABLE(locales-fix, [  --enable-locales-fix       The result of isprint() is unreliable ],
        [if test x$enableval = xyes; then
                AC_DEFINE(LOCALES_HACK,1,[ Define if the result of isprint() is unreliable. ])
        fi])

AC_ARG_WITH(exec-shell, [  --with-exec-shell=SHELL    Specify alternate shell (ONLY if /bin/sh is broken)],
        [if test $withval != yes; then
                AC_DEFINE_UNQUOTED(EXECSHELL, "$withval")
        fi])

AC_ARG_ENABLE(exact-address, [  --enable-exact-address     Enable regeneration of email addresses],
        [if test $enableval = yes; then
                AC_DEFINE(EXACT_ADDRESS)
        fi])

AC_SUBST(MUTTLIBS)
AC_SUBST(MUTT_LIB_OBJECTS)
AC_SUBST(LIBIMAP)
AC_SUBST(LIBIMAPDEPS)

dnl -- iconv/gettext --

MUTT_AM_GNU_GETTEXT
if test "$am_cv_func_iconv" != "yes"
then
  AC_MSG_ERROR([Unable to find an iconv function. See INSTALL for help])
fi

dnl (1) Some implementations of iconv won't convert from UTF-8 to UTF-8.
dnl (2) In glibc-2.1.2 and earlier there is a bug that messes up ob and
dnl     obl when args 2 and 3 are 0 (fixed in glibc-2.1.3).
AC_CACHE_CHECK([whether this iconv is good enough], mutt_cv_iconv_good,
        mutt_save_LIBS="$LIBS"
        LIBS="$LIBS $LIBICONV"
        AC_TRY_RUN([
#include <iconv.h>
int main()
{
  iconv_t cd;
changequote(, )dnl
  char buf[4];
changequote([, ])dnl
  char *ob;
  size_t obl;
  ob = buf, obl = sizeof(buf);
  return ((cd = iconv_open("UTF-8", "UTF-8")) != (iconv_t)(-1) &&
          (iconv(cd, 0, 0, &ob, &obl) ||
           !(ob == buf && obl == sizeof(buf)) ||
           iconv_close(cd)));
}
                ],
                mutt_cv_iconv_good=yes,
                mutt_cv_iconv_good=no,
                mutt_cv_iconv_good=yes)
        LIBS="$mutt_save_LIBS")
if test "$mutt_cv_iconv_good" = no; then
  AC_MSG_ERROR(Try using libiconv instead)
fi

dnl This is to detect implementations such as the one in glibc-2.1,
dnl which always convert exactly but return the number of characters
dnl converted instead of the number converted inexactly.
AC_CACHE_CHECK([whether iconv is non-transcribing], mutt_cv_iconv_nontrans,
        mutt_save_LIBS="$LIBS"
        LIBS="$LIBS $LIBICONV"
        AC_TRY_RUN([
#include <iconv.h>
#include <string.h>
int main()
{
  iconv_t cd;
  const char *ib;
  char *ob;
  size_t ibl, obl;
  const char *s = "\304\211";
changequote(, )dnl
  char t[3];
changequote([, ])dnl
  ib = s, ibl = 2, ob = t, obl = 3;
  return ((cd = iconv_open("UTF-8", "UTF-8")) == (iconv_t)(-1) ||
          iconv(cd, &ib, &ibl, &ob, &obl));
}
                ],
                mutt_cv_iconv_nontrans=no,
                mutt_cv_iconv_nontrans=yes,
                mutt_cv_iconv_nontrans=no)
        LIBS="$mutt_save_LIBS")
if test "$mutt_cv_iconv_nontrans" = yes; then
  AC_DEFINE(ICONV_NONTRANS, 1)
else
  AC_DEFINE(ICONV_NONTRANS, 0)
fi

CPPFLAGS="$CPPFLAGS -I\$(top_srcdir)/intl"

if test "$BUILD_INCLUDED_LIBINTL" = "yes"; then
  AC_DEFINE(HAVE_BIND_TEXTDOMAIN_CODESET,1,
          [ Define if your gettext has bind_textdomain_codeset. ])
else
  AC_CHECK_FUNCS(bind_textdomain_codeset)
fi

dnl -- locales --

AC_CHECK_HEADERS(wchar.h)

AC_CACHE_CHECK([for wchar_t], mutt_cv_wchar_t,
        AC_TRY_COMPILE([
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#e