AC_PREREQ(2.59)

m4_define([webkit_major_version], [1])

m4_define([webkit_minor_version], [3])

m4_define([webkit_micro_version], [3])

# This is the version we'll be using as part of our User-Agent string

# e.g., AppleWebKit/$(webkit_user_agent_version) ...

#

# Sourced from WebCore/Configurations/Version.xcconfig

m4_define([webkit_user_agent_major_version], [531])

m4_define([webkit_user_agent_minor_version], [2])

AC_INIT([WebKit],[webkit_major_version.webkit_minor_version.webkit_micro_version],[http://bugs.webkit.org/])

AC_CONFIG_MACRO_DIR([autotools])

AC_CONFIG_AUX_DIR([autotools])

AC_SUBST(ACLOCAL_AMFLAGS, "-I autotools")

AC_CONFIG_HEADERS([autotoolsconfig.h])

AC_CANONICAL_HOST

WEBKIT_MAJOR_VERSION=webkit_major_version

WEBKIT_MINOR_VERSION=webkit_minor_version

WEBKIT_MICRO_VERSION=webkit_micro_version

WEBKIT_USER_AGENT_MAJOR_VERSION=webkit_user_agent_major_version

WEBKIT_USER_AGENT_MINOR_VERSION=webkit_user_agent_minor_version

AC_SUBST(WEBKIT_MAJOR_VERSION)

AC_SUBST(WEBKIT_MINOR_VERSION)

AC_SUBST(WEBKIT_MICRO_VERSION)

AC_SUBST(WEBKIT_USER_AGENT_MAJOR_VERSION)

AC_SUBST(WEBKIT_USER_AGENT_MINOR_VERSION)

AC_CONFIG_SRCDIR([WebCore/config.h])

dnl # Libtool library version, not to confuse with API version

dnl # see http://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html#Libtool-versioning

LIBWEBKITGTK_VERSION=0:1:0

AC_SUBST([LIBWEBKITGTK_VERSION])

AM_INIT_AUTOMAKE([foreign subdir-objects tar-ustar])

# Use AM_SILENT_RULES if present

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

# host checking - inspired by the GTK+ configure.in

# TODO: move these to webkit.m4?

AC_MSG_CHECKING([for native Win32])

case "$host" in

     *-*-mingw*)

       os_win32=yes

       ;;

     *)

       os_win32=no

       ;;

esac

AC_MSG_RESULT([$os_win32])

case "$host" in

     *-*-linux*)

       os_linux=yes

       ;;

     *-*-freebsd*)

       os_freebsd=yes

       ;;

     *-*-darwin*)

       os_darwin=yes

       ;;

esac

case "$host_os" in

     gnu* | linux* | k*bsd*-gnu)

       os_gnu=yes

       ;;

     *)

       os_gnu=no

       ;;

esac

# initialize webkit options

WEBKIT_INIT

AC_DISABLE_STATIC

AC_LIBTOOL_WIN32_DLL

AC_PROG_LIBTOOL

# use dolt to speedup the build

DOLT

AC_PATH_PROG(FLEX, flex)

if test -z "$FLEX"; then

   AC_MSG_ERROR([You need the 'flex' lexer generator to compile WebKit])

else

   FLEX_VERSION=`$FLEX --version | sed 's,.*\ \([0-9]*\.[0-9]*\.[0-9]*\)$,\1,'`

   AX_COMPARE_VERSION([2.5.33],[gt],[$FLEX_VERSION],

      AC_MSG_WARN([You need at least version 2.5.33 of the 'flex' lexer generator to compile WebKit correctly]))

fi

AC_PATH_PROG(GPERF, gperf)

if test -z "$GPERF"; then

   AC_MSG_ERROR([You need the 'gperf' hash function generator to compile WebKit])

fi

# pthread (not needed on Windows)

if test "$os_win32" = "no"; then

AC_CHECK_HEADERS([pthread.h],

                 AC_DEFINE([HAVE_PTHREAD_H],[1],[Define if pthread exists]),

                 AC_MSG_ERROR([pthread support is required to build WebKit]))

fi

# check for libjpeg the way Gtk does it.

AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,

                   jpeg_ok=yes, jpeg_ok=no

                   AC_MSG_ERROR([JPEG library (libjpeg) not found]))

if test "$jpeg_ok" = yes; then

   AC_MSG_CHECKING([for jpeglib])

   AC_TRY_CPP(

[#include <stdio.h>

#undef PACKAGE

#undef VERSION

#undef HAVE_STDLIB_H

#include <jpeglib.h>],

         jpeg_ok=yes,

         jpeg_ok=no)

   AC_MSG_RESULT($jpeg_ok)

   if test "$jpeg_ok" = yes; then

      JPEG_LIBS="-ljpeg"

      # should we check for progressive JPEG like GTK+ as well?

   else

      AC_MSG_ERROR([JPEG library (libjpeg) not found])

   fi

fi

AC_SUBST([JPEG_LIBS])

# Check for libpng the way Gtk+ does it

for l in libpng libpng14 libpng12; do

  AC_MSG_CHECKING(for $l)

  if $PKG_CONFIG --exists $l ; then

    AC_MSG_RESULT(yes)

    PNG_LIBS=`$PKG_CONFIG --libs $l`

    png_ok=yes

    break

  else

    AC_MSG_RESULT(no)

    png_ok=no

  fi

done

if test "$png_ok" != yes; then

  AC_CHECK_LIB(png, png_read_info,

    [AC_CHECK_HEADER(png.h,

      png_ok=yes,

      png_ok=no)],

    AC_MSG_ERROR([PNG library (libpng) not found]), -lz -lm)

  if test "$png_ok" = yes; then

    AC_MSG_CHECKING([for png_structp in png.h])

    AC_TRY_COMPILE([#include <png.h>],

      [png_structp pp; png_infop info; png_colorp cmap; png_create_read_struct;],

      png_ok=yes,

      png_ok=no)

    AC_MSG_RESULT($png_ok)

    if test "$png_ok" = yes; then

      PNG_LIBS='-lpng -lz'

    else

      AC_MSG_ERROR([PNG library (libpng) not found])

    fi

  else

    AC_MSG_ERROR([PNG library (libpng) not found])

  fi

fi

AC_SUBST([PNG_LIBS])

# determine the GTK+ version to use

AC_MSG_CHECKING([the GTK+ version to use])

AC_ARG_WITH([gtk],

        [AS_HELP_STRING([--with-gtk=2.0|3.0], [the GTK+ version to use (default: 2.0)])],

        [case "$with_gtk" in

        2.0|3.0) ;;

        *) AC_MSG_ERROR([invalid GTK+ version specified]) ;;

        esac],

        [with_gtk=2.0])

AC_MSG_RESULT([$with_gtk])

case "$with_gtk" in

     2.0) GTK_REQUIRED_VERSION=2.10

          GTK_API_VERSION=2.0

          WEBKITGTK_API_MAJOR_VERSION=1

          WEBKITGTK_API_MINOR_VERSION=0

          WEBKITGTK_API_VERSION=1.0

          WEBKITGTK_PC_NAME=webkit

          GAIL_PC_NAME=gail

          GAIL_REQUIRED_VERSION=1.8

          ;;

     3.0) GTK_REQUIRED_VERSION=2.90

          GTK_API_VERSION=3.0

          WEBKITGTK_API_MAJOR_VERSION=3

          WEBKITGTK_API_MINOR_VERSION=0

          WEBKITGTK_API_VERSION=3.0

          WEBKITGTK_PC_NAME=webkitgtk

          GAIL_PC_NAME=gail-3.0

          GAIL_REQUIRED_VERSION=2.90.4

          ;;

esac

AC_SUBST([WEBKITGTK_API_MAJOR_VERSION])

AC_SUBST([WEBKITGTK_API_MINOR_VERSION])

AC_SUBST([WEBKITGTK_API_VERSION])

AC_SUBST([WEBKITGTK_PC_NAME])

AC_SUBST([GTK_API_VERSION])

AM_CONDITIONAL([GTK_API_VERSION_2],[test "$GTK_API_VERSION" = "2.0"])

# determine the GDK/GTK+ target

AC_MSG_CHECKING([the target windowing system])

AC_ARG_WITH(target,

            AC_HELP_STRING([--with-target=@<:@x11/win32/quartz/directfb@:>@],

                           [Select webkit target [default=x11]]),

            [],[with_target="x11"])

case "$with_target" in

     x11|win32|quartz|directfb) ;;

     *) AC_MSG_ERROR([Invalid target: must be x11, quartz, win32, or directfb.]) ;;

esac

AC_MSG_RESULT([$with_target])

AC_MSG_CHECKING([for Hildon UI extensions])

AC_ARG_WITH(hildon,

            AC_HELP_STRING([--with-hildon],

                           [Use Hildon UI extensions [default=no]]),

            [],[with_hildon="no"])

AC_MSG_RESULT([$with_hildon])

if test "$with_hildon" = "yes"; then

    HILDON_CPPFLAGS="-DMAEMO_CHANGES"

    PKG_CHECK_MODULES([HILDON], [hildon-1])

    AC_SUBST([HILDON_CPPFLAGS])

    AC_SUBST([HILDON_CFLAGS])

    AC_SUBST([HILDON_LIBS])

fi

# minimum base dependencies

LIBSOUP_REQUIRED_VERSION=2.28.2

CAIRO_REQUIRED_VERSION=1.6

FONTCONFIG_REQUIRED_VERSION=2.4

FREETYPE2_REQUIRED_VERSION=9.0

LIBXML_REQUIRED_VERSION=2.6

# minimum GTK+ base dependencies

PANGO_REQUIRED_VERSION=1.12

# optional modules

LIBXSLT_REQUIRED_VERSION=1.1.7

SQLITE_REQUIRED_VERSION=3.0

GSTREAMER_REQUIRED_VERSION=0.10

GSTREAMER_PLUGINS_BASE_REQUIRED_VERSION=0.10.25

ENCHANT_REQUIRED_VERSION=0.22

# Available modules

#

# glib - glib and includes gthread

# unicode - check and identify which unicode backend to use

#

# todo: webcore gtk

WEBKIT_CHECK_DEPENDENCIES([glib unicode])

GETTEXT_PACKAGE=$PACKAGE-$GTK_API_VERSION

AC_SUBST(GETTEXT_PACKAGE)

AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE",

                   [The gettext catalog name])

PKG_CHECK_MODULES(LIBXML, libxml-2.0 >= $LIBXML_REQUIRED_VERSION)

AC_SUBST(LIBXML_CFLAGS)

AC_SUBST(LIBXML_LIBS)

PKG_CHECK_MODULES(PANGO, 

                  [pango >= $PANGO_REQUIRED_VERSION

                   pangoft2])

AC_SUBST(PANGO_CFLAGS)

AC_SUBST(PANGO_LIBS)

PKG_CHECK_MODULES(ENCHANT, enchant >= $ENCHANT_REQUIRED_VERSION)

AC_SUBST(ENCHANT_CFLAGS)

AC_SUBST(ENCHANT_LIBS)

PKG_CHECK_MODULES(GAIL, $GAIL_PC_NAME >= $GAIL_REQUIRED_VERSION)

AC_SUBST(GAIL_CFLAGS)

AC_SUBST(GAIL_LIBS)

# check for target-specific dependencies

if test "$with_target" = "directfb"; then

   PKG_CHECK_MODULES(CAIRO, cairo-directfb >= $CAIRO_REQUIRED_VERSION)

   PKG_CHECK_MODULES(GTK, gtk+-directfb-2.0 >= $GTK_REQUIRED_VERSION)

   AC_DEFINE([WTF_PLATFORM_DIRECTFB],[1],[Define if target is DirectFB])

else

   PKG_CHECK_MODULES(CAIRO, cairo >= $CAIRO_REQUIRED_VERSION)

   PKG_CHECK_MODULES(GTK, gtk+-$GTK_API_VERSION >= $GTK_REQUIRED_VERSION)

   if test "$with_target" = "x11" && test "$os_win32" = "no"; then

      # check for XT

      PKG_CHECK_MODULES([XT],

                        [xt],

                        [xt_has_pkg_config=yes],

                        [xt_has_pkg_config=no])

      # some old versions of Xt do not provide xt.pc, so try to link against Xt

      # and if it's installed fall back to just adding -lXt

      if test "$xt_has_pkg_config" = "no"; then

         # using AC_CHECK_LIB instead of AC_SEARCH_LIB is fine in this case as

         # we don't care about the XtOpenDisplay symbol but only about the

         # existence of libXt

         AC_CHECK_LIB([Xt], [XtOpenDisplay],

                      [XT_CFLAGS=""; XT_LIBS="-lXt"],

                      [AC_MSG_ERROR([X Toolkit Intrinsics library (libXt) not found])])

      fi

      AC_SUBST([XT_CFLAGS])

      AC_SUBST([XT_LIBS])

      AC_DEFINE([WTF_PLATFORM_X11],[1],[Define if target is X11])

   fi

fi

AC_SUBST(GTK_CFLAGS)

AC_SUBST(GTK_LIBS)

AC_SUBST(CAIRO_CFLAGS)

AC_SUBST(CAIRO_LIBS)

# check whether to build with debugging enabled

AC_MSG_CHECKING([whether to do a debug build])

AC_ARG_ENABLE(debug,

              AC_HELP_STRING([--enable-debug],

                             [turn on debugging [default=no]]),

              [],[enable_debug="no"])

AC_MSG_RESULT([$enable_debug])

# check whether to enable optimized builds

AC_MSG_CHECKING([whether to enable optimized builds])

AC_ARG_ENABLE(optimizations,

              AC_HELP_STRING([--enable-optimizations],

                             [turn on optimize builds (GCC only)

                             [default=yes]]),

              [enable_optimizations=$enableval],

              [if test "$enable_debug" = "yes"; then enable_optimizations="no"; else enable_optimizations="yes"; fi])

AC_MSG_RESULT([$enable_optimizations])

# check whether to enable 3D transforms support

AC_MSG_CHECKING([whether to enable support for 3D Transforms])

AC_ARG_ENABLE(3D_transforms,

              AC_HELP_STRING([--enable-3D-transforms],

                             [enable support for 3D transforms [default=no]]),

              [],[enable_3D_transforms="no"])

AC_MSG_RESULT([$enable_3D_transforms])

# check whether to enable channel messaging support

AC_MSG_CHECKING([whether to enable HTML5 Channel Messaging support])

AC_ARG_ENABLE(channel_messaging,

              AC_HELP_STRING([--enable-channel-messaging],

                             [enable HTML5 channel messaging support [default=yes]]),

              [],[enable_channel_messaging="yes"])

AC_MSG_RESULT([$enable_channel_messaging])

# check whether to enable JavaScript debugger/profiler support

AC_MSG_CHECKING([whether to enable JavaScript debugger/profiler support])

AC_ARG_ENABLE(javascript_debugger,

              AC_HELP_STRING([--enable-javascript-debugger],

                             [enable JavaScript debugger/profiler support [default=yes]]),

              [],[enable_javascript_debugger="yes"])

AC_MSG_RESULT([$enable_javascript_debugger])

# check whether to enable HTML5 Offline Web Applications support

AC_MSG_CHECKING([whether to enable HTML5 offline web applications support])

AC_ARG_ENABLE(offline_web_applications,

              AC_HELP_STRING([--enable-offline-web-applications],

                             [enable HTML5 offline web applications support [default=yes]]),

              [],[enable_offline_web_applications="yes"])

AC_MSG_RESULT([$enable_offline_web_applications])

# check whether to enable HTML5 client-side session and persitent storage support

AC_MSG_CHECKING([whether to enable HTML5 client-side session and persistent storage support])

AC_ARG_ENABLE(dom_storage,

              AC_HELP_STRING([--enable-dom-storage],

                             [enable HTML5 client-side session and persistent storage support [default=yes]]),

              [],[enable_dom_storage="yes"])

AC_MSG_RESULT([$enable_dom_storage])

# check whether to enable the indexed database API

AC_MSG_CHECKING([whether to enable the indexed database API])

AC_ARG_ENABLE(indexed_database,

              AC_HELP_STRING([--enable-indexeddb],

                             [enable the indexed database API [default=no]]),

              [],[enable_indexed_database="no"])

AC_MSG_RESULT([$enable_indexed_database])

# check whether to enable the speech input API

AC_MSG_CHECKING([whether to enable the speech input API])

AC_ARG_ENABLE(input_speech,

              AC_HELP_STRING([--enable-input-speech],

                             [enable the speech input API [default=no]]),

              [],[enable_input_speech="no"])

AC_MSG_RESULT([$enable_input_speech])

# check whether to build with database support

AC_MSG_CHECKING([whether to enable HTML5 client-side database storage support])

AC_ARG_ENABLE(database,

              AC_HELP_STRING([--enable-database],

                             [enable HTML5 client-side database storage support [default=yes]]),

              [],[enable_database="yes"])

AC_MSG_RESULT([$enable_database])

# check whether to build with server-sent events support

AC_MSG_CHECKING([whether to enable HTML5 server-sent events support])

AC_ARG_ENABLE(eventsource,

              AC_HELP_STRING([--enable-eventsource],

                             [enable HTML5 server-sent events support [default=yes]]),

              [],[enable_eventsource="yes"])

AC_MSG_RESULT([$enable_eventsource])

# check whether to build with icon database support

AC_MSG_CHECKING([whether to enable icon database support])

AC_ARG_ENABLE(icon_database,

              AC_HELP_STRING([--enable-icon-database],

                             [enable icon database [default=yes]]),

              [],[enable_icon_database="yes"])

AC_MSG_RESULT([$enable_icon_database])

# check whether to build with image resizer API support

AC_MSG_CHECKING([whether to enable image resizer API support])

AC_ARG_ENABLE(image_resizer,

              AC_HELP_STRING([--enable-image-resizer],

                             [enable image resizer [default=no]]),

              [],[enable_image_resizer="no"])

AC_MSG_RESULT([$enable_image_resizer])

# check whether to enable HTML5 datalist support

AC_MSG_CHECKING([whether to enable HTML5 datalist support])

AC_ARG_ENABLE(datalist,

              AC_HELP_STRING([--enable-datalist],

                             [enable HTML5 datalist support [default=yes]]),

              [],[enable_datalist="yes"])

AC_MSG_RESULT([$enable_datalist])

# check whether to enable HTML5 ruby support

AC_MSG_CHECKING([whether to enable HTML5 ruby support])

AC_ARG_ENABLE(ruby,

              AC_HELP_STRING([--enable-ruby],

                             [enable HTML5 ruby support [default=yes]]),

              [],[enable_ruby="yes"])

AC_MSG_RESULT([$enable_ruby])

# check whether to enable HTML5 sandbox iframe support

AC_MSG_CHECKING([whether to enable HTML5 sandboxed iframe support])

AC_ARG_ENABLE(sandbox,

              AC_HELP_STRING([--enable-sandbox],

                             [enable HTML5 sandboxed iframe support [default=yes]]),

              [],[enable_sandbox="yes"])

AC_MSG_RESULT([$enable_sandbox])

# check whether to enable HTML5 audio/video support

AC_MSG_CHECKING([whether to enable HTML5 video support])

AC_ARG_ENABLE(video,

              AC_HELP_STRING([--enable-video],

                             [enable HTML5 video support [default=yes]]),

              [],[enable_video="yes"])

AC_MSG_RESULT([$enable_video])

# check whether to enable XHTML-MP support

AC_MSG_CHECKING([whether to enable XHTML-MP support])

AC_ARG_ENABLE(xhtmlmp,

              AC_HELP_STRING([--enable-xhtmlmp],

                             [enable support for XHTML-MP [default=no]]),

              [],[enable_xhtmlmp="no"])

AC_MSG_RESULT([$enable_xhtmlmp])

# check whether to enable XPath support

AC_MSG_CHECKING([whether to enable XPath support])

AC_ARG_ENABLE(xpath,

              AC_HELP_STRING([--enable-xpath],

                             [enable support for XPath [default=yes]]),

              [],[enable_xpath="yes"])

AC_MSG_RESULT([$enable_xpath])

# check whether to enable XSLT support

AC_MSG_CHECKING([whether to enable XSLT support])

AC_ARG_ENABLE(xslt,

              AC_HELP_STRING([--enable-xslt],

                             [enable support for XSLT [default=yes]]),

              [],[enable_xslt="yes"])

AC_MSG_RESULT([$enable_xslt])

# check whether to enable geolocation support

AC_MSG_CHECKING([whether to enable geolocation support])

AC_ARG_ENABLE(geolocation,

              AC_HELP_STRING([--enable-geolocation],

                             [enable support for geolocation [default=no]]),

              [],[enable_geolocation="no"])

AC_MSG_RESULT([$enable_geolocation])

# check whether to enable MathML support

AC_MSG_CHECKING([whether to enable MathML support])

AC_ARG_ENABLE(mathml,

              AC_HELP_STRING([--enable-mathml],

                             [enable support for MathML [default=no]]),

              [],[enable_mathml="no"])

AC_MSG_RESULT([$enable_mathml])

# check whether to enable SVG support

AC_MSG_CHECKING([whether to enable SVG support])

AC_ARG_ENABLE(svg,

              AC_HELP_STRING([--enable-svg],

                             [enable support for SVG [default=yes]]),

              [],[enable_svg="yes"])

AC_MSG_RESULT([$enable_svg])

# check whether to enable WML support

AC_MSG_CHECKING([whether to enable WML support])

AC_ARG_ENABLE(wml,

              AC_HELP_STRING([--enable-wml],

                             [enable support for WML [default=no]]),

              [],[enable_wml="no"])

AC_MSG_RESULT([$enable_wml])

# check whether to enable SharedWorkers support

AC_MSG_CHECKING([whether to enable SharedWorkers support])

AC_ARG_ENABLE(shared_workers,

              AC_HELP_STRING([--enable-shared-workers],

                             [enable support for SharedWorkers [default=yes]]),

              [],[enable_shared_workers="yes"])

AC_MSG_RESULT([$enable_shared_workers])

# check whether to enable Web Workers support

AC_MSG_CHECKING([whether to enable Web Workers support])

AC_ARG_ENABLE(workers,

              AC_HELP_STRING([--enable-workers],

                             [enable support for Web Workers [default=yes]]),

              [],[enable_workers="yes"])