configure.in

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

AC_INIT(libvirt, 0.4.2)
AC_CONFIG_SRCDIR(src/libvirt.c)
AC_CONFIG_AUX_DIR(build-aux)
AM_CONFIG_HEADER(config.h)
dnl Make automake keep quiet about wildcards & other GNUmake-isms
AM_INIT_AUTOMAKE([-Wno-portability])
AC_CANONICAL_HOST

LIBVIRT_MAJOR_VERSION=`echo $VERSION | awk -F. '{print $1}'`
LIBVIRT_MINOR_VERSION=`echo $VERSION | awk -F. '{print $2}'`
LIBVIRT_MICRO_VERSION=`echo $VERSION | awk -F. '{print $3}'`
LIBVIRT_VERSION=$LIBVIRT_MAJOR_VERSION.$LIBVIRT_MINOR_VERSION.$LIBVIRT_MICRO_VERSION$LIBVIRT_MICRO_VERSION_SUFFIX
LIBVIRT_VERSION_INFO=`expr $LIBVIRT_MAJOR_VERSION + $LIBVIRT_MINOR_VERSION`:$LIBVIRT_MICRO_VERSION:$LIBVIRT_MINOR_VERSION
LIBVIRT_VERSION_NUMBER=`expr $LIBVIRT_MAJOR_VERSION \* 1000000 + $LIBVIRT_MINOR_VERSION \* 1000 + $LIBVIRT_MICRO_VERSION`

AC_SUBST(LIBVIRT_MAJOR_VERSION)
AC_SUBST(LIBVIRT_MINOR_VERSION)
AC_SUBST(LIBVIRT_MICRO_VERSION)
AC_SUBST(LIBVIRT_VERSION)
AC_SUBST(LIBVIRT_VERSION_INFO)
AC_SUBST(LIBVIRT_VERSION_NUMBER)

dnl Required minimum versions of all libs we depend on
LIBXML_REQUIRED="2.5.0"
GNUTLS_REQUIRED="1.0.25"
AVAHI_REQUIRED="0.6.0"
POLKIT_REQUIRED="0.6"
PARTED_REQUIRED="1.8.0"

dnl Checks for C compiler.
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_CPP

dnl gl_INIT uses m4_foreach_w, yet that is not defined in autoconf-2.59.
dnl In order to accommodate developers with such old tools, here's a
dnl replacement definition.
m4_ifndef([m4_foreach_w],
  [m4_define([m4_foreach_w],
    [m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])])])

gl_EARLY
gl_INIT

AM_PROG_CC_STDC
AC_C_CONST

dnl Make sure we have an ANSI compiler
AM_C_PROTOTYPES
test "x$U" != "x" && AC_MSG_ERROR(Compiler not ANSI compliant)

dnl Support building Win32 DLLs (must appear *before* AM_PROG_LIBTOOL)
AC_LIBTOOL_WIN32_DLL

AM_PROG_LIBTOOL

AM_PROG_CC_C_O

LIBVIRT_COMPILE_WARNINGS(maximum)

dnl Availability of various common functions (non-fatal if missing).
AC_CHECK_FUNCS([cfmakeraw regexec uname])

dnl Availability of various common headers (non-fatal if missing).
AC_CHECK_HEADERS([pwd.h paths.h sys/syslimits.h sys/utsname.h sys/wait.h winsock2.h])

dnl Where are the XDR functions?
dnl If portablexdr is installed, prefer that.
dnl Otherwise try -lrpc (Cygwin) -lxdr (some MinGW) or none (most Unix)
AC_CHECK_LIB([portablexdr],[xdrmem_create],[],[
	AC_SEARCH_LIBS([xdrmem_create],[rpc xdr])
	])

dnl Do we have rpcgen?
AC_PATH_PROG(RPCGEN, rpcgen, no)
AM_CONDITIONAL(RPCGEN, [test "x$ac_cv_path_RPCGEN" != "xno"])
dnl Is this GLIBC's buggy rpcgen?
AM_CONDITIONAL(GLIBC_RPCGEN,
	       [test "x$ac_cv_path_RPCGEN" != "xno" &&
	        $ac_cv_path_RPCGEN -t </dev/null >/dev/null 2>&1])

dnl pthread?
AC_CHECK_HEADER(pthread.h,
	AC_CHECK_LIB(pthread,pthread_join,[
		AC_DEFINE([HAVE_LIBPTHREAD],[],[Define if pthread (-lpthread)])
		AC_DEFINE([HAVE_PTHREAD_H],[],[Define if <pthread.h>])
	]))

dnl Miscellaneous external programs.
AC_PATH_PROG(RM, rm, /bin/rm)
AC_PATH_PROG(MV, mv, /bin/mv)
AC_PATH_PROG(TAR, tar, /bin/tar)
AC_PATH_PROG(XMLLINT, xmllint, /usr/bin/xmllint)
AC_PATH_PROG(XSLTPROC, xsltproc, /usr/bin/xsltproc)

dnl External programs that we can use if they are available.
dnl We will hard-code paths to these programs unless we cannot
dnl detect them, in which case we'll search for the program
dnl along the $PATH at runtime and fail if it's not there.
AC_PATH_PROG(DNSMASQ, dnsmasq, dnsmasq,
	[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
AC_PATH_PROG(BRCTL, brctl, brctl,
	[/sbin:/usr/sbin:/usr/local/sbin:$PATH])

AC_DEFINE_UNQUOTED([DNSMASQ],["$DNSMASQ"],
        [Location or name of the dnsmasq program])
AC_DEFINE_UNQUOTED([BRCTL],["$BRCTL"],
        [Location or name of the brctl program (see bridge-utils)])

dnl Specific dir for HTML output ?
AC_ARG_WITH(html-dir, AC_HELP_STRING([--with-html-dir=path],
            [path to base html directory, default $datadir/doc/html]),
            [HTML_DIR=$withval], [HTML_DIR='$(datadir)/doc'])

AC_ARG_WITH(html-subdir, AC_HELP_STRING([--with-html-subdir=path],
            [directory used under html-dir, default $PACKAGE-$VERSION/html]),
            [test "x$withval" != "x" && HTML_DIR="$HTML_DIR/$withval"],
            [HTML_DIR="$HTML_DIR/\$(PACKAGE)-\$(VERSION)/html"])
AC_SUBST(HTML_DIR)

dnl if --prefix is /usr, don't use /usr/var for localstatedir
dnl or /usr/etc for sysconfdir
dnl as this makes a lot of things break in testing situations

if test "$prefix" = "/usr" -a "$localstatedir" = '${prefix}/var' ; then
    localstatedir='/var'
fi
if test "$prefix" = "/usr" -a "$sysconfdir" = '${prefix}/etc' ; then
    sysconfdir='/etc'
fi


dnl Allow to build without Xen, QEMU/KVM, test or remote driver
AC_ARG_WITH(xen,
[  --with-xen              add XEN support (on)],[],[with_xen=yes])
AC_ARG_WITH(qemu,
[  --with-qemu             add QEMU/KVM support (on)],[],[with_qemu=yes])
AC_ARG_WITH(openvz,
[  --with-openvz           add OpenVZ support (off)],[],[with_openvz=no])
AC_ARG_WITH(lxc,
[  --with-lxc              add Linux Container support (off)],[],[with_lxc=no])
AC_ARG_WITH(test,
[  --with-test             add test driver support (on)],[],[with_test=yes])
AC_ARG_WITH(remote,
[  --with-remote           add remote driver support (on)],[],[with_remote=yes])
AC_ARG_WITH(libvirtd,
[  --with-libvirtd         add libvirtd support (on)],[],[with_libvirtd=yes])

dnl
dnl specific tests to setup DV devel environments with debug etc ...
dnl
if [[ "${LOGNAME}" = "veillard" -a "`pwd`" = "/u/veillard/libvirt" ]] ; then
    STATIC_BINARIES="-static"
else
    STATIC_BINARIES=
fi
AC_SUBST(STATIC_BINARIES)

dnl --enable-debug=(yes|no)
AC_ARG_ENABLE(debug,
              AC_HELP_STRING([--enable-debug=no/yes],
                             [enable debugging output]),[],[enable_debug=yes])
if test x"$enable_debug" = x"yes"; then
   AC_DEFINE(ENABLE_DEBUG, [], [whether debugging is enabled])
fi


AC_MSG_CHECKING([where to write libvirtd PID file])
AC_ARG_WITH(remote-pid-file, AC_HELP_STRING([--with-remote-pid-file=[pidfile|none]], [PID file for libvirtd]))
if test "x$with_remote_pid_file" == "x" ; then
   REMOTE_PID_FILE="$localstatedir/run/libvirtd.pid"
elif test "x$with_remote_pid_file" == "xnone" ; then
   REMOTE_PID_FILE=""
else
   REMOTE_PID_FILE="$with_remote_pid_file"
fi
AC_SUBST(REMOTE_PID_FILE)
AC_MSG_RESULT($REMOTE_PID_FILE)

dnl
dnl init script flavor
dnl
AC_MSG_CHECKING([for init script flavor])
AC_ARG_WITH(init-script,
            AC_HELP_STRING([--with-init-scripts=[redhat|auto|none]],
                           [Style of init scripts to install (defaults to auto)]))
if test "x$with_init_scripts" = "x" -o "x$with_init_scripts" = "xauto"; then
    if test -f /etc/redhat-release ; then
        with_init_scripts=redhat
    else
        with_init_scripts=none
    fi
fi
AM_CONDITIONAL(LIBVIRT_INIT_SCRIPTS_RED_HAT, test x$with_init_scripts = xredhat)
AC_MSG_RESULT($with_init_scripts)

dnl
dnl ensure that Fedora's system-config-firewall knows
dnl about libvirt's iptables rules
dnl
AC_ARG_ENABLE(iptables-lokkit,
              AC_HELP_STRING([--enable-iptables-lokkit=no/yes/check],
                             [enable registering libvirt's iptables rules with Fedora's lokkit]),
                             [],[enable_iptables_lokkit=check])
if test x"$enable_iptables_lokkit" != x"no"; then
   AC_PATH_PROG(LOKKIT_PATH, lokkit, [], [/usr/sbin:$PATH])
fi

if test x"$enable_iptables_lokkit" = x"yes" -a x"$LOKKIT_PATH" = x; then
   AC_MSG_ERROR([Cannot find lokkit and --enable-iptables-lokkit specified])
fi

if test x"$LOKKIT_PATH" != x; then
   AC_DEFINE(ENABLE_IPTABLES_LOKKIT, [], [whether support for Fedora's lokkit is enabled])
   AC_DEFINE_UNQUOTED(LOKKIT_PATH, "$LOKKIT_PATH", [path to lokkit binary])
fi

AC_PATH_PROG(IPTABLES_PATH, iptables, /sbin/iptables, [/usr/sbin:$PATH])
AC_DEFINE_UNQUOTED(IPTABLES_PATH, "$IPTABLES_PATH", [path to iptables binary])

dnl
dnl Specify the xen-distribution directory to be able to compile on a
dnl non-xenified host
dnl
AC_ARG_WITH(xen-distdir, AC_HELP_STRING([--with-xen-distdir=path],
            [distribution directory of Xen, default /usr]))
if test "x$with_xen_distdir" != "x"
then
CPPFLAGS="$CPPFLAGS -I$withval/install/usr/include"
LDFLAGS="$LDFLAGS -L$withval/install/usr/lib"
fi

LIBVIRT_FEATURES=
WITH_XEN=0

if test "$with_openvz" = "yes" ; then
    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_OPENVZ"
fi
if test "$with_lxc" = "yes" ; then
    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_LXC"
fi
if test "$with_qemu" = "yes" ; then
    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_QEMU"
fi

if test "$with_test" = "yes" ; then
    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_TEST"
fi

if test "$with_remote" = "yes" ; then
    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_REMOTE"
fi

if test "$with_xen" = "yes" ; then
    dnl search for the Xen store library
    AC_SEARCH_LIBS(xs_read, [xenstore],
                   [WITH_XEN=1],
                   [AC_MSG_RESULT([Xen store library not found])])
    if test "$WITH_XEN" != "0" ; then
        LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_XEN"
    fi

    AC_CHECK_HEADERS(xen/xen.h xen/version.h xen/dom0_ops.h,,[
	AC_MSG_ERROR([Cannot find standard Xen headers. Is xen-devel installed?])
    ],
[#include <stdio.h>
#include <stdint.h>
])

    dnl Search for the location of <xen/{linux,sys}/privcmd.h>.
    AC_CHECK_HEADERS(xen/sys/privcmd.h,,[
	AC_CHECK_HEADERS(xen/linux/privcmd.h,,[
	    AC_MSG_ERROR([Cannot find header file <xen/linux/privcmd.h> or <xen/sys/privcmd.h>.  Is xen-devel installed?])
	],
[#include <stdio.h>
#include <stdint.h>
#include <xen/xen.h>
])
    ],
[#include <stdio.h>
#include <stdint.h>
#include <xen/xen.h>
])
fi

dnl
dnl check for kernel headers required by qemud/bridge.c
dnl
if test "$with_qemu" = "yes" ; then
  AC_CHECK_HEADERS(linux/param.h linux/sockios.h linux/if_bridge.h linux/if_tun.h,,
                   AC_MSG_ERROR([You must install kernel-headers in order to compile libvirt]))
fi

dnl Need to test if pkg-config exists
PKG_PROG_PKG_CONFIG

dnl ==========================================================================
dnl find libxml2 library, borrowed from xmlsec
dnl ==========================================================================
LIBXML_CONFIG="xml2-config"
LIBXML_CFLAGS=""
LIBXML_LIBS=""
LIBXML_FOUND="no"

AC_ARG_WITH(libxml, [  --with-libxml=[PFX]       libxml2 location])
if test "x$with_libxml" = "xno" ; then
    AC_MSG_CHECKING(for libxml2 libraries >= $LIBXML_REQUIRED)
    AC_MSG_ERROR(libxml2 >= $LIBXML_REQUIRED is required for libvirt)
elif test "x$with_libxml" = "x" -a "x$PKG_CONFIG" != "x" ; then
    PKG_CHECK_MODULES(LIBXML, libxml-2.0 >= $LIBXML_REQUIRED, [LIBXML_FOUND=yes], [LIBXML_FOUND=no])
fi
if test "$LIBXML_FOUND" = "no" ; then
    if test "x$with_libxml" != "x" ; then
	LIBXML_CONFIG=$with_libxml/bin/$LIBXML_CONFIG
    fi
    AC_MSG_CHECKING(libxml2 $LIBXML_CONFIG >= $LIBXML_REQUIRED )
    if ! $LIBXML_CONFIG --version > /dev/null 2>&1 ; then
	AC_MSG_ERROR(Could not find libxml2 anywhere (see config.log for details).)
    fi
    vers=`$LIBXML_CONFIG --version | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
    minvers=`echo $LIBXML_REQUIRED | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
    if test "$vers" -ge "$minvers" ; then
        LIBXML_LIBS="`$LIBXML_CONFIG --libs`"
        LIBXML_CFLAGS="`$LIBXML_CONFIG --cflags`"
	LIBXML_FOUND="yes"
        AC_MSG_RESULT(yes)
    else
        AC_MSG_ERROR(
          [You need at least libxml2 $LIBXML_REQUIRED for this version of libvirt])
    fi
fi

AC_SUBST(LIBXML_CFLAGS)
AC_SUBST(LIBXML_LIBS)

dnl xmlURI structure has query_raw?
old_cflags="$CFLAGS"
old_ldflags="$LDFLAGS"
CFLAGS="$CFLAGS $LIBXML_CFLAGS"
LDFLAGS="$LDFLAGS $LIBXML_LIBS"
AC_CHECK_MEMBER(struct _xmlURI.query_raw,
		[AC_DEFINE(HAVE_XMLURI_QUERY_RAW, [], [Have query_raw field in libxml2 xmlURI structure])],,
		[#include <libxml/uri.h>])
CFLAGS="$old_cflags"
LDFLAGS="$old_ldflags"

dnl GnuTLS library
GNUTLS_CFLAGS=
GNUTLS_LIBS=
GNUTLS_FOUND=no
if test -z "$PKG_CONFIG" ; then
  PKG_CHECK_MODULES(GNUTLS, gnutls >= $GNUTLS_REQUIRED,
     [GNUTLS_FOUND=yes], [GNUTLS_FOUND=no])
fi
if test "$GNUTLS_FOUND" = "no"; then
  AC_CHECK_HEADER([gnutls/gnutls.h],
    [],
    AC_MSG_ERROR(
      [You must install the GnuTLS development package in order to compile libvirt]))
  old_libs="$LIBS"
  AC_CHECK_LIB(gnutls, gnutls_handshake,
    [],
    [AC_MSG_ERROR(
       [You must install the GnuTLS library in order to compile and run libvirt])],
    [-lgcrypt])
  GNUTLS_LIBS=$LIBS
  LIBS="$old_libs"
fi

AC_SUBST(GNUTLS_CFLAGS)
AC_SUBST(GNUTLS_LIBS)

dnl Old versions of GnuTLS uses types like 'gnutls_session' instead
dnl of 'gnutls_session_t'.  Try to detect this type if defined so
dnl that we can offer backwards compatibility.
old_cflags="$CFLAGS"
old_ldflags="$LDFLAGS"
CFLAGS="$CFLAGS $GNUTLS_CFLAGS"
LDFLAGS="$LDFLAGS $GNUTLS_LIBS"
AC_CHECK_TYPE(gnutls_session,
	AC_DEFINE(GNUTLS_1_0_COMPAT,[],
		[enable GnuTLS 1.0 compatibility macros]),,
	[#include <gnutls/gnutls.h>])
CFLAGS="$old_cflags"
LDFLAGS="$old_ldflags"


dnl Cyrus SASL
AC_ARG_WITH(sasl,
  [  --with-sasl         use cyrus SASL for authentication],
  [],
  [with_sasl=check])

SASL_CFLAGS=
SASL_LIBS=
if test "x$with_sasl" != "xno"; then
  if test "x$with_sasl" != "xyes" -a "x$with_sasl" != "xcheck"; then
    SASL_CFLAGS="-I$with_sasl"
    SASL_LIBS="-L$with_sasl"
  fi
  old_cflags="$CFLAGS"
  old_libs="$LIBS"
  CFLAGS="$CFLAGS $SASL_CFLAGS"
  LIBS="$LIBS $SASL_LIBS"
  AC_CHECK_HEADER([sasl/sasl.h],[],[
    if test "x$with_sasl" != "xcheck" ; then
        with_sasl=no
    else
        AC_MSG_ERROR(
          [You must install the Cyrus SASL development package in order to compile libvirt])
    fi])
  if test "x$with_sasl" != "xno" ; then
    AC_CHECK_LIB(sasl2, sasl_client_init,[with_sasl=yes],[
      if test "x$with_sasl" = "xcheck" ; then
          with_sasl=no
      else
          AC_MSG_ERROR(
            [You must install the Cyrus SASL library in order to compile and run libvirt])
      fi])
  fi
  CFLAGS="$old_cflags"
  LIBS="$old_libs"
  SASL_LIBS="$SASL_LIBS -lsasl2"
  if test "x$with_sasl" = "xyes" ; then
    AC_DEFINE_UNQUOTED(HAVE_SASL, 1,
      [whether Cyrus SASL is available for authentication])
  fi
fi
AM_CONDITIONAL(HAVE_SASL, [test "x$with_sasl" = "xyes"])
AC_SUBST(SASL_CFLAGS)
AC_SUBST(SASL_LIBS)


dnl PolicyKit library
POLKIT_CFLAGS=
POLKIT_LIBS=
AC_ARG_WITH(polkit,
  [  --with-polkit         use PolicyKit for UNIX socket access checks],
  [],
  [with_polkit=check])

if test "x$with_polkit" = "xyes" -o "x$with_polkit" = "xcheck"; then
  PKG_CHECK_MODULES(POLKIT, polkit-dbus >= $POLKIT_REQUIRED,
    [with_polkit=yes], [
    if test "x$with_polkit" = "xcheck" ; then
       with_polkit=no
    else
       AC_MSG_ERROR(
         [You must install PolicyKit >= $POLKIT_REQUIRED to compile libvirt])
    fi
  ])
  if test "x$with_polkit" = "xyes" ; then
    AC_DEFINE_UNQUOTED(HAVE_POLKIT, 1,
      [use PolicyKit for UNIX socket access checks])

    old_CFLAGS=$CFLAGS
    old_LDFLAGS=$LDFLAGS
    CFLAGS="$CFLAGS $POLKIT_CFLAGS"
    LDFLAGS="$LDFLAGS $POLKIT_LIBS"
    AC_CHECK_FUNCS(polkit_context_is_caller_authorized)
    CFLAGS="$old_CFLAGS"
    LDFLAGS="$old_LDFLAGS"

    AC_PATH_PROG(POLKIT_AUTH, polkit-auth)
    if test "x$POLKIT_AUTH" != "x"; then
      AC_DEFINE_UNQUOTED([POLKIT_AUTH],["$POLKIT_AUTH"],[Location of polkit-auth program])
    fi
  fi
fi
AM_CONDITIONAL(HAVE_POLKIT, [test "x$with_polkit" = "xyes"])
AC_SUBST(POLKIT_CFLAGS)
AC_SUBST(POLKIT_LIBS)

dnl Avahi library
AC_ARG_WITH(avahi,
  [  --with-avahi         use avahi to advertise remote daemon],
  [],
  [with_avahi=check])

AVAHI_CFLAGS=
AVAHI_LIBS=
if test "x$with_avahi" = "xyes" -o "x$with_avahi" = "xcheck"; then
  PKG_CHECK_MODULES(AVAHI, avahi-client >= $AVAHI_REQUIRED,
    [with_avahi=yes], [
    if test "x$with_avahi" = "xcheck" ; then
       with_avahi=no
    else
       AC_MSG_ERROR(
         [You must install Avahi >= $AVAHI_REQUIRED to compile libvirt])
    fi
  ])
  if test "x$with_avahi" = "xyes" ; then
    AC_DEFINE_UNQUOTED(HAVE_AVAHI, 1,
      [whether Avahi is used to broadcast server presense])
  fi
fi
AM_CONDITIONAL(HAVE_AVAHI, [test "x$with_avahi" = "xyes"])
AC_SUBST(AVAHI_CFLAGS)
AC_SUBST(AVAHI_LIBS)

dnl SELinux
AC_ARG_WITH(selinux,
  [  --with-selinux         use SELinux to manage security],
  [],
  [with_selinux=check])

SELINUX_CFLAGS=
SELINUX_LIBS=
if test "$with_selinux" != "no"; then
  old_cflags="$CFLAGS"
  old_libs="$LIBS"
  if test "$with_selinux" = "check"; then
    AC_CHECK_HEADER([selinux/selinux.h],[],[with_selinux=no])
    AC_CHECK_LIB(selinux, fgetfilecon,[],[with_selinux=no])
    if test "$with_selinux" != "no"; then
      with_selinux="yes"
    fi
  else
    AC_CHECK_HEADER([selinux/selinux.h],[],
       [AC_MSG_ERROR([You must install the SELinux development package in order to compile libvirt])])
    AC_CHECK_LIB(selinux, fgetfilecon,[],
       [AC_MSG_ERROR([You must install the SELinux development package in order to compile and run libvirt])])
  fi
  CFLAGS="$old_cflags"
  LIBS="$old_libs"
fi
if test "$with_selinux" = "yes"; then
  SELINUX_LIBS="-lselinux"
  AC_DEFINE_UNQUOTED(HAVE_SELINUX, 1, [whether SELinux is available for security])
fi
AM_CONDITIONAL(HAVE_SELINUX, [test "$with_selinux" != "no"])
AC_SUBST(SELINUX_CFLAGS)
AC_SUBST(SELINUX_LIBS)

dnl NUMA lib
AC_ARG_WITH(numactl,
  [  --with-numactl         use numactl for host topology info],
  [],
  [with_numactl=check])

NUMACTL_CFLAGS=
NUMACTL_LIBS=
if test "$with_qemu" = "yes" -a "$with_numactl" != "no"; then
  old_cflags="$CFLAGS"
  old_libs="$LIBS"
  if test "$with_numactl" = "check"; then
    AC_CHECK_HEADER([numa.h],[],[with_numactl=no])
    AC_CHECK_LIB(numa, numa_available,[],[with_numactl=no])
    if test "$with_numactl" != "no"; then
      with_numactl="yes"
    fi
  else
    AC_CHECK_HEADER([numa.h],[],
       [AC_MSG_ERROR([You must install the numactl development package in order to compile libvirt])])
    AC_CHECK_LIB(numa, numa_available,[],
       [AC_MSG_ERROR([You must install the numactl development package in order to compile and run libvirt])])
  fi
  CFLAGS="$old_cflags"
  LIBS="$old_libs"
fi
if test "$with_numactl" = "yes"; then
  NUMACTL_LIBS="-lnuma"
  AC_DEFINE_UNQUOTED(HAVE_NUMACTL, 1, [whether Numactl is available for security])
fi
AM_CONDITIONAL(HAVE_NUMACTL, [test "$with_numactl" != "no"])
AC_SUBST(NUMACTL_CFLAGS)
AC_SUBST(NUMACTL_LIBS)

dnl virsh libraries
AC_CHECK_HEADERS([readline/readline.h])

# Check for readline.
AC_CHECK_LIB(readline, readline,
	[lv_use_readline=yes; VIRSH_LIBS="$VIRSH_LIBS -lreadline"],
	[lv_use_readline=no])

# If the above test failed, it may simply be that -lreadline requires
# some termcap-related code, e.g., from one of the following libraries.
# See if adding one of them to LIBS helps.
if test $lv_use_readline = no; then
    lv_saved_libs=$LIBS
    LIBS=
    AC_SEARCH_LIBS(tgetent, ncurses curses termcap termlib)
    case $LIBS in
      no*) ;;  # handle "no" and "none required"
      *) # anything else is a -lLIBRARY
	# Now, check for -lreadline again, also using $LIBS.
	# Note: this time we use a different function, so that
	# we don't get a cached "no" result.
	AC_CHECK_LIB(readline, rl_initialize,
		[lv_use_readline=yes
		 VIRSH_LIBS="$VIRSH_LIBS -lreadline $LIBS"],,
		[$LIBS])
	;;
    esac
    test $lv_use_readline = no &&
	AC_MSG_WARN([readline library not found])
    LIBS=$lv_saved_libs
fi

if test $lv_use_readline = yes; then
    AC_DEFINE_UNQUOTED([USE_READLINE], 1,
		       [whether virsh can use readline])
    READLINE_CFLAGS=-DUSE_READLINE
else
    READLINE_CFLAGS=
fi
AC_SUBST(READLINE_CFLAGS)
AC_SUBST(VIRSH_LIBS)

AC_SUBST(WITH_XEN)
AC_SUBST(LIBVIRT_FEATURES)


dnl
dnl Storage driver checks
dnl

AC_ARG_WITH(storage-fs,
[  --with-storage-fs           with FileSystem backend for the storage driver (on)],[],[with_storage_fs=check])
AC_ARG_WITH(storage-lvm,
[  --with-storage-lvm          with LVM backend for the storage driver (on)],[],[with_storage_lvm=check])
AC_ARG_WITH(storage-iscsi,
[  --with-storage-iscsi        with iSCSI backend for the storage driver (on)],[],[with_storage_iscsi=check])
AC_ARG_WITH(storage-disk,
[  --with-storage-disk         with GPartd Disk backend for the storage driver (on)],[],[with_storage_disk=check])

if test "$with_storage_fs" = "yes" -o "$with_storage_fs" = "check"; then
  AC_PATH_PROG(MOUNT, [mount], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(UMOUNT, [umount], [], [$PATH:/sbin:/usr/sbin])
  if test "$with_storage_fs" = "yes" ; then
    if test -z "$MOUNT" ; then AC_MSG_ERROR(We need mount for FS storage driver) ; fi
    if test -z "$UMOUNT" ; then AC_MSG_ERROR(We need mount for FS storage driver) ; fi
  else
    if test -z "$MOUNT" ; then with_storage_fs=no ; fi
    if test -z "$UMOUNT" ; then with_storage_fs=no ; fi

    if test "$with_storage_fs" = "check" ; then with_storage_fs=yes ; fi
  fi

  if test "$with_storage_fs" = "yes" ; then
    AC_DEFINE_UNQUOTED(WITH_STORAGE_FS, 1, [whether FS backend for storage driver is enabled])
    AC_DEFINE_UNQUOTED([MOUNT],["$MOUNT"],
        [Location or name of the mount program])
    AC_DEFINE_UNQUOTED([UMOUNT],["$UMOUNT"],
        [Location or name of the mount program])
  fi
fi
AM_CONDITIONAL(WITH_STORAGE_FS, [test "$with_storage_fs" = "yes"])

AC_PATH_PROG(QEMU_IMG, [qemu-img], [], [$PATH:/sbin:/usr/sbin:/bin:/usr/bin])
if test -n "$QEMU_IMG" ; then
  AC_DEFINE_UNQUOTED(HAVE_QEMU_IMG, 1, [whether qemu-img is available for non-raw files])
  AC_DEFINE_UNQUOTED([QEMU_IMG],["$QEMU_IMG"],
      [Location or name of the qemu-img program])
fi

AC_PATH_PROG(QCOW_CREATE, [qcow-create], [], [$PATH:/sbin:/usr/sbin:/bin:/usr/bin])
if test -n "$QCOW_CREATE" ; then
  AC_DEFINE_UNQUOTED(HAVE_QCOW_CREATE, 1, [whether qcow-create is available for non-raw files])
  AC_DEFINE_UNQUOTED([QCOW_CREATE],["$QCOW_CREATE"],
      [Location or name of the qcow-create program])
fi


if test "$with_storage_lvm" = "yes" -o "$with_storage_lvm" = "check"; then
  AC_PATH_PROG(PVCREATE, [pvcreate], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(VGCREATE, [vgcreate], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(LVCREATE, [lvcreate], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(PVREMOVE, [pvremove], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(VGREMOVE, [vgremove], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(LVREMOVE, [lvremove], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(VGCHANGE, [vgchange], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(PVS, [pvs], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(VGS, [vgs], [], [$PATH:/sbin:/usr/sbin])
  AC_PATH_PROG(LVS, [lvs], [], [$PATH:/sbin:/usr/sbin])

  if test "$with_storage_lvm" = "yes" ; then
    if test -z "$PVCREATE" ; then AC_MSG_ERROR(We need pvcreate for LVM storage driver) ; fi
    if test -z "$VGCREATE" ; then AC_MSG_ERROR(We need vgcreate for LVM storage driver) ; fi
    if test -z "$LVCREATE" ; then AC_MSG_ERROR(We need lvcreate for LVM storage driver) ; fi
    if test -z "$PVREMOVE" ; then AC_MSG_ERROR(We need pvremove for LVM storage driver) ; fi
    if test -z "$VGREMOVE" ; then AC_MSG_ERROR(We need vgremove for LVM storage driver) ; fi
    if test -z "$LVREMOVE" ; then AC_MSG_ERROR(We need lvremove for LVM storage driver) ; fi
    if test -z "$VGCHANGE" ; then AC_MSG_ERROR(We need vgchange for LVM storage driver) ; fi
    if test -z "$PVS" ; then AC_MSG_ERROR(We need pvs for LVM storage driver) ; fi
    if test -z "$VGS" ; then AC_MSG_ERROR(We need vgs for LVM storage driver) ; fi
    if test -z "$LVS" ; then AC_MSG_ERROR(We need lvs for LVM storage driver) ; fi
  else
    if test -z "$PVCREATE" ; then with_storage_lvm=no ; fi
    if test -z "$VGCREATE" ; then with_storage_lvm=no ; fi
    if test -z "$LVCREATE" ; then with_storage_lvm=no ; fi
    if test -z "$PVREMOVE" ; then with_storage_lvm=no ; fi
    if test -z "$VGREMOVE" ; then with_storage_lvm=no ; fi
    if test -z "$LVREMOVE" ; then with_storage_lvm=no ; fi
    if test -z "VGCHANGE" ; then with_storage_lvm=no ; fi
    if test -z "$PVS" ; then with_storage_lvm=no ; fi
    if test -z "$VGS" ; then with_storage_lvm=no ; fi
    if test -z "$LVS" ; then with_storage_lvm=no ; fi

    if test "$with_storage_lvm" = "check" ; then with_storage_lvm=yes ; fi
  fi

  if test "$with_storage_lvm" = "yes" ; then
    AC_DEFINE_UNQUOTED(WITH_STORAGE_LVM, 1, [whether LVM backend for storage driver is enabled])
    AC_DEFINE_UNQUOTED([PVCREATE],["$PVCREATE"],[Location of pvcreate program])
    AC_DEFINE_UNQUOTED([VGCREATE],["$VGCREATE"],[Location of vgcreate program])
    AC_DEFINE_UNQUOTED([LVCREATE],["$LVCREATE"],[Location of lvcreate program])
    AC_DEFINE_UNQUOTED([PVREMOVE],["$PVREMOVE"],[Location of pvcreate program])
    AC_DEFINE_UNQUOTED([VGREMOVE],["$VGREMOVE"],[Location of vgcreate program])
    AC_DEFINE_UNQUOTED([LVREMOVE],["$LVREMOVE"],[Location of lvcreate program])
    AC_DEFINE_UNQUOTED([VGCHANGE],["$VGCHANGE"],[Location of vgchange program])
    AC_DEFINE_UNQUOTED([PVS],["$PVS"],[Location of pvs program])
    AC_DEFINE_UNQUOTED([VGS],["$VGS"],[Location of vgs program])
    AC_DEFINE_UNQUOTED([LVS],["$LVS"],[Location of lvs program])
  fi
fi
AM_CONDITIONAL(WITH_STORAGE_LVM, [test "$with_storage_lvm" = "yes"])



if test "$with_storage_iscsi" = "yes" -o "$with_storage_iscsi" = "check"; then
  AC_PATH_PROG(ISCSIADM, [iscsiadm], [], [$PATH:/sbin:/usr/sbin])
  if test "$with_storage_iscsi" = "yes" ; then
    if test -z "$ISCSIADM" ; then AC_MSG_ERROR(We need iscsiadm for iSCSI storage driver) ; fi
  else
    if test -z "$ISCSIADM" ; then with_storage_iscsi=no ; fi

    if test "$with_storage_iscsi" = "check" ; then with_storage_iscsi=yes ; fi
  fi

  if test "$with_storage_iscsi" = "yes" ; then
    AC_DEFINE_UNQUOTED(WITH_STORAGE_ISCSI, 1, [whether iSCSI backend for storage driver is enabled])
    AC_DEFINE_UNQUOTED([ISCSIADM],["$ISCSIADM"],[Location of iscsiadm program])
  fi
fi
AM_CONDITIONAL(WITH_STORAGE_ISCSI, [test "$with_storage_iscsi" = "yes"])



LIBPARTED_CFLAGS=
LIBPARTED_LIBS=
if test "$with_storage_disk" = "yes" -o "$with_storage_disk" = "check"; then
  AC_PATH_PROG(PARTED, [parted], [], [$PATH:/sbin:/usr/sbin])
  if test -z "$PARTED" ; then with_storage_disk=no ; fi

  PARTED_FOUND=yes
  if test "$with_storage_disk" != "no" -a "x$PKG_CONFIG" != "x" ; then
    PKG_CHECK_MODULES(LIBPARTED, libparted >= $PARTED_REQUIRED, [], [PARTED_FOUND=no])
  fi
  if test "$PARTED_FOUND" = "no"; then
    # RHEL-5 vintage parted is missing pkg-config files
    save_LIBS="$LIBS"
    save_CFLAGS="$CFLAGS"
    PARTED_FOUND=yes
    AC_CHECK_HEADER(parted/parted.h,,[PARTED_FOUND=no])
    AC_CHECK_LIB(uuid, uuid_generate,,[PARTED_FOUND=no])
    AC_CHECK_LIB(parted, ped_device_read,,[PARTED_FOUND=no])
    LIBPARTED_LIBS="-luuid -lparted"
    LIBS="$save_LIBS"
    CFLAGS="$save_CFLAGS"
  fi

  if test "$PARTED_FOUND" = "no" ; then
    if test "$with_storage_disk" = "yes" ; then
      AC_MSG_ERROR(We need parted for disk storage driver)
    else
      with_storage_disk=no
    fi
  else
    with_storage_disk=yes
  fi

  if test "$with_storage_disk" = "yes"; then
    AC_DEFINE_UNQUOTED(WITH_STORAGE_DISK, 1, [whether Disk backend for storage driver is enabled])
    AC_DEFINE_UNQUOTED([PARTED],["$PARTED"], [Location or name of the parted program])
  fi
fi
AM_CONDITIONAL(WITH_STORAGE_DISK, [test "$with_storage_disk" = "yes"])
AC_SUBST(LIBPARTED_CFLAGS)
AC_SUBST(LIBPARTED_LIBS)


dnl
dnl check for python
dnl

PYTHON_VERSION=
PYTHON_INCLUDES=
PYTHON_SITE_PACKAGES=
PYTHON_TESTS=
pythondir=
if test "$with_python" != "no" ; then
    if test -x "$with_python/bin/python"
    then
        echo Found python in $with_python/bin/python
        PYTHON="$with_python/bin/python"
    else
	if test -x "$with_python"
	then
	    echo Found python in $with_python
	    PYTHON="$with_python"
	else
	    if test -x "$PYTHON"
	    then
	        echo Found python in environment PYTHON=$PYTHON
		with_python=`$PYTHON -c "import sys; print sys.exec_prefix"`
	    else
		AC_PATH_PROG(PYTHON, python python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5)
	    fi
	fi
    fi
    if test "$PYTHON" != ""
    then
        PYTHON_VERSION=`$PYTHON -c "import sys; print sys.version[[0:3]]"`
	echo Found Python version $PYTHON_VERSION
    fi
    if test "$PYTHON_VERSION" != ""
    then
	if test -r $with_python/include/python$PYTHON_VERSION/Python.h -a \
	   -d $with_python/lib/python$PYTHON_VERSION/site-packages
	then
	    PYTHON_INCLUDES=$with_python/include/python$PYTHON_VERSION
	    PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
	else
	    if test -r $prefix/include/python$PYTHON_VERSION/Python.h
	    then
	        PYTHON_INCLUDES=$prefix/include/python$PYTHON_VERSION
	        PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
	    else
		if test -r /usr/include/python$PYTHON_VERSION/Python.h
		then
		    PYTHON_INCLUDES=/usr/include/python$PYTHON_VERSION
	            PYTHON_SITE_PACKAGES=$libdir/python$PYTHON_VERSION/site-packages
		else
		    echo could not find python$PYTHON_VERSION/Python.h
		fi
	    fi
	    if test ! -d "$PYTHON_SITE_PACKAGES"
	    then
		    PYTHON_SITE_PACKAGES=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_lib()"`
	    fi
	fi
    fi
    if test "$with_python" != ""
    then
        pythondir='$(PYTHON_SITE_PACKAGES)'
    else
        pythondir='$(libdir)/python$(PYTHON_VERSION)/site-packages'
    fi
else
    PYTHON=
fi
AM_CONDITIONAL(WITH_PYTHON, test "$PYTHON_INCLUDES" != "")
AC_SUBST(pythondir)
AC_SUBST(PYTHON_VERSION)
AC_SUBST(PYTHON_INCLUDES)
AC_SUBST(PYTHON_SITE_PACKAGES)

AC_MSG_CHECKING([whether this host is running a Xen kernel])
RUNNING_XEN=
if test -d /proc/sys/xen
then
    RUNNING_XEN=yes
else
    RUNNING_XEN=no
fi
AC_MSG_RESULT($RUNNING_XEN)

AC_MSG_CHECKING([If XenD UNIX socket /var/run/xend/xmlrpc.sock is accessible])
RUNNING_XEND=
if test -S /var/run/xend/xmlrpc.sock
then
    RUNNING_XEND=yes
else
    RUNNING_XEND=no
fi
AC_MSG_RESULT($RUNNING_XEND)

AM_CONDITIONAL(ENABLE_XEN_TESTS, [test "$RUNNING_XEN" != "no" -a "$RUNNING_XEND" != "no"])

AC_ARG_ENABLE(test-coverage,
[  --enable-test-coverage   turn on code coverage instrumentation],
[case "${enableval}" in
   yes|no) ;;
   *)      AC_MSG_ERROR([bad value ${enableval} for test-coverage option]) ;;
 esac],
              [enableval=no])

if test "${enableval}" = yes; then
  gl_COMPILER_FLAGS(-fprofile-arcs)
  gl_COMPILER_FLAGS(-ftest-coverage)
  AC_SUBST([COVERAGE_CFLAGS], [$COMPILER_FLAGS])
  AC_SUBST([COVERAGE_LDFLAGS], [$COMPILER_FLAGS])
  COMPILER_FLAGS=
fi

dnl Enable building the proxy?

AC_ARG_WITH(xen-proxy,
[  --with-xen-proxy              add XEN setuid proxy support (on)],[],[with_xen_proxy=auto])

AC_MSG_CHECKING([if Xen setuid proxy is needed])
if test "$with_xen_proxy" = "auto"; then
  if test "$with_polkit" = "yes"; then
    with_xen_proxy="no"
  else
    with_xen_proxy="yes"
  fi
fi
if test "$with_xen" != "yes"; then
  with_xen_proxy="no"
fi
AC_MSG_RESULT([$with_xen_proxy])

AM_CONDITIONAL(WITH_PROXY,[test "$with_xen_proxy" = "yes"])
if test "$with_xen_proxy" = "yes"; then
  AC_DEFINE(WITH_PROXY, 1, [Whether Xen proxy is enabled])
fi

dnl Enable building libvirtd?
AM_CONDITIONAL(WITH_LIBVIRTD,[test "x$with_libvirtd" = "xyes"])

dnl Check for gettext
AM_GNU_GETTEXT_VERSION([0.14.1])
AM_GNU_GETTEXT([external])
if test -d po
then
    ALL_LINGUAS=`(cd po > /dev/null && ls *.po) | sed 's+\.po$++'`
else
    ALL_LINGUAS="af am ar as be bg bn_IN bn ca cs cy da de el en_GB es et eu_ES fa fi fr gl gu he hi hr hu hy id is it ja ka kn ko ku lo lt lv mk ml mr ms my nb nl nn no nso or pa pl pt_BR pt ro ru si sk sl sq sr@latin sr sv ta te th tr uk ur vi zh_CN zh_TW zu"
fi

dnl Extra link-time flags for Cygwin.
dnl Copied from libxml2 configure.in, but I removed mingw changes
dnl for now since I'm not supporting mingw at present.  - RWMJ
CYGWIN_EXTRA_LDFLAGS=
CYGWIN_EXTRA_LIBADD=
CYGWIN_EXTRA_PYTHON_LIBADD=
MINGW_EXTRA_LDFLAGS=
case "$host" in
  *-*-cygwin*)
    CYGWIN_EXTRA_LDFLAGS="-no-undefined"
    CYGWIN_EXTRA_LIBADD="${INTLLIBS}"
    if test "x$PYTHON_VERSION" != "x"; then
      CYGWIN_EXTRA_PYTHON_LIBADD="-L/usr/lib/python${PYTHON_VERSION}/config -lpython${PYTHON_VERSION}"
    fi
    ;;
  *-*-mingw*)
    MINGW_EXTRA_LDFLAGS="-no-undefined"
    ;;
esac
AC_SUBST(CYGWIN_EXTRA_LDFLAGS)
AC_SUBST(CYGWIN_EXTRA_LIBADD)
AC_SUBST(CYGWIN_EXTRA_PYTHON_LIBADD)
AC_SUBST(MINGW_EXTRA_LDFLAGS)

AC_SYS_LARGEFILE

# Set LV_LIBTOOL_OBJDIR to "." or $lt_cv_objdir, depending on whether
# we're building shared libraries.  This is the name of the directory
# in which .o files will be created.
test "$enable_shared" = no && lt_cv_objdir=.
LV_LIBTOOL_OBJDIR=${lt_cv_objdir-.}
AC_SUBST(LV_LIBTOOL_OBJDIR)

# very annoying
rm -f COPYING
cp COPYING.LIB COPYING

AC_OUTPUT(Makefile src/Makefile include/Makefile docs/Makefile \
          docs/examples/Makefile docs/devhelp/Makefile \
	  docs/examples/python/Makefile \
	  gnulib/lib/Makefile \
	  gnulib/tests/Makefile \
          libvirt.pc libvirt.spec \
          po/Makefile.in scripts/Makefile \
	  include/libvirt/Makefile include/libvirt/libvirt.h \
	  python/Makefile python/tests/Makefile \
          qemud/Makefile \
          tests/Makefile proxy/Makefile \
          tests/xml2sexprdata/Makefile \
          tests/sexpr2xmldata/Makefile \
          tests/xmconfigdata/Makefile \
          tests/xencapsdata/Makefile \
          tests/virshdata/Makefile tests/confdata/Makefile)

AC_MSG_NOTICE([])
AC_MSG_NOTICE([Configuration summary])
AC_MSG_NOTICE([=====================])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Drivers])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([     Xen: $with_xen])
AC_MSG_NOTICE([   Proxy: $with_xen_proxy])
AC_MSG_NOTICE([    QEMU: $with_qemu])
AC_MSG_NOTICE([  OpenVZ: $with_openvz])
AC_MSG_NOTICE([     LXC: $with_lxc])
AC_MSG_NOTICE([    Test: $with_test])
AC_MSG_NOTICE([  Remote: $with_remote])
AC_MSG_NOTICE([Libvirtd: $with_libvirtd])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Storage Drivers])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([     Dir: yes])
AC_MSG_NOTICE([      FS: $with_storage_fs])
AC_MSG_NOTICE([   NetFS: $with_storage_fs])
AC_MSG_NOTICE([     LVM: $with_storage_lvm])
AC_MSG_NOTICE([   iSCSI: $with_storage_iscsi])
AC_MSG_NOTICE([    Disk: $with_storage_disk])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Libraries])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([  libxml: $LIBXML_CFLAGS $LIBXML_LIBS])
AC_MSG_NOTICE([  gnutls: $GNUTLS_CFLAGS $GNUTLS_LIBS])
if test "$with_sasl" != "no" ; then
AC_MSG_NOTICE([    sasl: $SASL_CFLAGS $SASL_LIBS])
else
AC_MSG_NOTICE([    sasl: no])
fi
if test "$with_avahi" = "yes" ; then
AC_MSG_NOTICE([   avahi: $AVAHI_CFLAGS $AVAHI_LIBS])
else
AC_MSG_NOTICE([   avahi: no])
fi
if test "$with_polkit" = "yes" ; then
AC_MSG_NOTICE([  polkit: $POLKIT_CFLAGS $POLKIT_LIBS])
else
AC_MSG_NOTICE([  polkit: no])
fi
if test "$with_selinux" = "yes" ; then
AC_MSG_NOTICE([  selinux: $SELINUX_CFLAGS $SELINUX_LIBS])
else
AC_MSG_NOTICE([  selinux: no])
fi
if test "$with_numactl" = "yes" ; then
AC_MSG_NOTICE([  numactl: $NUMACTL_CFLAGS $NUMACTL_LIBS])
else
AC_MSG_NOTICE([  numactl: no])
fi
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Miscellaneous])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([  Debug: $enable_debug])
AC_MSG_NOTICE([  Warnings: $enable_compile_warnings])
AC_MSG_NOTICE([  Readline: $lv_use_readline])
AC_MSG_NOTICE([])