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.Big5 zh_CN.GB2312 pt_BR eo gl sv da lt tr ja hu"

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, no, $PATH:$ac_aux_path_sendmail)

AC_DEFINE_UNQUOTED(SENDMAIL, "$ac_cv_path_SENDMAIL")

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)
                PGPAUX_TARGET=pgpring
                AM_CONDITIONAL(NEEDS_PGPEWRAP, true)
                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_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")
                ])

fi
AC_SUBST(OPS)

AC_SUBST(PGPAUX_TARGET)

AC_DEFINE_UNQUOTED(SUBVERSION, "$SUBVERSION")
AC_SUBST(SUBVERSION)

AC_PATH_PROG(ISPELL, ispell, no)
if test $ISPELL != no; then
        AC_DEFINE_UNQUOTED(ISPELL, "$ISPELL")
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)
        AC_DEFINE(HAVE_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])

	for cf_ncurses in ncurses ncursesw unknown
	do
		AC_CHECK_LIB($cf_ncurses,waddnwstr,[break])
	done
	if test "$cf_ncurses" = unknown; then cf_ncurses=ncurses; fi
        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)
		else
			AC_CHECK_HEADERS(ncurses.h)
		fi],

                [CF_CURSES_LIBS])

        old_LIBS="$LIBS"
        LIBS="$LIBS $MUTTLIBS"
        CF_CHECK_FUNCDECLS([#include <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)
        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_FUNC(snprintf, [AC_DEFINE(HAVE_SNPRINTF)], [mutt_cv_snprintf=yes])
AC_CHECK_FUNC(vsnprintf, [AC_DEFINE(HAVE_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, break, [AC_CHECK_LIB(x, chsize)])

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

dnl AIX may not have fchdir()
AC_CHECK_FUNCS(fchdir, [AC_DEFINE(HAVE_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)
        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")
        AC_DEFINE(HOMESPOOL)
        AC_DEFINE(USE_DOTLOCK)
        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")

        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)
        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)
                        AC_DEFINE(USE_SETGID)
                        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)
        DOTLOCK_TARGET="mutt_dotlock"
else
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS dotlock.o"
fi

AC_SUBST(DOTLOCK_TARGET)

AC_ARG_WITH(iconv, [  --with-iconv=DIR           Where libiconv is installed ],
       [mutt_cv_iconv=$withval
       if test "$mutt_cv_iconv" != yes -a \
                "$mutt_cv_iconv" != no -a \
                "$mutt_cv_iconv" != /usr; then
               CPPFLAGS="-I${mutt_cv_iconv}/include $CPPFLAGS"
               LDFLAGS="-L${mutt_cv_iconv}/lib $LDFLAGS"
       fi])

LIBICONV=

if test "$mutt_cv_iconv" != no; then

AC_CACHE_CHECK(for iconv, mutt_cv_func_iconv,
    [ mutt_cv_func_iconv=no
      mutt_cv_lib_iconv=no
      AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
        [iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);],
        mutt_cv_func_iconv=yes)
      if test "$mutt_cv_func_iconv" = no; then
        mutt_save_LIBS="$LIBS"
        LIBS="$LIBS -liconv"
        AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
          [iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);],
          mutt_cv_lib_iconv=yes
          mutt_cv_func_iconv=yes)
        LIBS="$mutt_save_LIBS"
      fi
    ])
if test "$mutt_cv_func_iconv" = no; then
  AC_MSG_ERROR(Unable to find iconv library)
fi
if test "$mutt_cv_lib_iconv" = yes; then
  LIBICONV="-liconv"
fi
AC_DEFINE(HAVE_ICONV)

AC_SUBST(LIBICONV)

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

else # "$mutt_cv_iconv" != no
  AC_DEFINE(ICONV_NONTRANS, 0)
fi

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")
        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)
                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)
                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))
        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)
        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)

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)
          LIBS="$saved_LIBS"
          MUTTLIBS="$MUTTLIBS -lssl -lcrypto"
          MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl.o"
          need_ssl=yes

          dnl Some systems avoid certain patent-encumbered SSL routines
          AC_CHECK_HEADER(openssl/rc5.h,,AC_DEFINE(NO_RC5))
          AC_CHECK_HEADER(openssl/idea.h,,AC_DEFINE(NO_IDEA))
          AC_CHECK_HEADER(openssl/rsa.h,,AC_DEFINE(NO_RSA))
        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)
          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
])

dnl -- end imap dependencies --

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)
          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)
          fi
         ])

AC_ARG_ENABLE(flock, [  --enable-flock             Use flock() to lock files],
        [if test $enableval = yes; then
                AC_DEFINE(USE_FLOCK)
        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)
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)
        fi])

AC_ARG_ENABLE(mailtool, [  --enable-mailtool          Enable Sun mailtool attachments support ],
        [if test x$enableval = xyes; then
                AC_DEFINE(SUN_ATTACHMENT)
        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)
        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)

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

MUTTLOCALEDIR=$mutt_cv_prefix/$DATADIRNAME/locale
AC_SUBST(MUTTLOCALEDIR)
AC_DEFINE_UNQUOTED(MUTTLOCALEDIR, "$MUTTLOCALEDIR")

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>
#endif
                ],
                [ wchar_t wc; return 0; ],
                mutt_cv_wchar_t=yes,
                mutt_cv_wchar_t=no))

if test "$mutt_cv_wchar_t" = no; then
        AC_DEFINE(wchar_t, int)
fi

AC_CACHE_CHECK([for wint_t], mutt_cv_wint_t,
        AC_TRY_COMPILE([
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
                ],
                [ wint_t wc; return 0; ],
                mutt_cv_wint_t=yes,