# $Id$
#
AC_INIT(wtap.c)

AC_PREREQ(2.52)

AC_CANONICAL_HOST
AC_CANONICAL_TARGET

AM_INIT_AUTOMAKE(libwtap.a, 0.0.0)
AM_CONFIG_HEADER(config.h)

AM_DISABLE_STATIC

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CPP
AC_PROG_YACC
AM_PROG_LEX
AC_PROG_LIBTOOL
AC_PATH_PROG(LEX, flex)

AC_SUBST(FLEX_PATH)


#
# Try to add some additional gcc checks to CFLAGS
#
AC_ARG_ENABLE(extra-gcc-checks,
  AC_HELP_STRING( [--enable-extra-gcc-checks],
		  [Do additional -W checks in GCC.  @<:@default=no@:>@]),
[
	wireshark_extra_gcc_flags=$enableval
	if test $enableval != no
	then
		AC_WIRETAP_GCC_CFLAGS_CHECK(-pedantic)
		AC_WIRETAP_GCC_CFLAGS_CHECK(-Wno-long-long)
		#Temporarily put cast-align here waiting eradication of 'cast
		#increases required alignment of target type' on the Solaris
		#slave. 
		AC_WIRETAP_GCC_CFLAGS_CHECK(-Wcast-align)
	fi
],)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wall -W)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wdeclaration-after-statement)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wendif-labels)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wpointer-arith)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wbad-function-cast)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wcast-qual)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wwrite-strings)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wshorten-64-to-32)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wstrict-prototypes)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wmissing-declarations)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wno-pointer-sign)
AC_WIRETAP_GCC_CFLAGS_CHECK(-Wcast-align)

#
# If we're running gcc add '-D_U_="__attribute__((unused))"' to CFLAGS as well,
# so we can use _U_ to flag unused function arguments and not get warnings
# about them. Otherwise, add '-D_U_=""', so that _U_ used to flag an unused
# function argument will compile with non-GCC compilers.
#
if test "x$GCC" = "xyes" ; then
  CFLAGS="-D_U_=\"__attribute__((unused))\" $CFLAGS"
else
  CFLAGS="-D_U_=\"\" $CFLAGS"
fi

#
# If we're running gcc, will enable a barrier "stop on warning". 
# This barrier is set for a very large part of the code. However, it is
# typically not set for "generated" code  (lex, ans2wrs, idl2wrs, ...)
#
AC_MSG_CHECKING(whether we should treat compiler warnings as errors)
AC_ARG_ENABLE(warnings-as-errors,
  AC_HELP_STRING( [--enable-warnings-as-errors],
                  [Treat warnings as errors (only for gcc). @<:@default=yes@:>@]),
[
  if test "x$GCC" = "xyes" -a "x$enableval" == "xyes" -a "x$wireshark_extra_gcc_flags" != "xyes"; then
    with_warnings_as_errors="yes"
    AC_MSG_RESULT(yes)
  else
    with_warnings_as_errors="no"
    AC_MSG_RESULT(no)
  fi
],
  if test "x$GCC" = "xyes" -a "x$wireshark_extra_gcc_flags" = "x"; then
    with_warnings_as_errors="yes"
    AC_MSG_RESULT(yes)
  else
    with_warnings_as_errors="no"
    AC_MSG_RESULT(no)
  fi
)
#
# Temporary one-shot - as we're turning the warning levels up, don't
# treat warnings as errors, so the build won't fail.
#
#AM_CONDITIONAL(HAVE_WARNINGS_AS_ERRORS, test "x$with_warnings_as_errors" = "xyes")
AM_CONDITIONAL(HAVE_WARNINGS_AS_ERRORS, test "1" = "0")

#
# Add any platform-specific compiler flags needed.
#
AC_MSG_CHECKING(for platform-specific compiler flags)
if test "x$GCC" = "xyes" ; then
	#
	# GCC - do any platform-specific tweaking necessary.
	#
	case "$host_os" in
	darwin*)
		#
		# See comments above about Apple's lovely C compiler.
		#
		CFLAGS="-no-cpp-precomp $CFLAGS"
		AC_MSG_RESULT(Apple GCC - added -no-cpp-precomp)
		;;
	*)
	AC_MSG_RESULT(none needed)
	;;
	esac
else
	#
	# Not GCC - assume it's the vendor's compiler.
	#
	case "$host_os" in
	hpux*)
		#
		# HP's ANSI C compiler; flags suggested by Jost Martin.
		# "-Ae" for ANSI C plus extensions such as "long long".
		# "+O2", for optimization.  XXX - works with "-g"?
		#
		CFLAGS="-Ae +O2 $CFLAGS"
		AC_MSG_RESULT(HP ANSI C compiler - added -Ae +O2)
		;;
	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.
		#
		CFLAGS="-no-cpp-precomp $CFLAGS"
		AC_MSG_RESULT(Apple GCC - added -no-cpp-precomp)
		;;
	*)
		AC_MSG_RESULT(none needed)
		;;
	esac
fi

#
# Add any platform-specific linker flags needed.
#
AC_MSG_CHECKING(for platform-specific linker flags)
case "$host_os" in
darwin*)
	#
	# Add -Wl,-single_module to the LDFLAGS used with shared
	# libraries, to fix some error that show up in some cases;
	# some Apple documentation recommends it for most shared
	# libraries.
	#
	LDFLAGS_SHAREDLIB="-Wl,-single_module"
	#
	# Add -Wl,-search_paths_first to make sure that if we search
	# directories A and B, in that order, for a given library, a
	# non-shared version in directory A, rather than a shared
	# version in directory B, is chosen (so we can use
	# --with-pcap=/usr/local to force all programs to be linked
	# with a static version installed in /usr/local/lib rather than
	# the system version in /usr/lib).
	#
	LDFLAGS="-Wl,-search_paths_first $LDFLAGS"
	AC_MSG_RESULT([Apple linker - added -Wl,-single_module and -Wl,-search_paths_first])
	;;
cygwin*)
	#
	# Shared libraries in cygwin/Win32 must never contain
	# undefined symbols.
	#
	LDFLAGS="$LDFLAGS -no-undefined"
	AC_MSG_RESULT(CygWin GNU ld - added -no-undefined)
	;;
*)
	AC_MSG_RESULT(none needed)
	;;
esac
AC_SUBST(LDFLAGS_SHAREDLIB)

AC_ARG_ENABLE(profile-build,
  AC_HELP_STRING( [--enable-profile-build],
		  [build profile-ready binaries.  @<:@default=no@:>@]),
    enable_profile_build=$enableval,enable_profile_build=no)

AM_CONDITIONAL(USE_PROFILE_BUILD, test x$enable_profile_build = xyes)
AC_MSG_CHECKING(if profile builds must be generated)
if test "x$enable_profile_build" = "xyes" ; then
	if test "x$GCC" = "xyes" ; then
		AC_MSG_RESULT(yes)
		CFLAGS=" -pg $CFLAGS"
	else
		AC_MSG_RESULT(no)
		echo "Building profile binaries currently only supported for GCC."
	fi
else
	AC_MSG_RESULT(no)
fi
	
AC_ARG_ENABLE(gtk2,
  AC_HELP_STRING( [--disable-gtk2],
                  [build Glib1/Gtk1+-based wireshark/tshark.  @<:@default=no@:>@]),
    enable_gtk2=$enableval,enable_gtk2=yes)

if test "x$enable_gtk2" = "xyes" ; then
	AM_PATH_GLIB_2_0(2.0.0, CFLAGS="$CFLAGS $GLIB_CFLAGS" LIBS="$LIBS $GLIB_LIBS", , gmodule)
else
	AM_PATH_GLIB(1.2.0, CFLAGS="$CFLAGS $GLIB_CFLAGS" LIBS="$LIBS $GLIB_LIBS", , gmodule)
fi

dnl Look in /usr/local for header files and libraries ?
AC_ARG_ENABLE(usr-local,
  AC_HELP_STRING( [--enable-usr-local],
                  [look for headers and libs in /usr/local tree.  @<:@default=yes@:>@]),
    enable_usr_local=$enableval,enable_usr_local=yes)

AC_MSG_CHECKING(whether to use /usr/local for headers and libraries)
if test "x$enable_usr_local" = "xyes" ; then
	AC_MSG_RESULT(yes)
	#
	# Arrange that we search for header files in "/usr/local/include",
	# as various packages we use ("libpcap", "zlib") may have been installed
	# under "/usr/local/include".
	#
	# We do this after checking for GLib, so that "-I/usr/local/include"
	# comes after any "-I" flags added by "AM_PATH_GLIB"; if the user has
	# installed a pre-1.2.9 version of GLib, it'd probably go under
	# "/usr/local", and if they then install 1.2.9 or later without
	# uninstalling the pre-1.2.9 version, 1.2.9's header files won't be
	# in "/usr/local/include" (they're put in a separate directory so that
	# GLib 1.2[.x] and 1.3[.x]/2.x can coexist), and if we search
	# "/usr/local/include" before searching the directory "AM_PATH_GLIB"
	# specifies, we may pick up headers from the older version.
	#
	CFLAGS="$CFLAGS -I/usr/local/include"
	CPPFLAGS="$CPPFLAGS -I/usr/local/include"

	#
	# Arrange that we search for libraries in "/usr/local/lib", as we'll
	# be testing whether zlib has gzgets, and we need to be able to find
	# zlib even if it's in "/usr/local/lib".
	#
	# We do this after checking for GLib; see above.
	#
	LDFLAGS="$LDFLAGS -L/usr/local/lib"
else
	AC_MSG_RESULT(no)
fi

dnl Checks for header files
AC_HEADER_STDC
AC_CHECK_HEADERS(sys/time.h netinet/in.h unistd.h fcntl.h sys/stat.h sys/types.h)

#
# Define WS_VAR_IMPORT appropriately for declarations of external
# variables exported from dynamically-linked libraries.
#
AC_DEFINE(WS_VAR_IMPORT, extern, [Define as the string to precede external variable declarations in dynamically-linked libraries])

# We must know our byte order
AC_C_BIGENDIAN

#
# Does GLib define G_GINT64_MODIFIER?
#
AC_MSG_CHECKING([[whether glib.h defines the G_GINT64_MODIFIER macro]])
AC_COMPILE_IFELSE(
  [
    AC_LANG_SOURCE(
      [[
	#include <glib.h>
	#if GTK_MAJOR_VERSION >= 2
	#include <glib/gprintf.h>
	#endif
	#include <stdio.h>

	main()
	{
	  char strbuf[16+1];
	  g_snprintf(strbuf, sizeof strbuf, "%" G_GINT64_MODIFIER "x\n", (gint64)1);
	}
      ]])
  ],
  [
    AC_MSG_RESULT(yes)
  ],
  [
    AC_MSG_RESULT(no)
    AC_WIRETAP_CHECK_64BIT_FORMAT(ll,
      [
	AC_WIRETAP_CHECK_64BIT_FORMAT(L,
	  [
	    AC_WIRETAP_CHECK_64BIT_FORMAT(q,
	      [
		AC_MSG_ERROR([neither %llx nor %Lx nor %qx worked on a 64-bit integer])
	      ])
	  ])
      ])
  ])

#
# Look for libpcap, so we can include <pcap.h> in libpcap.c if it's
# found.
#
# "--with-pcap" is merely done to allow the user to specify a directory
# in which to look for <pcap.h> (and so that specifying it to the
# top-level Wireshark configure script specifies it to the Wiretap
# configure script as well); we search for it regardless of whether
# "--without-pcap" was specified, as Wiretap isn't linked with it and
# there's no benefit to not looking for the header.
#
AC_ARG_WITH(pcap,
  AC_HELP_STRING( [--with-pcap=DIR],
                  [libpcap is located in directory DIR.]),
[
	if test $withval != yes -a $withval != no
	then
		pcap_dir=$withval
	fi
],[
	pcap_dir=
])
AC_WIRETAP_PCAP_CHECK

dnl zlib check
AC_MSG_CHECKING(whether to use zlib for reading compressed capture files)

AC_ARG_WITH(zlib,
  AC_HELP_STRING( [--with-zlib@<:@=DIR@:>@],
                  [use zlib (located in directory DIR, if supplied) to read compressed data.  @<:@default=yes, if present@:>@]),
[
	if test $withval = no
	then
		want_zlib=no
	elif test $withval = yes
	then
		want_zlib=yes
	else
		want_zlib=yes
		zlib_dir=$withval
	fi
],[
	#
	# Use zlib if it's present, otherwise don't.
	#
	want_zlib=ifpresent
	zlib_dir=
])
if test "x$want_zlib" = "xno" ; then
	AC_MSG_RESULT(no)
else
	AC_MSG_RESULT(yes)
	AC_WIRETAP_ZLIB_CHECK
	if test "x$want_zlib" = "xno" ; then
		AC_MSG_RESULT(zlib not found - disabling compressed capture file support)
	fi
fi

AC_OUTPUT(Makefile)