/* @(#)$Id: configure.ac,v 1.3 2006/03/21 20:24:41 simon Exp $ */

AC_PREREQ(2.59)
AC_INIT([ipa_sdb], [1.0.1], [simon@comsys.ntu-kpi.kiev.ua])
AM_INIT_AUTOMAKE

AC_ARG_WITH([with-pthread],
	AC_HELP_STRING([--with-pthread], [build pthread safe modules (read INSTALL)]),
	AC_DEFINE(WITH_PTHREAD)
)

AC_ARG_WITH([mandir-ru],
	AC_HELP_STRING([--with-mandir-ru=/path], [subdirectory for Russian manual pages [[ru.KOI8-R]]]),
	mandir_ru=${withval},
	mandir_ru=ru.KOI8-R
)

AC_ARG_ENABLE([autorules],
	AC_HELP_STRING([--disable-autorules], [remove dynamic rules support]),
	with_autorules=no,
	with_autorules=yes
	AC_DEFINE(WITH_AUTORULES)
)

AC_ARG_ENABLE([rules],
	AC_HELP_STRING([--disable-rules], [remove static rules support]),
	with_rules=no,
	with_rules=yes
	AC_DEFINE(WITH_RULES)
)

AC_ARG_ENABLE([limits],
	AC_HELP_STRING([--disable-limits], [remove limits support]),
	,
	AC_DEFINE(WITH_LIMITS)
)

AC_ARG_ENABLE([thresholds],
	AC_HELP_STRING([--disable-thresholds], [remove thresholds support]),
	,
	AC_DEFINE(WITH_THRESHOLDS)
)

if test "${with_rules}" = "no" -a "${with_autorules}" = "no"; then
	AC_MSG_ERROR([you cannot remove support for both static and dynamic rules])
fi

AC_PROG_CC

AM_DISABLE_STATIC
AM_PROG_LIBTOOL

AC_CHECK_SIZEOF(long)

AC_CHECK_TYPES([u_short, u_int, u_long])

AC_DEFUN([MY_CHECK_ATTR_FORMAT], [
	AC_MSG_CHECKING([attribute "format"])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
#include <stdarg.h>
#include <stdio.h>

void bar(const char *, ...) __attribute__ ((format (printf, 1, 2)));

void
bar(const char *format, ...)
{
	va_list ap;
	va_start(ap, format);
	vprintf(format, ap);
	va_end(ap);
}
]])],
		[AC_MSG_RESULT([yes]); AC_DEFINE([ATTR_FORMAT(x, y, z)], [__attribute__ ((format (x, y, z)))])],
		[AC_MSG_RESULT([no]);  AC_DEFINE([ATTR_FORMAT(x, y, z)], [])]
	)
])

MY_CHECK_ATTR_FORMAT

AC_DEFUN([MY_CHECK_ATTR_NORETURN], [
	AC_MSG_CHECKING([attribute "noreturn"])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
#include <stdlib.h>

void bar(void) __attribute__ ((noreturn));

void
bar(void)
{
	exit(0);
}
]])],
		[AC_MSG_RESULT([yes]); AC_DEFINE(ATTR_NORETURN, [__attribute__ ((noreturn))])],
		[AC_MSG_RESULT([no]);  AC_DEFINE(ATTR_NORETURN, [])]
	)
])

MY_CHECK_ATTR_NORETURN

AC_DEFUN([MY_CHECK_ATTR_PACKED], [
	AC_MSG_CHECKING([attribute "packed"])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
struct bar {
	int x;
} __attribute__ ((packed));
]])],
		[AC_MSG_RESULT([yes]); my_cv_attr_packed=yes; AC_DEFINE(ATTR_PACKED, [__attribute__ ((packed))])],
		[AC_MSG_RESULT([no]);  my_cv_attr_packed=no]
	)
])

MY_CHECK_ATTR_PACKED

AC_DEFUN([MY_CHECK_PRAGMA_PACK_PUSH_POP], [
	AC_MSG_CHECKING([pragma pack])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
#pragma pack(push, 1)
struct bar {
	int x;
};
#pragma pack(pop)
]])],
		[AC_MSG_RESULT([yes]), AC_DEFINE(USE_PRAGMA_PACK_PUSH_POP, [])],
		[AC_MSG_RESULT([no])]
	)
])

if test "${my_cv_attr_packed}" = "no"; then
	MY_CHECK_PRAGMA_PACK_PUSH_POP
fi

AC_DEFUN([MY_CHECK_ATTR_UNUSED], [
	AC_MSG_CHECKING([attribute "unused"])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
int x __attribute__((unused));
]])],
		[AC_MSG_RESULT([yes]); AC_DEFINE(ATTR_UNUSED, [__attribute__ ((unused))])],
		[AC_MSG_RESULT([no]);  AC_DEFINE(ATTR_UNUSED, [])]
	)
])

MY_CHECK_ATTR_UNUSED

AC_DEFUN([MY_CHECK_DECL], [
	AC_MSG_CHECKING([whether $1 is defined])
	AC_COMPILE_IFELSE(
		[AC_LANG_SOURCE([[
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif

char *s = $1;
]])],
		[AC_MSG_RESULT([yes]); my_cv_decl_$1=yes],
		[AC_MSG_RESULT([no]);  my_cv_decl_$1=no]
	)
])

AC_DEFUN([MY_CHECK_PRINTF_UINT64], [
	AC_MSG_CHECKING([whether printf accepts uint64_t for %$1])
	AC_RUN_IFELSE(
		[AC_LANG_SOURCE([[
#include <stdio.h>
#include <string.h>

#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif

#ifndef UINT64_MAX
# define UINT64_MAX	0xffffffffffffffffULL
#endif

int
main(void)
{
	char buf[21];

	if (snprintf(buf, sizeof buf, "%$1", UINT64_MAX) != 20)
		return 1;
	return strcmp(buf, "18446744073709551615") == 0 ? 0 : 1;
}
]])],
		[AC_MSG_RESULT([yes]); my_cv_printf_uint64_$1=yes],
		[AC_MSG_RESULT([no]);  my_cv_printf_uint64_$1=no],
		[AC_MSG_RESULT([no]);  my_cv_printf_uint64_$1=no]
	)
])

if test ${ac_cv_sizeof_long} -eq 4; then
	MY_CHECK_DECL(PRIu64)
	if test "${my_cv_decl_PRIu64}" = "no"; then
		MY_CHECK_PRINTF_UINT64(llu)
		if test "${my_cv_printf_uint64_llu}" = "yes"; then
			AC_DEFINE(PRIu64, "llu")
		else
			MY_CHECK_PRINTF_UINT64(qu)
			if test "${my_cv_printf_uint64_qu}" = "yes"; then
    				AC_DEFINE(PRIu64, "qu")
			else
				AC_MSG_ERROR([could not find good printf format string for uint64_t])
			fi
		fi
	fi
else
	AC_DEFINE(PRIu64, "lu")
fi

AC_DEFUN([MY_CHECK_SCANF_UINT64], [
	AC_MSG_CHECKING([whether scanf accepts uint64_t for %$1])
	AC_RUN_IFELSE(
		[AC_LANG_SOURCE([[
#include <stdio.h>
#include <sys/types.h>

#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif

#ifndef UINT64_MAX
# define UINT64_MAX	0xffffffffffffffffULL
#endif

int
main(void)
{
	uint64_t a;

	if (sscanf("18446744073709551615", "%$1", &a) != 1)
		return 1;
	return a == UINT64_MAX ? 0 : 1;
}
]])],
		[AC_MSG_RESULT([yes]); my_cv_scanf_uint64_$1=yes],
		[AC_MSG_RESULT([no]);  my_cv_scanf_uint64_$1=no],
		[AC_MSG_RESULT([no]);  my_cv_scanf_uint64_$1=no]
	)
])

if test ${ac_cv_sizeof_long} -eq 4; then
	MY_CHECK_DECL(SCNu64)
	if test "${my_cv_decl_SCNu64}" = "no"; then
		MY_CHECK_SCANF_UINT64(llu)
		if test "${my_cv_scanf_uint64_llu}" = "yes"; then
    			AC_DEFINE(SCNu64, "llu")
		else
			MY_CHECK_SCANF_UINT64(qu)
			if test "${my_cv_scanf_uint64_qu}" = "yes"; then
    				AC_DEFINE(SCNu64, "qu")
			else
				AC_MSG_WARN([could not find good scanf format string for uint64_t])
			fi
		fi
	fi
else
	AC_DEFINE(SCNu64, "lu")
fi

if test "${GCC}" = "yes"; then
	CFLAGS="${CFLAGS} -Wall -Wformat -Wpointer-arith -Wmissing-prototypes -Wreturn-type -Wshadow -Wstrict-prototypes -Wswitch"
fi

AC_SUBST(mandir_ru)

AC_CONFIG_HEADERS([src/config.h src/ipa_sdb.h])

AC_CONFIG_FILES([Makefile src/Makefile man/Makefile man/ru.KOI8-R/Makefile])

AC_OUTPUT