configure.in

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

AC_PREREQ(2.59)
AC_INIT(showeq, 5.13.10.51)
AC_CONFIG_SRCDIR(src/main.cpp)
AC_CONFIG_MACRO_DIR([m4])
AC_CANONICAL_SYSTEM

AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(1.11 dist-bzip2)
AM_MAINTAINER_MODE

dnl doxygen macros
dnl DX_HTML_FEATURE(ON)
dnl DX_CHM_FEATURE(OFF)
dnl DX_CHI_FEATURE(OFF)
dnl DX_MAN_FEATURE(OFF)
dnl DX_RTF_FEATURE(OFF)
dnl DX_XML_FEATURE(OFF)
dnl DX_PDF_FEATURE(OFF)
dnl DX_PS_FEATURE(OFF)
dnl DX_INIT_DOXYGEN(ShowEQ, doxygen.cfg, dox)

dnl Use CCd/CXXd rather than CC/CXX otherwise it cache's the value
dnl and prevents the alternate search from working. Would be better
dnl if there was someway to invalidate the cache entry. ??

AC_CHECK_PROGS(CCd,$CC gcc cc gcc3 gcc-3.0)
AC_CHECK_PROGS(CXXd,$CXX $CCC g++ c++ gcc CC cxx cc++ gcc g++3 g++-3.0)

CC=$CCd
CXX=$CXXd

AC_ARG_ENABLE(old-compiler,
	[  --enable-old-compiler   Compile with an older compiler],
	[ AC_MSG_CHECKING(whether to build with an older compiler)
	case "${enableval}" in
	yes)	AC_MSG_RESULT(yes);
		ac_cv_showeq_old_compiler=yes
		;;
	*)	AC_MSG_RESULT(no)
		ac_cv_showeq_old_compiler=no
		;;
	esac] )

AC_DEFUN([CHECK_COMPILER],[
ac_save_cxxflags="$CXXFLAGS"
if [[ "$ac_cv_showeq_old_compiler" == "yes" ]]; then
	CXXFLAGS="$CXXFLAGS -DOLDCOMPILER"
fi

AC_TRY_LINK(
[
#include <stdio.h>
],
[
#ifdef __GNUC__
 #if ((!defined(OLDCOMPILER) && (__GNUC__ < 3)) || \
      ((__GNUC__ < 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ < 96))))
   #ifdef __GNUC_PATCHLEVEL__
	printf("Unsupported GCC Version: %d.%d.%d\n", 
	       __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
   #else
	printf("Unsuported GCC Version: %d.%d\n", __GNUC__, __GNUC_MINOR__);
   #endif
	#error "Unsupported Compiler Version"
 #else
   #ifdef __GNUC_PATCHLEVEL__
	printf("GCC Version: %d.%d.%d\n", 
	       __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
   #else
	printf("GCC Version: %d.%d\n", __GNUC__, __GNUC_MINOR__);
   #endif
 #endif
#else
	printf("Non-GNU Compiler\n");
	#warning "Unknown Compiler may or may not work!"
#endif
],
[ 
AC_MSG_RESULT(yes)
HAVE_GCC="YES";
],
[
AC_MSG_RESULT(no);
HAVE_GCC="NO";
]
)
CXXFLAGS="$ac_save_cxxflags"
]
)

AC_MSG_CHECKING(for supported compiler version)
AC_LANG_CPLUSPLUS
CHECK_COMPILER
if test "$HAVE_GCC" = "NO"; then
    unset CC
    unset CXX
    AC_CHECK_PROGS(CC,gcc-3.0 gcc3)
    AC_CHECK_PROGS(CXX,g++-3.0 g++3)
    AC_MSG_CHECKING(alternate compiler for supported compiler version)
    CHECK_COMPILER
fi
if test "$HAVE_GCC" = "NO"; then
    AC_MSG_ERROR([You need at least GCC G++ 3.0 or greater to compile ShowEQ])
fi
AC_LANG_C

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CPP

dnl Checks for typedefs, structures, and compiler characteristics.
dnl AC_C_CONST will fail if c++ is switched on using AC_LANG_CPLUSPLUS
dnl before this test is run.
AC_C_CONST

AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AM_PROG_LIBTOOL

AC_LANG_CPLUSPLUS

AC_MSG_CHECKING(for supported libc version)
AC_TRY_LINK(
[
#include <stdio.h>
],
[
#ifdef __GLIBC__
 #if __GLIBC_MINOR__ < 2
	printf("Unsuported GLIBC Version: %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
	#error "Unsupported Compiler Version"
 #else
	printf("GLIBC Version: %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
 #endif
#else
	printf("Non-GNU LibC\n");
	#warning "Unknown LibC may or may not work!"
#endif
],
[
AC_MSG_RESULT(yes)
],
[
AC_MSG_RESULT(no)
AC_MSG_ERROR([You need at least glibc-2.2 or greater to compile ShowEQ])
]
)

AC_PATH_QT_MOC
AC_PATH_QT_UIC
AC_PATH_QT

dnl The below needs to be re-defined since the Qt defines from KDE destroy it
AC_LANG_CPLUSPLUS

dnl Check taken from SINS 0.5
AC_DEFUN([SHOWEQ_CHECK_THREADING],[
AC_LANG_CPLUSPLUS
USE_THREADS=""
LIBGETOPT=""
LIBPTHREAD=""
LIBPCAP_EXTRA=""
case $target_os in
  solaris*)
    USE_THREADS="-D_THREAD_SAFE"
    LIBPTHREAD="-pthread"
    LIBPCAP_EXTRA="-lresolv"
    echo "setting Solaris pthread compilation options"
    ;;
  freebsd*)
    USE_THREADS="-D_THREAD_SAFE"
    LIBPTHREAD="-pthread"
    LIBGETOPT="-L/usr/local/lib/ -lgnugetopt"
    echo "setting FreeBSD pthread compilation options"
    ;;
  aix*)
    USE_THREADS="-D_THREAD_SAFE"
    LIBPTHREAD="$LIBPTHREAD -lc_r"
    echo "setting AIX pthread compilation options"
    ;;
  linux*)
    AC_CHECK_LIB( pthread,
      pthread_create, 
      USE_THREADS="-D_REENTRANT"
      LIBPTHREAD="-lpthread"
      echo "setting Linux pthread compilation options",
      AC_MSG_ERROR( cannot find pthread_create in libpthread )
    )
    ;;
  *)
    ;;
esac
AC_SUBST(USE_THREADS)
AC_SUBST(LIBPTHREAD)
AC_SUBST(LIBGETOPT)
])


dnl Checks for libraries.

dnl check for the threading library
SHOWEQ_CHECK_THREADING

AC_CHECK_LIB(pcap, pcap_open_live,
	, 
	AC_MSG_ERROR(cannot find pcap_open_live in libpcap.  Read the INSTALL file.))

AC_CHECK_LIB(gd, gdImageCreate, 
	havegd=true, 
	havegd=false)
AM_CONDITIONAL(HAVE_GD, test x$havegd=xtrue)

AC_CHECK_LIB(gd, gdImagePng, 
	AC_DEFINE(HAVE_GD_IMAGEPNG, 1, Define if libgd supports PNG))

AC_CHECK_LIB(z, inflate,
	, 
	AC_MSG_ERROR(cannot find compresion library functions. Make sure libz is installed) )

dnl Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS(deque,,AC_MSG_ERROR(cannot find deque, normally part of a c++ development package))

dnl Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_SIZE_T

	
AC_ARG_ENABLE(cgi, 
[  --enable-cgi=DIR        Compile CGIs and install in specified DIR],
[ AC_MSG_CHECKING(whether to build CGIs)
  case "${enableval}" in 
    no)		AC_MSG_RESULT(No) ;;
    yes)	for dir in /var/www/cgi-bin /home/httpd/cgi-bin; do
			if test -d ${dir} ; then
				enableval=${dir}
			fi
	  	done
		if test -d ${enableval} ; then
			cgi=true
			CGIDIR=${enableval}
			AC_MSG_RESULT(${enableval})
		else
			AC_MSG_RESULT(No path found)
			cgi=false
		fi
		;;
    *)		AC_MSG_RESULT(${enableval})
		cgi=true
		CGIDIR=${enableval}
		;;
  esac ], [cgi=false])
AC_SUBST(CGIDIR)
AM_CONDITIONAL(CGI, test x$cgi = xtrue)


CGI_ICON_DIR=/eq-icons/
CGI_ICONS=false
AC_ARG_ENABLE(cgi-icons,
[  --enable-cgi-icons=DIR  Directory on your server where your icons will
                          be stored (/eq-icons/ for http://<SERVER>/eq-icons/).],[ AC_MSG_CHECKING(whether to enable build CGIs with icon support)
  case "${enableval}" in
  no)	CGI_ICON_DIR=/eq-icons/
	AC_MSG_RESULT(no)
	CGI_ICONS=false
	;;
  yes)	CGI_ICON_DIR=/eq-icons/
	AC_MSG_RESULT(${CGI_ICON_DIR})
	CGI_ICONS=true
	;;
  *)	CGI_ICON_DIR=${enableval}
	AC_MSG_RESULT(${CGI_ICON_DIR})
	CGI_ICONS=true
	;;
  esac ], [CGI_ICONS=false])
AC_SUBST(CGI_ICONS)
AC_SUBST(CGI_ICON_DIR)


AC_MSG_CHECKING(whether to enable debugging code and flags)
AC_ARG_ENABLE(debug,
  [  --disable-debug          turn off debugging code and flags ],
  [ case "${enableval}" in
    yes)
      AC_MSG_RESULT(yes)
      DEBUG="1"
      USE_DEBUG_C="-Wall -g -ggdb -DDEBUG"
      USE_DEBUG_CXX="-Wall -g -ggdb -DDEBUG"
      ac_cv_showeq_debug="${enableval}"
      ;;
    no)
      AC_MSG_RESULT(no)
      DEBUG=
      USE_DEBUG_C="-Wall -UDEBUG"
      USE_DEBUG_CXX="-Wall -UDEBUG"
      ac_cv_showeq_debug="${enableval}"
      ;;
    esac
  ],
  [ AC_MSG_RESULT(yes)
    USE_DEBUG_C="-Wall -g -ggdb -DDEBUG"
    USE_DEBUG_CXX="-Wall -g -ggdb -DDEBUG"
    ac_cv_sins_debug=yes
  ]
)

AC_SUBST(DEBUG)

AC_MSG_CHECKING(whether to build with optimization enabled)
AC_ARG_ENABLE(
  optimization,
  [  --disable-optimization  turn off compiler optimizations ],
  [ case "${enableval}" in
    yes)
      AC_MSG_RESULT(yes)
      USE_OPT_C="-O2"
      USE_OPT_CXX="-O2"
      ac_cv_showeq_optimization=yes
      ;;
    no)
      AC_MSG_RESULT(no)
      USE_OPT_C=
      USE_OPT_CXX=
      ac_cv_showeq_optimization=no
      ;;
    6)
      AC_MSG_RESULT(level 6)
      USE_OPT_C="-O6"
      USE_OPT_CXX="-O6"
      ac_cv_showeq_optimization="${enableval}"
      ;;
    3)
      AC_MSG_RESULT(level 3)
      USE_OPT_C="-O3"
      USE_OPT_CXX="-O3"
      ac_cv_showeq_optimization="${enableval}"
      ;;
    2)
      AC_MSG_RESULT(level 2)
      USE_OPT_C="-O2"
      USE_OPT_CXX="-O2"
      ac_cv_showeq_optimization="${enableval}"
      ;;
    1)
      AC_MSG_RESULT(level 1)
      USE_OPT_C="-O1"
      USE_OPT_CXX="-O1"
      ac_cv_showeq_optimization="${enableval}"
      ;;
    esac
  ],
  [ AC_MSG_RESULT(yes)
    USE_OPT_C="-02"
    USE_OPT_CXX="-O2"
    ac_cv_sins_optimization=yes
  ]
)

AC_MSG_CHECKING(whether to build with code inlined)
AC_ARG_ENABLE(inlines,
	[  --disable-inlines         Disable code inlining],
	[ case "${enableval}" in
	no)	AC_MSG_RESULT(no)
		USE_INLINE_C="-fno-inline-functions"
		USE_INLINE_CXX="-fno-inline-functions"
		ac_cv_showeq_inlines=no
		;;
	*)	AC_MSG_RESULT(yes);
		USE_INLINE_C="-finline-functions"
		USE_INLINE_CXX="-finline-functions"
		ac_cv_showeq_inlines=yes
		;;
	esac],
	[ AC_MSG_RESULT(yes);
	  USE_INLINE_C="-finline-functions"
	  USE_INLINE_CXX="-finline-functions"
	  ac_cv_showeq_inlines=yes
	]
)

MEMORY_LIBS=

AC_ARG_ENABLE(mpr,
	[  --enable-mpr            Compile with mpr],
	[ AC_MSG_CHECKING(whether to build with mpr)
	case "${enableval}" in
	yes)	AC_MSG_RESULT(yes);
		MEMORY_LIBS="-lmpr"
		ac_cv_showeq_mpr=yes
		;;
	*)	AC_MSG_RESULT(no)
		ac_cv_showeq_mpr=no
		;;
	esac] )

AC_ARG_ENABLE(mpatrol,
	[  --enable-mpatrol        Compile with mpatrol],
	[ AC_MSG_CHECKING(whether to build with mpatrol)
	case "${enableval}" in
	yes)	AC_MSG_RESULT(yes);
		MEMORY_LIBS="-lmpatrol -lbfd -liberty"
		ac_cv_showeq_mpatrol=yes
		;;
	*)	AC_MSG_RESULT(no)
		ac_cv_showeq_mpatrol=no
		;;
	esac] )
AC_SUBST(MEMORY_LIBS)

AC_MSG_CHECKING(whether to build with profiling)
AC_ARG_ENABLE(profiling,
	[  --enable-profiling      Compile with profiling data for gprof],
	[ case "${enableval}" in
	yes)	AC_MSG_RESULT(yes);
		USE_PROFILE_C="-pg"
		USE_PROFILE_CXX="-pg"
		PROFILE_LIBS="-pg"
		ac_cv_showeq_profiling=yes
		;;
	no)	AC_MSG_RESULT(no)
		USE_PROFILE_C=
		USE_PROFILE_CXX=
		PROFILE_LIBS=
		ac_cv_showeq_profiling=no
		;;
	esac],
	[ AC_MSG_RESULT(no)
	  USE_PROFILE_C=
	  USE_PROFILE_CXX=
	  PROFILE_LIBS=
	  ac_cv_showeq_profiling=no
	]
)
AC_SUBST(PROFILE_LIBS)

AC_MSG_CHECKING(whether to build for use with the test server)
AC_ARG_WITH(test-server,
	[  --with-test-server      Compile for use with the test server ],
	[  AC_MSG_RESULT(yes)
	   AC_DEFINE(TEST_SERVER, 1, Define if compiling for test server)
	   test_server=true ],
	[ AC_MSG_RESULT(no)
	  test_server=false ]
)
AM_CONDITIONAL(TEST_SERVER, test x$test_server = xtrue)

AC_CHECK_RPATH

CFLAGS="$USE_THREADS $USE_OPT_C $USE_DEBUG_C $USE_INLINE_C $USE_PROFILE_C $CFLAGS"
CXXFLAGS="$USE_THREADS $USE_OPT_CXX $USE_DEBUG_CXX $USE_INLINE_CXX  $USE_PROFILE_CXX -DQT_THREAD_SUPPORT=1 -DDISPLAY_ICONS=${CGI_ICONS} -DICON_DIR=\\\"${CGI_ICON_DIR}\\\" $CXXFLAGS"

AC_DEFUN([SUCCESS],[
echo "Success!"
case $target_os in
  solaris*)
    echo "<insert build instructions here>"
    ;;
  freebsd*)
    echo "Please run:"
    echo "  gmake"
    ;;
  linux*)
    echo "Please run:"
    echo "  make"
    ;;
esac
])

AC_OUTPUT([Makefile src/Makefile conf/Makefile])
SUCCESS