AC_INIT
AC_CONFIG_SRCDIR([src])
AC_PREREQ(2.59)
AC_CANONICAL_HOST
AC_CANONICAL_TARGET


dnl **********************************************************
dnl * Version and release information
dnl **********************************************************

libprelude_major=1
libprelude_minor=0
libprelude_micro=0
libprelude_patchlevel=
libprelude_version=$libprelude_major.$libprelude_minor.$libprelude_micro$libprelude_patchlevel


dnl **********************************************************
dnl * Library soname (http://sources.redhat.com/autobook/autobook/autobook_91.html#SEC91)
dnl **********************************************************

libprelude_current=21
libprelude_revision=1
libprelude_age=19
LIBPRELUDE_SONAME=$libprelude_current:$libprelude_revision:$libprelude_age

libpreludecpp_current=3
libpreludecpp_revision=0
libpreludecpp_age=3
LIBPRELUDECPP_SONAME=$libpreludecpp_current:$libpreludecpp_revision:$libpreludecpp_age


AM_INIT_AUTOMAKE(libprelude, $libprelude_version)
AC_CONFIG_HEADER(config.h)
AM_MAINTAINER_MODE


dnl **********************************************************
dnl * Check required program.
dnl **********************************************************

AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_MAKE_SET
AM_PROG_LEX
AC_PROG_YACC
AC_PATH_PROG(GREP, grep, no) # for prelude-config.h generation
BINDINGS_CC="$CC"


dnl **********************************************************
dnl * Setup GnuLib, libtool and libltdl.
dnl **********************************************************

gl_EARLY
LT_CONFIG_LTDL_DIR([libltdl])
AC_CONFIG_MACRO_DIR([m4])
LT_INIT([dlopen win32-dll disable-static])
LTDL_INIT([recursive])




dnl **********************************************************
dnl * When cross compiling, we need to compile and run a program on the build machine.
dnl **********************************************************

AC_MSG_CHECKING(for cc for build)
if test "$cross_compiling" = "yes"; then
  CC_FOR_BUILD="${CC_FOR_BUILD-cc}"
else
  CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
fi
AC_MSG_RESULT($CC_FOR_BUILD)
AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])



dnl **********************************************************
dnl * Checks to see if ANSI C99 CPP variable __func__ works. *
dnl **********************************************************

dnl From http://lists.gnu.org/archive/html/bug-autoconf/2002-07/msg00028.html

AC_DEFUN([AC_CPP_FUNC], [AC_REQUIRE([AC_PROG_CC_STDC])dnl
AC_CACHE_CHECK([for an ANSI C99-conforming __func__], ac_cv_cpp_func,
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
[[char *foo = __func__;]])],
  [ac_cv_cpp_func=yes],
  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
[[char *foo = __FUNCTION__;]])],
  [ac_cv_cpp_func=__FUNCTION__],
  [ac_cv_cpp_func=no])])])

if test $ac_cv_cpp_func = yes; then
   AC_DEFINE(__PRELUDE_FUNC__, __func__, [Define to __FUNCTION__ or "" if `__func__' does not conform to ANSI C.])
elif test $ac_cv_cpp_func = __FUNCTION__; then
   AC_DEFINE(__PRELUDE_FUNC__, __FUNCTION__, [Define to __FUNCTION__ or "" if `__func__' does not conform to ANSI C.])
elif test $ac_cv_cpp_func = no; then
   AC_DEFINE(__PRELUDE_FUNC__, "", [Define to __FUNCTION__ or "" if `__func__' does not conform to ANSI C.])
fi
])

AC_CPP_FUNC



dnl **************************************************
dnl * Check for Pthread library                      *
dnl **************************************************

PTHREAD_LIBS=@LTLIBMULTITHREAD@
PTHREAD_LDFLAGS=""
PTHREAD_CFLAGS=$THREADCPPFLAGS

AC_SUBST(PTHREAD_LDFLAGS)
AC_SUBST(PTHREAD_CFLAGS)
AC_SUBST(PTHREAD_LIBS)

dnl ***
dnl *** Can we use -Werror -Wmissing-braces for some checks ? ***
AX_C_CHECK_FLAG(-Werror -Wmissing-braces, , , buggy_pthread_cppflags="-Werror -Wmissing-braces")


old_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $buggy_pthread_cppflags"

AC_MSG_CHECKING(for buggy pthread mutex initializers)
AC_TRY_COMPILE(
[
#include <pthread.h>
],
[
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
],
compile_ok="yes", compile_ok="no")

CFLAGS="$old_CFLAGS"

if test x$compile_ok = xyes; then
   AC_MSG_RESULT(no)
else
   AC_MSG_RESULT(yes)
   buggy_pthread_initializers="yes"
fi


dnl **************************************************
dnl * Check endianess                                *
dnl **************************************************
AC_C_BIGENDIAN(AC_DEFINE_UNQUOTED(PRELUDE_WORDS_BIGENDIAN, , Byte ordering))



dnl **************************************************
dnl * Check for GnuTLS.                              *
dnl **************************************************
GNUTLS_MIN_VERSION=1.0.17

PKG_CHECK_MODULES([LIBGNUTLS], [gnutls >= $GNUTLS_MIN_VERSION], [],
                  [AM_PATH_LIBGNUTLS($GNUTLS_MIN_VERSION, [], [AC_MSG_ERROR($LIBGNUTLS_PKG_ERRORS)])])

old_LIBS=$LIBS
old_CPPFLAGS=$CPPFLAGS
LIBS="$LIBGNUTLS_LIBS"
CPPFLAGS="$LIBGNUTLS_CFLAGS"

AC_CHECK_HEADER(gnutls/gnutls.h, ,
                AC_MSG_ERROR("GnuTLS development headers are required to build libprelude"))

dnl
dnl Recent GnuTLS version moved SRP function from libgnutls-extra to libgnutls
dnl
AC_CHECK_LIB(gnutls, gnutls_srp_verifier, srp_available=yes, srp_available=no)
AC_CHECK_LIB(gnutls, gnutls_x509_crt_list_import,
             AC_DEFINE_UNQUOTED(HAVE_GNUTLS_X509_CRT_LIST_IMPORT, , Define whether GnuTLS provides gnutls_x509_crt_list_import,))

AC_CHECK_LIB(gnutls, gnutls_priority_init, gnutls_string_priority=yes, gnutls_string_priority=no)
if test x$gnutls_string_priority = xyes; then
        AC_CHECK_LIB(gnutls, gnutls_priority_set, AC_DEFINE_UNQUOTED(HAVE_GNUTLS_STRING_PRIORITY, , Define whether GnuTLS provide priority parsing),)
fi


LIBS=$old_LIBS
CPPFLAGS=$old_CPPFLAGS

AC_SUBST(PRELUDE_ADMIN_LIBS)
AC_SUBST(PRELUDE_ADMIN_CFLAGS)

if test x$srp_available = xno; then
   dnl **************************************************
   dnl * Check for SRP function in GnuTLS extra.        *
   dnl **************************************************
   PKG_CHECK_MODULES([LIBGNUTLS_EXTRA], [gnutls-extra >= $GNUTLS_MIN_VERSION], [gnutls_extra=yes],
                     [AM_PATH_LIBGNUTLS_EXTRA($GNUTLS_MIN_VERSION, gnutls_extra=yes, gnutls_extra=no)])

   if test x$gnutls_extra = xyes; then
        old_LIBS=$LIBS
        LIBS="$LIBGNUTLS_EXTRA_LIBS"
        old_CPPFLAGS=$CPPFLAGS
        CPPFLAGS="$LIBGNUTLS_EXTRA_CFLAGS"

        AC_CHECK_HEADER(gnutls/extra.h, [AC_CHECK_LIB(gnutls-extra, gnutls_srp_verifier, srp_available=yes, srp_available=no)], srp_available=no)
        if test x$srp_available = xyes; then
                AC_DEFINE_UNQUOTED(GNUTLS_SRP_ENABLED, , Define whether SRP support is enabled)
                PRELUDE_ADMIN_CFLAGS="-DNEED_GNUTLS_EXTRA $LIBGNUTLS_EXTRA_CFLAGS"
                PRELUDE_ADMIN_LIBS="$LIBGNUTLS_EXTRA_LIBS"
                AC_DEFINE([NEED_GNUTLS_EXTRA_INCLUDE], [1], 
			  [Define whether we need to include gnutls/extra.h for srp])
        fi

       LIBS=$old_LIBS
       CPPFLAGS=$old_CPPFLAGS
   fi
fi




dnl **************************************************
dnl * Check for Gcrypt.                              *
dnl **************************************************

AM_PATH_LIBGCRYPT(1:1.1.94,,
        AC_MSG_ERROR([[
***
*** libgcrypt was not found. You may want to get it from
*** ftp://ftp.gnupg.org/gcrypt/libgcrypt/
***
]]))


LIBPRELUDE_LIBS="$LIBPRELUDE_LIBS $LIBGNUTLS_LIBS $LIBGCRYPT_LIBS"


dnl **************************************************
dnl * Check for Ipv6.                                *
dnl **************************************************

AC_CHECK_TYPES([struct sockaddr_in6], have_ipv6_type=yes,, [
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
])

AC_CHECK_DECL(AF_INET6, have_ipv6_def=yes,, [
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
])

if test x$have_ipv6_type = xyes && test x$have_ipv6_def = xyes; then
        AC_DEFINE_UNQUOTED(HAVE_IPV6, , Define whether Ipv6 is available on this system)
fi



dnl **************************************************
dnl * Check for variadic macros                      *
dnl **************************************************
AC_MSG_CHECKING(whether variadic macros are supported)

AC_TRY_COMPILE(
[
#include <stdio.h>
#include <stdarg.h>

#define print_me(...) printf(__VA_ARGS__)
],
[
print_me("test __VA_ARGS__: %s, %d, %d", "a", 0, 1);
return 0;
], have_variadic_macros=yes, have_variadic_macros=no)

if test x$have_variadic_macros = xyes; then
   AC_MSG_RESULT(yes)
   AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS, 1, [Define whether variadic macros are supported])
else
   AC_MSG_RESULT(no)
fi



dnl **************************************************
dnl * Do we need aligned access ? (from tcpdump)     *
dnl **************************************************

AX_CHECK_ALIGNED_ACCESS_REQUIRED
if test "$ax_cv_have_aligned_access_required" = yes; then
        AC_DEFINE_UNQUOTED(PRELUDE_ALIGNED_ACCESS, , Define wether we need to take care with alignment)
fi



dnl ************************************
dnl *   va_copy checks (Thanks Glib!)  *
dnl ************************************
dnl
dnl we currently check for all three va_copy possibilities, so we get
dnl all results in config.log for bug reports.

AC_CACHE_CHECK([for an implementation of va_copy()],prelude_cv_va_copy,[
        AC_LINK_IFELSE([#include <stdarg.h>
        void f (int i, ...) {
        va_list args1, args2;
        va_start (args1, i);
        va_copy (args2, args1);
        if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
          exit (1);
        va_end (args1); va_end (args2);
        }
        int main() {
          f (0, 42);
          return 0;
        }],
        [prelude_cv_va_copy=yes],
        [prelude_cv_va_copy=no])
])
AC_CACHE_CHECK([for an implementation of __va_copy()],prelude_cv___va_copy,[
        AC_LINK_IFELSE([#include <stdarg.h>
        void f (int i, ...) {
        va_list args1, args2;
        va_start (args1, i);
        __va_copy (args2, args1);
        if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
          exit (1);
        va_end (args1); va_end (args2);
        }
        int main() {
          f (0, 42);
          return 0;
        }],
        [prelude_cv___va_copy=yes],
        [prelude_cv___va_copy=no])
])

if test "x$prelude_cv_va_copy" = "xyes"; then
  g_va_copy_func=va_copy
else if test "x$prelude_cv___va_copy" = "xyes"; then
  g_va_copy_func=__va_copy
fi
fi

if test -n "$g_va_copy_func"; then
  AC_DEFINE_UNQUOTED(PRELUDE_VA_COPY,$g_va_copy_func,[A 'va_copy' style function])
fi

AC_CACHE_CHECK([whether va_lists can be copied by value],prelude_cv_va_val_copy,[
        AC_TRY_RUN([#include <stdarg.h>
        void f (int i, ...) {
        va_list args1, args2;
        va_start (args1, i);
        args2 = args1;
        if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
          exit (1);
        va_end (args1); va_end (args2);
        }
        int main() {
          f (0, 42);
          return 0;
        }],
        [prelude_cv_va_val_copy=yes],
        [prelude_cv_va_val_copy=no],
        [prelude_cv_va_val_copy=yes])
])

if test "x$prelude_cv_va_val_copy" = "xno"; then
  AC_DEFINE(PRELUDE_VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
fi


dnl **************************************************
dnl * Swig support                                   *
dnl **************************************************

AC_ARG_WITH(swig, AC_HELP_STRING(--with-swig@<:@=PATH@:>@, Re-generate perl/python bindings sources @<:@default=auto@:>@),
            [swig_required=true; if test x$withval = xyes; then with_swig="swig"; fi], with_swig="swig")

if test x$with_swig != xno; then
   AC_PATH_PROG(SWIG, `basename $with_swig`, no, `dirname $with_swig`:$PATH)

   if test x$SWIG = xno; then
      if test x$swig_required = xtrue; then
         AC_MSG_ERROR([Could not find $with_swig binary])
      fi
   fi
fi

AM_CONDITIONAL(HAVE_SWIG, test x$SWIG != xno)


dnl **************************************************
dnl * Perl support                                   *
dnl **************************************************

AC_ARG_WITH(perl, AC_HELP_STRING(--with-perl@<:@=PATH@:>@, Enable support for perl binding @<:@default=auto@:>@),
            [perl_required=true; if test x$withval = xyes; then with_perl="perl"; fi], with_perl="perl")

if test x$with_perl != xno; then

   AC_PATH_PROG(PERL, `basename $with_perl`, no, `dirname $with_perl`:$PATH)

   if test x$PERL = xno; then
      if test x$perl_required = xtrue; then
         AC_MSG_ERROR([Could not find $with_perl binary])
      fi

      with_perl=no
   else
      PERL_CFLAGS="-I`$PERL -e 'use Config; print $Config{archlib}'`/CORE"

      old_CPPFLAGS="$CPPFLAGS"
      CPPFLAGS="$CPPFLAGS $PERL_CFLAGS"

      AC_CHECK_HEADER(EXTERN.h, [AC_CHECK_HEADER(perl.h, with_perl=yes, with_perl=no, [#include <EXTERN.h>])], with_perl=no)
      CPPFLAGS="$old_CPPFLAGS"
   fi
fi

AM_CONDITIONAL(HAVE_PERL, test x$with_perl = xyes)


PERL_INSTALLDIRS="site"

AC_ARG_WITH(perl-installdirs, AC_HELP_STRING(--with-perl-installdirs=@<:@site|vendor@:>@, Specify where to install the Perl module @<:@default=site@:>@),
            PERL_INSTALLDIRS="$withval")

if test x$PERL_INSTALLDIRS != xsite && test x$PERL_INSTALLDIRS != xvendor; then
        AC_MSG_ERROR(Invalid value for --with-perl-installdirs: only "site" or "vendor" supported.)
fi

PERL_EXTRA_PARAMS="INSTALLDIRS=$PERL_INSTALLDIRS"
AC_SUBST(PERL_EXTRA_PARAMS)


dnl **************************************************
dnl * Python support                                 *
dnl **************************************************

AC_ARG_WITH(python, AC_HELP_STRING(--with-python@<:@=PATH@:>@, Enable support for python binding @<:@default=auto@:>@),
            [python_required=true; if test x$withval = xyes; then with_python="python"; fi], with_python="python")

if test x$with_python != xno; then

   AC_PATH_PROG(PYTHON, `basename $with_python`, no, `dirname $with_python`:$PATH)
   if test x$PYTHON = xno; then
      if test x$python_required = xtrue; then
         AC_MSG_ERROR([Could not find $with_python binary])
      fi

      with_python=no
   else
      old_CPPFLAGS="$CPPFLAGS"
      CPPFLAGS="-I`$PYTHON -c 'from distutils.sysconfig import get_python_inc; print get_python_inc()'`"

      AC_CHECK_HEADER(Python.h, with_python=yes, with_python=no)
      CPPFLAGS="$old_CPPFLAGS"
   fi
fi

AM_CONDITIONAL(HAVE_PYTHON, test x$with_python = xyes)


dnl **************************************************
dnl * Ruby support                                   *
dnl **************************************************


AM_PATH_RUBY(,with_ruby=yes, with_ruby=no)
if test x$with_ruby != xno; then
    RUBY_ARCHDIR=`$RUBY -e 'require "rbconfig.rb"; puts Config::expand("\$(archdir)")'`
    RUBY_LIBRUBYARG=`$RUBY -e 'require "rbconfig.rb"; puts Config::expand("\$(LIBRUBYARG)")'`

    RUBY_LIBS="-L$RUBY_ARCHDIR $RUBY_LIBRUBYARG"
    AC_SUBST(RUBY_LIBS)

    RUBY_CCFLAGS=`$RUBY -rrbconfig -e "print Config::CONFIG[['CFLAGS']]"`
    AC_SUBST(RUBY_CCFLAGS)

    old_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$RUBY_INCLUDES"
    AC_CHECK_HEADER(ruby.h, with_ruby=yes, with_ruby=no)
    CPPFLAGS="$old_CPPFLAGS"
fi
AM_CONDITIONAL([HAVE_RUBY], [test x$with_ruby = xyes])


dnl **************************************************
dnl * LUA support                                    *
dnl **************************************************


AC_ARG_WITH(lua, AC_HELP_STRING(--with-lua-config@<:@=PATH@:>@, Enable support for lua binding @<:@default=auto@:>@),
            [lua_required=true; if test x$withval = xyes; then with_lua="lua-config"; fi], with_lua="lua-config")

if test x$with_lua != xno; then

   lua_pkg_found=0
   PKG_CHECK_MODULES(LUA, lua >= 5.1, [
      AC_DEFINE([HAVE_LUA], [1], [liblua])
      AC_DEFINE([HAVE_LUA_H], [1], [lua.h])
      lua_pkg_found=1
   ],[
      PKG_CHECK_MODULES(LUA, lua5.1 >= 5.1, [
        AC_DEFINE([HAVE_LUA], [1], [liblua])
        AC_DEFINE([HAVE_LUA_H], [1], [lua.h])
        lua_pkg_found=1
      ], [
         AC_MSG_WARN([*** lua >= 5.1 not found])
      ])
   ])

   if test x$lua_pkg_found = x1; then
      AC_SUBST(LUA_CFLAGS)
      AC_SUBST(LUA_LIBS)

      old_CPPFLAGS="$CPPFLAGS"
      CPPFLAGS="$LUA_CFLAGS"
      AC_CHECK_HEADERS([lua.h lauxlib.h], with_lua=yes, [with_lua=no; break])
      CPPFLAGS="$old_CPPFLAGS"
   else
      dnl try lua 5.0
      AC_PATH_PROG(LUA_CONFIG, `basename $with_lua`, no, `dirname $with_lua`:$PATH)
      if test x$LUA_CONFIG = xno; then
         if test x$lua_required = xtrue; then
            AC_MSG_ERROR([Could not find $with_lua binary])
         fi

         with_lua=no
      else
         LUA_CFLAGS=`$LUA_CONFIG --include --vmonly`
         LUA_LIBS=`$LUA_CONFIG --libs --vmonly`
         AC_SUBST(LUA_CFLAGS)
         AC_SUBST(LUA_LIBS)

         old_CPPFLAGS="$CPPFLAGS"
         CPPFLAGS="$LUA_CFLAGS"
         AC_CHECK_HEADERS([lua.h lauxlib.h], with_lua=yes, [with_lua=no; break])
         CPPFLAGS="$old_CPPFLAGS"
      fi
   fi
fi

AM_CONDITIONAL(HAVE_LUA, test x$with_lua = xyes)



dnl **************************************************
dnl * Easy bindings support                          *
dnl **************************************************


AC_ARG_ENABLE(easy-bindings, AC_HELP_STRING(--enable-easy-bindings, Enable support for high level binding @<:@default=yes@:>@),
                enable_easy_bindings=$enableval, enable_easy_bindings="yes")

AM_CONDITIONAL(HAVE_EASY_BINDINGS, test x$enable_easy_bindings = xyes)

if test x$enable_easy_bindings = xyes; then
        AC_CHECK_PROG(HAVE_CXX, $CXX, yes, no)
        if test x$HAVE_CXX != xyes; then
                AC_MSG_ERROR([Easybindings require a C++ compiler, but none were found.])
        fi
fi


dnl **************************************************
dnl * Valgrind support                               *
dnl **************************************************

AC_ARG_WITH(valgrind, AC_HELP_STRING(--with-python@<:@=PATH@:>@, Valgrind support for unit testing @<:@default=auto@:>@),
            [valgrind_required=true; if test x$withval = xyes; then with_valgrind="valgrind"; fi], with_valgrind="valgrind")

if test x$with_valgrind != xno; then

   AC_PATH_PROG(VALGRIND, `basename $with_valgrind`, no, `dirname $with_valgrind`:$PATH)
   if test x$VALGRIND = xno; then
      if test x$valgrind_required = xtrue; then
         AC_MSG_ERROR([Could not find $with_valgrind binary])
      fi

      with_valgrind=no
   else
      with_valgrind=yes
   fi
fi

AM_CONDITIONAL(HAVE_VALGRIND, test x$with_valgrind = xyes)


dnl **************************************************
dnl * Typedefs, structures, compiler characteristics.*
dnl **************************************************

dnl this need to be done before calling GnuLib, since
dnl GnuLib might provide replacement for the different
dnl types

AC_C_CONST
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_CHECK_TYPES([uid_t, gid_t])
AC_HEADER_TIME
AC_TYPE_LONG_LONG_INT
AC_C_INLINE
AC_SYS_LARGEFILE



dnl **************************************************
dnl * Check for missing function replacement         *
dnl **************************************************
gl_SOURCE_BASE(libmissing)
gl_M4_BASE(libmissing/m4)
gl_INIT


dnl **************************************************
dnl * Check for GTK-DOC                              *
dnl **************************************************

GTK_DOC_CHECK(1.0)


dnl **************************************************
dnl * Required headers / functions.                  *
dnl **************************************************

dnl Needed for FIONREAD under solaris

AC_CHECK_HEADERS_ONCE(sys/filio.h sys/un.h netinet/tcp.h)
AC_CHECK_FUNCS(ftruncate chsize)
AX_CREATE_PRELUDE_INTTYPES_H(src/include/prelude-inttypes.h)



dnl **************************************************
dnl * Setup custom compiler flags                    *
dnl **************************************************

AC_MSG_CHECKING(for cpu-specific compiler flags)
if test "$host_cpu" == "x86_64" && test $enable_static = "yes"; then
        AC_MSG_RESULT(x86_64/static: adding -fPIC)
        AX_C_CHECK_FLAG(-fPIC, , , CPPFLAGS="$CPPFLAGS -fPIC")
else
        AC_MSG_RESULT(none needed)
fi

AC_MSG_CHECKING(for platform-specific compiler flags)
case "$host_os" in
 darwin*)
        # It may be called "cc", but it's really a GCC derivative
        # with a problematic special precompiler and precompiled
        # headers; turn off the special precompiler, as some
        # apparently-legal code won't compile with its precompiled
        # headers.
        AC_MSG_RESULT(Darwin: adding -no-cpp-precomp)
        AX_C_CHECK_FLAG(-no-cpp-precomp, , , PCFLAGS="$PCFLAGS -no-cpp-precomp")
        ;;
 *)
        AC_MSG_RESULT(none needed)
        ;;
esac


AX_LD_CHECK_FLAG(-z relro, , , LDFLAGS="$LDFLAGS -z relro")
AX_LD_CHECK_FLAG(-z now, , , LDFLAGS="$LDFLAGS -z now")


for i in -Wall -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations \
         -Wbad-function-cast -Wcast-qual -Wcast-align -Wnested-externs -Wunused \
         -Wformat -Wformat-security; do
        AX_C_CHECK_FLAG($i, , , PCFLAGS="$PCFLAGS $i")
done

if test x$buggy_pthread_initializers = xyes; then
   AX_C_CHECK_FLAG(-Wno-missing-braces, , , PCFLAGS="$PCFLAGS -Wno-missing-braces")
fi



dnl **************************************************
dnl * Setup build variable                           *
dnl **************************************************

AC_SUBST(CFLAGS)
AC_SUBST(PCFLAGS)
AC_SUBST(CPPFLAGS)
AC_SUBST(LDFLAGS)
AC_SUBST(BINDINGS_CC)
AC_SUBST(LIBPRELUDE_SONAME)
AC_SUBST(LIBPRELUDECPP_SONAME)
AC_SUBST(LIBPRELUDE_LIBS)
AC_SUBST(LIBPRELUDE_CFLAGS)
AC_SUBST(PRELUDE_ADMIN_LIBS)
AC_SUBST(PRELUDE_SPOOL_DIR)
AC_SUBST(PRELUDE_CONFIG_DIR)

AS_AC_EXPAND(SYSCONFDIR, $sysconfdir)
AS_AC_EXPAND(LOCALSTATEDIR, $localstatedir)
AS_AC_EXPAND(LIBDIR, $libdir)
AS_AC_EXPAND(BINDIR, $bindir)

PRELUDE_SPOOL_DIR=$LOCALSTATEDIR/spool/prelude
PRELUDE_CONFIG_DIR=$SYSCONFDIR/prelude

AC_DEFINE_UNQUOTED(PRELUDE_SPOOL_DIR, "$PRELUDE_SPOOL_DIR", Prelude spool directory)
AC_DEFINE_UNQUOTED(PRELUDE_CONFIG_DIR, "$PRELUDE_CONFIG_DIR", Prelude config directory)

case "${host}" in
        i[[3456789]]86-*-mingw32*) WIN32="yes" ;;
        *cygwin*) WIN32="yes" ;;
        *) WIN32="no" ;;
esac

if test x$WIN32 = xyes; then
        AC_DEFINE_UNQUOTED(INSTALLDIR, "$BINDIR", Prelude library install directory)
else
        AC_DEFINE_UNQUOTED(INSTALLDIR, "$LIBDIR", Prelude library install directory)
fi


AC_CONFIG_FILES([

Makefile
client.conf
global.conf
idmef-client.conf

libprelude-config

libltdl/Makefile

libmissing/Makefile
libmissing/tests/Makefile
m4/Makefile

src/Makefile
src/libprelude.pc
src/libprelude-error/Makefile
src/include/Makefile

src/include/prelude.h
src/include/prelude-inttypes.h

prelude-admin/prelude-adduser
prelude-admin/Makefile

docs/Makefile
docs/api/Makefile
docs/manpages/Makefile

bindings/Makefile
bindings/low-level/Makefile
bindings/low-level/perl/Makefile.PL
bindings/low-level/python/Makefile
bindings/low-level/python/setup.py

bindings/c++/Makefile
bindings/c++/include/Makefile
bindings/lua/Makefile
bindings/perl/Makefile.PL
bindings/python/Makefile
bindings/python/setup.py
bindings/ruby/Makefile
tests/Makefile

])
AC_CONFIG_COMMANDS([default],[[ chmod +x libprelude-config ]],[[]])
AC_OUTPUT


echo
echo "*** Dumping configuration ***"
echo "    - Generate documentation   : $enable_gtk_doc"
echo "    - LUA binding              : $with_lua"
echo "    - Perl binding             : $with_perl"
echo "    - Python binding           : $with_python"
echo "    - Ruby binding             : $with_ruby"
echo "    - Easy bindings            : $enable_easy_bindings"