~ubuntu-branches/ubuntu/precise/enigmail/precise-security : contents of configure.in at revision 19

~ubuntu-branches/ubuntu/precise/enigmail/precise-security : (revision 19)
dnl -*- Mode: Autoconf; tab-width: 4; indent-tabs-mode: nil; -*-
dnl vi: set tabstop=4 shiftwidth=4 expandtab:
dnl ***** BEGIN LICENSE BLOCK *****
dnl Version: MPL 1.1/GPL 2.0/LGPL 2.1
dnl
dnl The contents of this file are subject to the Mozilla Public License Version
dnl 1.1 (the "License"); you may not use this file except in compliance with
dnl the License. You may obtain a copy of the License at
dnl http://www.mozilla.org/MPL/
dnl
dnl Software distributed under the License is distributed on an "AS IS" basis,
dnl WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
dnl for the specific language governing rights and limitations under the
dnl License.
dnl
dnl The Original Code is this file as it was released upon August 6, 1998.
dnl
dnl The Initial Developer of the Original Code is
dnl Christopher Seawood.
dnl Portions created by the Initial Developer are Copyright (C) 1998-2001
dnl the Initial Developer. All Rights Reserved.
dnl
dnl Contributor(s):
dnl   Jamie Zawinski <jwz@jwz.org>
dnl   gettimeofday args check
dnl   Christopher Blizzard <blizzard@appliedtheory.com>
dnl   gnomefe update & enable-pthreads
dnl   Ramiro Estrugo <ramiro@netscape.com>
dnl   X11 makedepend support
dnl   Insure support.
dnl   Henry Sobotka <sobotka@axess.com>
dnl   OS/2 support
dnl   Dan Mosedale <dmose@mozilla.org>
dnl   LDAP support
dnl   Seth Spitzer <sspitzer@netscape.com>
dnl   xpctools support
dnl   Benjamin Smedberg <benjamin@smedbergs.us>
dnl   Howard Chu <hyc@symas.com>
dnl   MSYS support
dnl   Mark Mentovai <mark@moxienet.com>:
dnl   Mac OS X 10.4 support
dnl   Giorgio Maone <g.maone@informaction.com>
dnl   MSVC l10n compatible version check
dnl   Ben Turner <mozilla@songbirdnest.com>
dnl
dnl Alternatively, the contents of this file may be used under the terms of
dnl either the GNU General Public License Version 2 or later (the "GPL"), or
dnl the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
dnl in which case the provisions of the GPL or the LGPL are applicable instead
dnl of those above. If you wish to allow use of your version of this file only
dnl under the terms of either the GPL or the LGPL, and not to allow others to
dnl use your version of this file under the terms of the MPL, indicate your
dnl decision by deleting the provisions above and replace them with the notice
dnl and other provisions required by the GPL or the LGPL. If you do not delete
dnl the provisions above, a recipient may use your version of this file under
dnl the terms of any one of the MPL, the GPL or the LGPL.
dnl
dnl ***** END LICENSE BLOCK *****

dnl Process this file with autoconf to produce a configure script.
dnl ========================================================

AC_PREREQ(2.13)
AC_INIT(config/config.mk)
AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
AC_CANONICAL_SYSTEM
TARGET_CPU="${target_cpu}"
TARGET_VENDOR="${target_vendor}"
TARGET_OS="${target_os}"


MOZ_DEB_TIMESTAMP=`date +"%a, %d  %b %Y %T %z"   2>&1` 
AC_SUBST(MOZ_DEB_TIMESTAMP)


dnl ========================================================
dnl =
dnl = Don't change the following two lines.  Doing so breaks:
dnl =
dnl = CFLAGS="-foo" ./configure
dnl =
dnl ========================================================
CFLAGS="${CFLAGS=}"
CPPFLAGS="${CPPFLAGS=}"
CXXFLAGS="${CXXFLAGS=}"
LDFLAGS="${LDFLAGS=}"
HOST_CFLAGS="${HOST_CFLAGS=}"
HOST_CXXFLAGS="${HOST_CXXFLAGS=}"
HOST_LDFLAGS="${HOST_LDFLAGS=}"

dnl ========================================================
dnl = Preserve certain environment flags passed to configure
dnl = We want sub projects to receive the same flags
dnl = untainted by this configure script
dnl ========================================================
_SUBDIR_CC="$CC"
_SUBDIR_CXX="$CXX"
_SUBDIR_CFLAGS="$CFLAGS"
_SUBDIR_CPPFLAGS="$CPPFLAGS"
_SUBDIR_CXXFLAGS="$CXXFLAGS"
_SUBDIR_LDFLAGS="$LDFLAGS"
_SUBDIR_HOST_CC="$HOST_CC"
_SUBDIR_HOST_CFLAGS="$HOST_CFLAGS"
_SUBDIR_HOST_CXXFLAGS="$HOST_CXXFLAGS"
_SUBDIR_HOST_LDFLAGS="$HOST_LDFLAGS"
_SUBDIR_CONFIG_ARGS="$ac_configure_args"

dnl Set the version number of the libs included with mozilla
dnl ========================================================
MOZJPEG=62
MOZPNG=10217
MOZZLIB=0x1230
NSPR_VERSION=4
NSS_VERSION=3

dnl Set the minimum version of toolkit libs used by mozilla
dnl ========================================================
GLIB_VERSION=1.2.0
LIBIDL_VERSION=0.6.3
PERL_VERSION=5.006
PYTHON_VERSION=2.4
CAIRO_VERSION=1.8.8
PANGO_VERSION=1.14.0
GTK2_VERSION=2.10.0
WINDRES_VERSION=2.14.90
W32API_VERSION=3.8
GNOMEVFS_VERSION=2.0
GNOMEUI_VERSION=2.2.0
GCONF_VERSION=1.2.1
LIBGNOME_VERSION=2.0
STARTUP_NOTIFICATION_VERSION=0.8
DBUS_VERSION=0.60
SQLITE_VERSION=3.6.22
LIBNOTIFY_VERSION=0.4

MSMANIFEST_TOOL=

dnl Set various checks
dnl ========================================================
MISSING_X=
AC_PROG_AWK

dnl Initialize the Pthread test variables early so they can be
dnl  overridden by each platform.
dnl ========================================================
USE_PTHREADS=
_PTHREAD_LDFLAGS=""

dnl Do not allow a separate objdir build if a srcdir build exists.
dnl ==============================================================
_topsrcdir=`cd \`dirname $0\`; pwd`
_objdir=`pwd`

if test "$_topsrcdir" != "$_objdir"
then
  # Check for a couple representative files in the source tree
  _conflict_files=
  for file in $_topsrcdir/Makefile $_topsrcdir/config/autoconf.mk; do
    if test -f $file; then
      _conflict_files="$_conflict_files $file"
    fi
  done
  if test "$_conflict_files"; then
    echo "***"
    echo "*   Your source tree contains these files:"
    for file in $_conflict_files; do
      echo "*         $file"
    done
    cat 1>&2 <<-EOF
	*   This indicates that you previously built in the source tree.
	*   A source tree build can confuse the separate objdir build.
	*
	*   To clean up the source tree:
	*     1. cd $_topsrcdir
	*     2. gmake distclean
	***
	EOF
    exit 1
    break
  fi
fi
MOZ_BUILD_ROOT=`pwd`

dnl Default to MSVC for win32
dnl ==============================================================
if test -z "$CROSS_COMPILE"; then
case "$target" in
*-cygwin*|*-mingw*|*-msvc*|*-mks*)
    if test -z "$CC"; then CC=cl; fi
    if test -z "$CXX"; then CXX=cl; fi
    if test -z "$CPP"; then CPP="cl -E -nologo"; fi
    if test -z "$CXXCPP"; then CXXCPP="cl -TP -E -nologo"; ac_cv_prog_CXXCPP="$CXXCPP"; fi
    if test -z "$LD"; then LD=link; fi
    if test -z "$AS"; then AS=ml; fi
    if test -z "$MIDL"; then MIDL=midl; fi
    ;;
esac
fi

COMPILE_ENVIRONMENT=1
MOZ_ARG_ENABLE_BOOL(compile-environment,
[  --disable-compile-environment
                           Disable compiler/library checks.],
    COMPILE_ENVIRONMENT=1,
    COMPILE_ENVIRONMENT= )
AC_SUBST(COMPILE_ENVIRONMENT)

MOZ_ARG_WITH_STRING(l10n-base,
[  --with-l10n-base=DIR     path to l10n repositories],
    L10NBASEDIR=$withval)
if test ! -z "$L10NBASEDIR"; then
    if test "$L10NBASEDIR" = "yes" -o "$L10NBASEDIR" = "no"; then
        AC_MSG_ERROR([--with-l10n-base must specify a path])
    elif test -d "$L10NBASEDIR"; then
        L10NBASEDIR=`cd "$L10NBASEDIR" && pwd`
    else
        AC_MSG_ERROR([Invalid value --with-l10n-base, $L10NBASEDIR doesn't exist])
    fi
fi
AC_SUBST(L10NBASEDIR)

dnl Check for Perl first -- needed for win32 SDK checks
MOZ_PATH_PROGS(PERL, $PERL perl5 perl )
if test -z "$PERL" || test "$PERL" = ":"; then
    AC_MSG_ERROR([perl not found in \$PATH])
fi

dnl ========================================================
dnl Checks for compilers.
dnl ========================================================
dnl Set CROSS_COMPILE in the environment when running configure
dnl to use the cross-compile setup for now
dnl ========================================================

if test "$COMPILE_ENVIRONMENT"; then

dnl Do some special WinCE toolchain stuff
case "$target" in
*wince)

    MOZ_ARG_WITH_STRING(wince-sdk,
    [  --with-wince-sdk=WINCE_SDK_DIR
                        The path to the Windows CE SDK],
    WINCE_SDK_DIR=$withval)

    MOZ_ARG_WITH_STRING(ogles-sdk,
    [  --with-ogles-sdk=OGLES_SDK_DIR
                        The path to the OGLES SDK],
    OGLES_SDK_DIR=$withval)

    dnl Default to Windows Mobile components enabled
    WINCE_WINDOWS_MOBILE=1

    MOZ_ARG_DISABLE_BOOL(windows-mobile-components,
    [  --disable-windows-mobile-components
         Disable Windows Mobile specific components from CE build],
    WINCE_WINDOWS_MOBILE=,
    WINCE_WINDOWS_MOBILE=1)

    if test "$WINCE_WINDOWS_MOBILE"; then
        AC_DEFINE(WINCE_WINDOWS_MOBILE)
    fi

    AC_DEFINE(WINCE)
    
    export WINCE=1

    echo -----------------------------------------------------------------------------
    echo Building Windows CE Shunt Library and Tool Chain
    echo Using SDK in:
    echo $WINCE_SDK_DIR

    ac_exeext=.exe

    _pwd=`pwd -W`
    _topsrcdirwin=`cd \`dirname $0\`; pwd -W`
    make OGLES_SDK_DIR="$OGLES_SDK_DIR" WINCE_SDK_DIR="$WINCE_SDK_DIR" TOPSRCDIR="$_topsrcdirwin" OBJDIR="$_pwd" -C $srcdir/build/wince/tools

    CC="$_pwd/dist/sdk/bin/arm-wince-gcc.exe"
    CXX="$_pwd/dist/sdk/bin/arm-wince-gcc.exe"
    CPP="$_pwd/dist/sdk/bin/arm-wince-gcc.exe -E -nologo"
    CXXCPP="$_pwd/dist/sdk/bin/arm-wince-gcc.exe -TP -E -nologo"
    LD="$_pwd/dist/sdk/bin/arm-wince-link.exe"
    AR="$_pwd/dist/sdk/bin/arm-wince-lib.exe"
    AS="$_pwd/dist/sdk/bin/arm-wince-as.exe"
    RC="$_pwd/dist/sdk/bin/arm-wince-res.exe"


    echo -----------------------------------------------------------------------------

    ;;
esac

if test -n "$CROSS_COMPILE" && test "$target" != "$host"; then
    echo "cross compiling from $host to $target"
    cross_compiling=yes

    _SAVE_CC="$CC"
    _SAVE_CFLAGS="$CFLAGS"
    _SAVE_LDFLAGS="$LDFLAGS"

    AC_MSG_CHECKING([for host c compiler])
    AC_CHECK_PROGS(HOST_CC, $HOST_CC gcc cc /usr/ucb/cc cl icc, "")
    if test -z "$HOST_CC"; then
        AC_MSG_ERROR([no acceptable c compiler found in \$PATH])
    fi
    AC_MSG_RESULT([$HOST_CC])
    AC_MSG_CHECKING([for host c++ compiler])
    AC_CHECK_PROGS(HOST_CXX, $HOST_CXX $CCC c++ g++ gcc CC cxx cc++ cl icc, "")
    if test -z "$HOST_CXX"; then
        AC_MSG_ERROR([no acceptable c++ compiler found in \$PATH])
    fi
    AC_MSG_RESULT([$HOST_CXX])

    if test -z "$HOST_CFLAGS"; then
        HOST_CFLAGS="$CFLAGS"
    fi
    if test -z "$HOST_CXXFLAGS"; then
        HOST_CXXFLAGS="$CXXFLAGS"
    fi
    if test -z "$HOST_LDFLAGS"; then
        HOST_LDFLAGS="$LDFLAGS"
    fi
    AC_CHECK_PROGS(HOST_RANLIB, $HOST_RANLIB ranlib, ranlib, :)
    AC_CHECK_PROGS(HOST_AR, $HOST_AR ar, ar, :)
    CC="$HOST_CC"
    CFLAGS="$HOST_CFLAGS"
    LDFLAGS="$HOST_LDFLAGS"

    AC_MSG_CHECKING([whether the host c compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
    AC_TRY_COMPILE([], [return(0);], 
	[ac_cv_prog_hostcc_works=1 AC_MSG_RESULT([yes])],
	AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CC cannot create executables.]) )

    CC="$HOST_CXX"
    CFLAGS="$HOST_CXXFLAGS"

    AC_MSG_CHECKING([whether the host c++ compiler ($HOST_CXX $HOST_CXXFLAGS $HOST_LDFLAGS) works])
    AC_TRY_COMPILE([], [return(0);], 
	[ac_cv_prog_hostcxx_works=1 AC_MSG_RESULT([yes])],
	AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CXX cannot create executables.]) )
    
    CC=$_SAVE_CC
    CFLAGS=$_SAVE_CFLAGS
    LDFLAGS=$_SAVE_LDFLAGS

    case "$build:$target" in
      powerpc-apple-darwin8*:i?86-apple-darwin*)
        dnl The Darwin cross compiler doesn't necessarily point itself at a
        dnl root that has libraries for the proper architecture, it defaults
        dnl to the system root.  The libraries in the system root on current
        dnl versions of PPC OS X 10.4 aren't fat, so these target compiler
        dnl checks will fail.  Fake a working SDK in that case.
        _SAVE_CFLAGS=$CFLAGS
        _SAVE_CXXFLAGS=$CXXLAGS
        CFLAGS="-isysroot /Developer/SDKs/MacOSX10.4u.sdk $CFLAGS"
        CXXFLAGS="-isysroot /Developer/SDKs/MacOSX10.4u.sdk $CXXFLAGS"
        ;;
    esac

    AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", :)
    unset ac_cv_prog_CC
    AC_PROG_CC
    AC_CHECK_PROGS(CXX, $CXX "${target_alias}-g++" "${target}-g++", :)
    unset ac_cv_prog_CXX
    AC_PROG_CXX

    case "$build:$target" in
      powerpc-apple-darwin8*:i?86-apple-darwin*)
        dnl Revert the changes made above.  From this point on, the target
        dnl compiler will never be used without applying the SDK to CFLAGS
        dnl (see --with-macos-sdk below).
        CFLAGS=$_SAVE_CFLAGS
        CXXFLAGS=$_SAVE_CXXFLAGS
        ;;
    esac

    AC_CHECK_PROGS(RANLIB, $RANLIB "${target_alias}-ranlib" "${target}-ranlib", :)
    AC_CHECK_PROGS(AR, $AR "${target_alias}-ar" "${target}-ar", :)
    MOZ_PATH_PROGS(AS, $AS "${target_alias}-as" "${target}-as", :)
    AC_CHECK_PROGS(LD, $LD "${target_alias}-ld" "${target}-ld", :)
    AC_CHECK_PROGS(STRIP, $STRIP "${target_alias}-strip" "${target}-strip", :)
    AC_CHECK_PROGS(WINDRES, $WINDRES "${target_alias}-windres" "${target}-windres", :)
    AC_DEFINE(CROSS_COMPILE)
else
    AC_PROG_CC
    AC_PROG_CXX
    AC_PROG_RANLIB
    MOZ_PATH_PROGS(AS, $AS as, $CC)
    AC_CHECK_PROGS(AR, ar, :)
    AC_CHECK_PROGS(LD, ld, :)
    AC_CHECK_PROGS(STRIP, strip, :)
    AC_CHECK_PROGS(WINDRES, windres, :)
    if test -z "$HOST_CC"; then
        HOST_CC="$CC"
    fi
    if test -z "$HOST_CFLAGS"; then
        HOST_CFLAGS="$CFLAGS"
    fi
    if test -z "$HOST_CXX"; then
        HOST_CXX="$CXX"
    fi
    if test -z "$HOST_CXXFLAGS"; then
        HOST_CXXFLAGS="$CXXFLAGS"
    fi
    if test -z "$HOST_LDFLAGS"; then
        HOST_LDFLAGS="$LDFLAGS"
    fi
    if test -z "$HOST_RANLIB"; then
        HOST_RANLIB="$RANLIB"
    fi
    if test -z "$HOST_AR"; then
       HOST_AR="$AR"
    fi
fi

GNU_AS=
GNU_LD=
GNU_CC=
GNU_CXX=
CC_VERSION='N/A'
CXX_VERSION='N/A'
if test "$GCC" = "yes"; then
    GNU_CC=1
    CC_VERSION=`$CC -v 2>&1 | grep 'gcc version'`
fi
if test "$GXX" = "yes"; then
    GNU_CXX=1
    CXX_VERSION=`$CXX -v 2>&1 | grep 'gcc version'`
fi
if test "`echo | $AS -v 2>&1 | grep -c GNU`" != "0"; then
    GNU_AS=1
fi
if test "`echo | $LD -v 2>&1 | grep -c GNU`" != "0"; then
    GNU_LD=1
fi
if test "$GNU_CC"; then
    if `$CC -print-prog-name=ld` -v 2>&1 | grep -c GNU >/dev/null; then
        GCC_USE_GNU_LD=1
    fi
fi

INTEL_CC=
INTEL_CXX=
if test "$GCC" = yes; then
   if test "`$CC -help 2>&1 | grep -c 'Intel(R) C Compiler'`" != "0"; then
     INTEL_CC=1
   fi
fi

if test "$GXX" = yes; then
   if test "`$CXX -help 2>&1 | grep -c 'Intel(R) C++ Compiler'`" != "0"; then
     INTEL_CXX=1
   fi
fi

dnl Special win32 checks
dnl ========================================================
case "$target" in
*-wince)
    WINVER=500
    ;;
*)
    WINVER=502
    ;;
esac

dnl Target the Windows 7 SDK by default
WINSDK_TARGETVER=601

MOZ_ARG_WITH_STRING(windows-version,
[  --with-windows-version=WINSDK_TARGETVER
                          Highest Windows version to target using this SDK
                              502: Windows Server 2003
                              600: Windows Vista
                              601: Windows 7],
  WINSDK_TARGETVER=$withval)

case "$WINSDK_TARGETVER" in
502|600|601)
    MOZ_WINSDK_TARGETVER=0${WINSDK_TARGETVER}0000
    ;;

*)
    AC_MSG_ERROR([Invalid value for --with-windows-version ($WINSDK_TARGETVER), must be 502, 600 or 601]);
    ;;

esac

dnl Vista SDK specific api (deprecated)
MOZ_ARG_DISABLE_BOOL(vista-sdk-requirements,
[  --disable-vista-sdk-requirements
                           Do not build Vista SDK specific code],
   MOZ_DISABLE_VISTA_SDK_REQUIREMENTS=1,
   MOZ_DISABLE_VISTA_SDK_REQUIREMENTS=)
if test -n "$COMPILE_ENVIRONMENT"; then
if test -n "$MOZ_DISABLE_VISTA_SDK_REQUIREMENTS"; then
    AC_MSG_WARN([--disable-vista-sdk-requirements is deprecated, use --with-windows-version=502 instead])
    MOZ_WINSDK_TARGETVER=05020000
fi

if test "$MOZ_WINSDK_TARGETVER" -lt "06000000"; then
    MOZ_DISABLE_VISTA_SDK_REQUIREMENTS=1
    AC_DEFINE(MOZ_DISABLE_VISTA_SDK_REQUIREMENTS)
    # We can't build parental controls either
    MOZ_DISABLE_PARENTAL_CONTROLS=1
fi
fi

AC_SUBST(MOZ_DISABLE_VISTA_SDK_REQUIREMENTS)

case "$target" in
*-cygwin*|*-mingw*|*-msvc*|*-mks*|*-wince)
    if test "$GCC" != "yes"; then
        # Check to see if we are really running in a msvc environemnt
        _WIN32_MSVC=1
        AC_CHECK_PROGS(MIDL, midl)

        # Make sure compilers are valid
        CFLAGS="$CFLAGS -TC -nologo"
        CXXFLAGS="$CXXFLAGS -TP -nologo"
        AC_LANG_SAVE
        AC_LANG_C
        AC_TRY_COMPILE([#include <stdio.h>],
            [ printf("Hello World\n"); ],,
            AC_MSG_ERROR([\$(CC) test failed.  You must have MS VC++ in your path to build.]) )

        AC_LANG_CPLUSPLUS
        AC_TRY_COMPILE([#include <new.h>],
            [ unsigned *test = new unsigned(42); ],,
            AC_MSG_ERROR([\$(CXX) test failed.  You must have MS VC++ in your path to build.]) )
        AC_LANG_RESTORE
        
        changequote(,)
        _MSVC_VER_FILTER='s|.* ([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?).*|\1|p'
        changequote([,])
        
        # Determine compiler version
        CC_VERSION=`"${CC}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _CC_MAJOR_VERSION=`echo ${CC_VERSION} | $AWK -F\. '{ print $1 }'`
        _CC_MINOR_VERSION=`echo ${CC_VERSION} | $AWK -F\. '{ print $2 }'`
        _CC_RELEASE=`echo ${CC_VERSION} | $AWK -F\. '{ print $3 }'`
        _CC_BUILD=`echo ${CC_VERSION} | $AWK -F\. '{ print $4 }'`
        _MSC_VER=${_CC_MAJOR_VERSION}${_CC_MINOR_VERSION}

        CXX_VERSION=`"${CXX}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _CXX_MAJOR_VERSION=`echo ${CXX_VERSION} | $AWK -F\. '{ print $1 }'`

        if test "$_CC_MAJOR_VERSION" != "$_CXX_MAJOR_VERSION"; then
            AC_MSG_ERROR([The major versions of \$CC and \$CXX do not match.])
        fi
        if test "$_CC_MAJOR_VERSION" = "13"; then
            _CC_SUITE=7
        elif test "$_CC_MAJOR_VERSION" = "14"; then
            _CC_SUITE=8
            CXXFLAGS="$CXXFLAGS -Zc:wchar_t-"
            dnl -DYNAMICBASE is only supported on VC8SP1 or newer,
            dnl so be very specific here!
            dnl VC8 is 14.00.50727.42, VC8SP1 is 14.00.50727.762
            if test $_CC_RELEASE -gt 50727; then
               _USE_DYNAMICBASE=1
            elif test $_CC_BUILD -ge 762; then
               _USE_DYNAMICBASE=1
            fi
            AC_DEFINE(_CRT_SECURE_NO_DEPRECATE)
            AC_DEFINE(_CRT_NONSTDC_NO_DEPRECATE)
        elif test "$_CC_MAJOR_VERSION" = "15"; then
            _CC_SUITE=9
            CXXFLAGS="$CXXFLAGS -Zc:wchar_t-"
            LDFLAGS="$LDFLAGS -MANIFESTUAC:NO"
            _USE_DYNAMICBASE=1
            AC_DEFINE(_CRT_SECURE_NO_WARNINGS)
            AC_DEFINE(_CRT_NONSTDC_NO_WARNINGS)
        else
            AC_MSG_ERROR([This version of the MSVC compiler, $CC_VERSION , is unsupported.])
        fi

        _MOZ_RTTI_FLAGS_ON='-GR'
        _MOZ_RTTI_FLAGS_OFF='-GR-'
        _MOZ_EXCEPTIONS_FLAGS_ON='-EHsc'
        _MOZ_EXCEPTIONS_FLAGS_OFF=''

        if test -n "$WIN32_REDIST_DIR"; then
            WIN32_REDIST_DIR=`cd "$WIN32_REDIST_DIR" && pwd`
        fi
	
        # bug #249782
        # ensure that mt.exe is Microsoft (R) Manifest Tool and not magnetic tape manipulation utility (or something else)
        if test "$_CC_SUITE" -ge "8"; then
                changequote(,)
                _MSMT_VER_FILTER='s|.* \([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*|\1|p'
                changequote([,])

                MSMT_TOOL=`mt 2>&1|grep 'Microsoft (R) Manifest Tool'`
                if test -n "$MSMT_TOOL"; then
                        MSMANIFEST_TOOL_VERSION=`echo ${MSMT_TOOL}|sed -ne "$_MSMT_VER_FILTER"`
                        if test -z "$MSMANIFEST_TOOL_VERSION"; then
                                AC_MSG_WARN([Unknown version of the Microsoft (R) Manifest Tool.])
                        fi
                        MSMANIFEST_TOOL=1
                        unset MSMT_TOOL
                else
                        AC_MSG_ERROR([Microsoft (R) Manifest Tool must be in your \$PATH.])
                fi
        fi

        # Check linker version
        _LD_FULL_VERSION=`"${LD}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _LD_MAJOR_VERSION=`echo ${_LD_FULL_VERSION} | $AWK -F\. '{ print $1 }'`
        if test "$_LD_MAJOR_VERSION" != "$_CC_SUITE"; then
            AC_MSG_ERROR([The linker major version, $_LD_FULL_VERSION,  does not match the compiler suite version, $_CC_SUITE.])
        fi
        INCREMENTAL_LINKER=1

        # Check midl version
        _MIDL_FULL_VERSION=`"${MIDL}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _MIDL_MAJOR_VERSION=`echo ${_MIDL_FULL_VERSION} | $AWK -F\. '{ print $1 }'`
        _MIDL_MINOR_VERSION=`echo ${_MIDL_FULL_VERSION} | $AWK -F\. '{ print $2 }'`
        _MIDL_REV_VERSION=`echo ${_MIDL_FULL_VERSION} | $AWK -F\. '{ print $3 }'`
        # Add flags if necessary
        AC_MSG_CHECKING([for midl flags])
        case "$target" in
        i*86-*)
            if test \( "$_MIDL_MAJOR_VERSION" = "7" -a "$_MIDL_MINOR_VERSION" = "00" -a "$_MIDL_REV_VERSION" = "0499" \); then
                # MIDL version 7.00.0499 defaults /env win64 on x64 platforms.
                # MIDL version 7.00.0500 or later has no problem.
                MIDL_FLAGS="${MIDL_FLAGS} -env win32"
                AC_MSG_RESULT([need -env win32])
            else
                AC_MSG_RESULT([none needed])
            fi
            ;;
        *)
            AC_MSG_RESULT([none needed])
            ;;
        esac

        # Identify which version of the SDK we're building with
        # Windows Server 2008 and newer SDKs have WinSDKVer.h, get the version
        # from there
        AC_CHECK_HEADERS([winsdkver.h])
        if test "$ac_cv_header_winsdkver_h" = "yes"; then
            # Get the highest _WIN32_WINNT and NTDDI versions supported
            # Take the higher of the two
            # This is done because the Windows 7 beta SDK reports its
            # NTDDI_MAXVER to be 0x06000100 instead of 0x06010000, as it should
            AC_CACHE_CHECK(for highest Windows version supported by this SDK,
                           ac_cv_winsdk_maxver,
                           [cat > conftest.h <<EOF
#include <winsdkver.h>
#include <sdkddkver.h>

#if (NTDDI_VERSION_FROM_WIN32_WINNT(_WIN32_WINNT_MAXVER) > NTDDI_MAXVER)
#define WINSDK_MAXVER NTDDI_VERSION_FROM_WIN32_WINNT(_WIN32_WINNT_MAXVER)
#else
#define WINSDK_MAXVER NTDDI_MAXVER
#endif

WINSDK_MAXVER
EOF
                            ac_cv_winsdk_maxver=`$CPP conftest.h 2>/dev/null | tail -n1`
                            rm -f conftest.h
                           ])
            MOZ_WINSDK_MAXVER=${ac_cv_winsdk_maxver}
        else
            # The Vista SDK is the only one to have sdkddkver.h but not
            # WinSDKVer.h
            AC_CHECK_HEADERS([sdkddkver.h])
            if test "$ac_cv_header_sdkddkver_h" = "yes"; then
                MOZ_WINSDK_MAXVER=0x06000000
            else
                # Assume the Server 2003 Platform SDK
                MOZ_WINSDK_MAXVER=0x05020000
            fi
        fi

        unset _MSVC_VER_FILTER

    else
        # Check w32api version
        _W32API_MAJOR_VERSION=`echo $W32API_VERSION | $AWK -F\. '{ print $1 }'`
        _W32API_MINOR_VERSION=`echo $W32API_VERSION | $AWK -F\. '{ print $2 }'`
        AC_MSG_CHECKING([for w32api version >= $W32API_VERSION])
        AC_TRY_COMPILE([#include <w32api.h>],
            #if (__W32API_MAJOR_VERSION < $_W32API_MAJOR_VERSION) || \
                (__W32API_MAJOR_VERSION == $_W32API_MAJOR_VERSION && \
                 __W32API_MINOR_VERSION < $_W32API_MINOR_VERSION)
                #error "test failed."
            #endif
            , [ res=yes ], [ res=no ])
        AC_MSG_RESULT([$res])
        if test "$res" != "yes"; then
            AC_MSG_ERROR([w32api version $W32API_VERSION or higher required.])
        fi
        # Check windres version
        AC_MSG_CHECKING([for windres version >= $WINDRES_VERSION])
        _WINDRES_VERSION=`${WINDRES} --version 2>&1 | grep -i windres 2>/dev/null | $AWK '{ print $3 }'`
        AC_MSG_RESULT([$_WINDRES_VERSION])
        _WINDRES_MAJOR_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $1 }'`
        _WINDRES_MINOR_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $2 }'`
        _WINDRES_RELEASE_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $3 }'`
        WINDRES_MAJOR_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $1 }'`
        WINDRES_MINOR_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $2 }'`
        WINDRES_RELEASE_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $3 }'`
        if test "$_WINDRES_MAJOR_VERSION" -lt "$WINDRES_MAJOR_VERSION" -o \
                "$_WINDRES_MAJOR_VERSION" -eq "$WINDRES_MAJOR_VERSION" -a \
                "$_WINDRES_MINOR_VERSION" -lt "$WINDRES_MINOR_VERSION" -o \
                "$_WINDRES_MAJOR_VERSION" -eq "$WINDRES_MAJOR_VERSION" -a \
                "$_WINDRES_MINOR_VERSION" -eq "$WINDRES_MINOR_VERSION" -a \
                "$_WINDRES_RELEASE_VERSION" -lt "$WINDRES_RELEASE_VERSION"
        then
            AC_MSG_ERROR([windres version $WINDRES_VERSION or higher is required to build.])
        fi

        # Server 2003 is the highest version supported
        MOZ_WINSDK_MAXVER=0x05020000
    fi # !GNU_CC

    AC_DEFINE_UNQUOTED(WINVER,0x$WINVER)
    AC_DEFINE_UNQUOTED(_WIN32_WINNT,0x$WINVER)
    # Require OS features provided by IE 5.0
    AC_DEFINE_UNQUOTED(_WIN32_IE,0x0500)

    # If the maximum version supported by this SDK is lower than the target
    # version, error out
    AC_MSG_CHECKING([for Windows SDK being recent enough])
    if $PERL -e "exit(0x$MOZ_WINSDK_TARGETVER > $MOZ_WINSDK_MAXVER)"; then
        AC_MSG_RESULT("yes")
    else
        AC_MSG_RESULT("no")
        AC_MSG_ERROR([You are targeting Windows version 0x$MOZ_WINSDK_TARGETVER, but your SDK only supports up to version $MOZ_WINSDK_MAXVER. Install and use an updated SDK, or target a lower version using --with-windows-version. See https://developer.mozilla.org/En/Windows_SDK_versions for more details on fixing this.])
    fi

    AC_DEFINE_UNQUOTED(MOZ_WINSDK_TARGETVER,0x$MOZ_WINSDK_TARGETVER)
    # Definitions matching sdkddkver.h
    AC_DEFINE_UNQUOTED(MOZ_NTDDI_WS03, 0x05020000)
    AC_DEFINE_UNQUOTED(MOZ_NTDDI_LONGHORN, 0x06000000)
    AC_DEFINE_UNQUOTED(MOZ_NTDDI_WIN7, 0x06010000)
    ;;
esac

dnl Test breaks icc on OS/2 && MSVC
if test "$CC" != "icc" -a -z "$_WIN32_MSVC"; then
    AC_PROG_CC_C_O
    if grep "NO_MINUS_C_MINUS_O 1" ./confdefs.h >/dev/null; then
        USING_HCC=1
        _OLDCC=$CC
        _OLDCXX=$CXX
        CC="${srcdir}/build/hcc '$CC'"
        CXX="${srcdir}/build/hcpp '$CXX'"
    fi
fi

AC_PROG_CPP
AC_PROG_CXXCPP

if test -n "$_WIN32_MSVC"; then
    SKIP_PATH_CHECKS=1
    SKIP_COMPILER_CHECKS=1
    SKIP_LIBRARY_CHECKS=1

    # Since we're skipping compiler and library checks, hard-code
    # some facts here.
    case "$target" in
    *-wince)
        ;;
    *)
        AC_DEFINE(HAVE_IO_H)
        AC_DEFINE(HAVE_SETBUF)
        AC_DEFINE(HAVE_ISATTY)
        ;;
    esac
fi

fi # COMPILE_ENVIRONMENT

AC_SUBST(MIDL_FLAGS)
AC_SUBST(_MSC_VER)

AC_SUBST(GNU_AS)
AC_SUBST(GNU_LD)
AC_SUBST(GNU_CC)
AC_SUBST(GNU_CXX)
AC_SUBST(INTEL_CC)
AC_SUBST(INTEL_CXX)

dnl ========================================================
dnl Checks for programs.
dnl ========================================================
AC_PROG_INSTALL
AC_PROG_LN_S

if test -z "$TINDERBOX_SKIP_PERL_VERSION_CHECK"; then
AC_MSG_CHECKING([for minimum required perl version >= $PERL_VERSION])
_perl_version=`PERL_VERSION=$PERL_VERSION $PERL -e 'print "$]"; if ($] >= $ENV{PERL_VERSION}) { exit(0); } else { exit(1); }' 2>&5`
_perl_res=$?
AC_MSG_RESULT([$_perl_version])

if test "$_perl_res" != 0; then
    AC_MSG_ERROR([Perl $PERL_VERSION or higher is required.])
fi
fi

AC_MSG_CHECKING([for full perl installation])
_perl_archlib=`$PERL -e 'use Config; if ( -d $Config{archlib} ) { exit(0); } else { exit(1); }' 2>&5`
_perl_res=$?
if test "$_perl_res" != 0; then
    AC_MSG_RESULT([no])
    AC_MSG_ERROR([Cannot find Config.pm or \$Config{archlib}.  A full perl installation is required.])
else
    AC_MSG_RESULT([yes])    
fi

MOZ_PATH_PROGS(PYTHON, $PYTHON python2.5 python2.4 python)
if test -z "$PYTHON"; then
    AC_MSG_ERROR([python was not found in \$PATH])
fi

if test -z "$COMPILE_ENVIRONMENT"; then
    NSINSTALL_BIN='$(PYTHON) $(topsrcdir)/config/nsinstall.py'
fi
AC_SUBST(NSINSTALL_BIN)

MOZ_PATH_PROG(DOXYGEN, doxygen, :)
MOZ_PATH_PROG(WHOAMI, whoami, :)
MOZ_PATH_PROG(AUTOCONF, autoconf, :)
MOZ_PATH_PROG(UNZIP, unzip, :)
MOZ_PATH_PROGS(ZIP, zip)
if test -z "$ZIP" || test "$ZIP" = ":"; then
    AC_MSG_ERROR([zip not found in \$PATH])
fi
MOZ_PATH_PROG(SYSTEM_MAKEDEPEND, makedepend)
MOZ_PATH_PROG(XARGS, xargs)
if test -z "$XARGS" || test "$XARGS" = ":"; then
    AC_MSG_ERROR([xargs not found in \$PATH .])
fi

if test "$COMPILE_ENVIRONMENT"; then

dnl ========================================================
dnl = Mac OS X toolchain support
dnl ========================================================

case "$target_os" in
darwin*)
    dnl Current known valid versions for GCC_VERSION are 2.95.2 3.1 3.3 4.0.
    dnl 4.0 identifies itself as 4.0.x, so strip the decidecimal for
    dnl the environment and includedir purposes (when using an SDK, below),
    dnl but remember the full version number for the libdir (SDK).
    changequote(,)
    GCC_VERSION_FULL=`echo $CXX_VERSION | $PERL -pe 's/^.*gcc version ([^ ]*).*/$1/'`
    GCC_VERSION=`echo $GCC_VERSION_FULL | $PERL -pe '(split(/\./))[0]>=4&&s/(^\d*\.\d*).*/$1/;'`
    changequote([,])
    if test "$GCC_VERSION_FULL" = "4.0.0" ; then
        dnl Bug 280479, but this keeps popping up in bug 292530 too because
        dnl 4.0.0/4061 is the default compiler in Tiger.
        changequote(,)
        GCC_BUILD=`echo $CXX_VERSION | $PERL -pe 's/^.*build ([^ )]*).*/$1/'`
        changequote([,])
        if test "$GCC_BUILD" = "4061" ; then
            AC_MSG_ERROR([You are attempting to use Apple gcc 4.0 build 4061.
This compiler was supplied with Xcode 2.0, and contains bugs that prevent it
from building Mozilla. Upgrade to Xcode 2.1 or later.])
        fi
    fi

    dnl xcodebuild needs GCC_VERSION defined in the environment, since it
    dnl doesn't respect the CC/CXX setting.  With GCC_VERSION set, it will use
    dnl /usr/bin/g(cc|++)-$GCC_VERSION.
    MOZ_PATH_PROGS(PBBUILD, pbbuild xcodebuild pbxbuild)

    case "$PBBUILD" in
      *xcodebuild*)
        changequote(,)
        XCODEBUILD_VERSION=`$PBBUILD -version 2>/dev/null | xargs | sed -e 's/.*DevToolsCore-\([0-9]*\).*/\1/'`
        changequote([,])
        if test -n "$XCODEBUILD_VERSION" && test "$XCODEBUILD_VERSION" -ge 620 ; then
          HAS_XCODE_2_1=1;
        fi
      ;;
    esac

    dnl sdp was formerly in /Developer/Tools.  As of Mac OS X 10.4 (Darwin 8),
    dnl it has moved into /usr/bin.
    MOZ_PATH_PROG(SDP, sdp, :, [$PATH:/usr/bin:/Developer/Tools])
    ;;
esac

AC_SUBST(GCC_VERSION)
AC_SUBST(XCODEBUILD_VERSION)
AC_SUBST(HAS_XCODE_2_1)

dnl The universal machinery sets UNIVERSAL_BINARY to inform packager.mk
dnl that a universal binary is being produced.
AC_SUBST(UNIVERSAL_BINARY)

dnl ========================================================
dnl Check for MacOS deployment target version
dnl ========================================================

MOZ_ARG_ENABLE_STRING(macos-target,
                      [  --enable-macos-target=VER (default=10.4)
                          Set the minimum MacOS version needed at runtime],
                      [_MACOSX_DEPLOYMENT_TARGET=$enableval])

case "$target" in
*-darwin*)
    if test -n "$_MACOSX_DEPLOYMENT_TARGET" ; then
        dnl Use the specified value
        export MACOSX_DEPLOYMENT_TARGET=$_MACOSX_DEPLOYMENT_TARGET
        AC_DEFINE_UNQUOTED(__ENVIRONMENT_MAC_OS_X_VERION_MIN_REQUIRED__,$_MACOSX_DEPLOYMENT_TARGET)
    elif test -z "$MACOSX_DEPLOYMENT_TARGET" ; then
        dnl No value specified on the command line or in the environment,
        dnl use architecture minimum.
        case "${target_cpu}" in
          x86_64)
            export MACOSX_DEPLOYMENT_TARGET=10.5
            ;;
          *)
            export MACOSX_DEPLOYMENT_TARGET=10.4
            ;;
        esac
    fi
    ;;
esac

AC_SUBST(MACOSX_DEPLOYMENT_TARGET)

dnl ========================================================
dnl = Mac OS X SDK support
dnl ========================================================
MACOS_SDK_DIR=
NEXT_ROOT=
MOZ_ARG_WITH_STRING(macos-sdk,
[  --with-macos-sdk=dir   Location of platform SDK to use (Mac OS X only)],
    MACOS_SDK_DIR=$withval)

dnl MACOS_SDK_DIR will be set to the SDK location whenever one is in use.
dnl NEXT_ROOT will be set and exported only if it's needed.
AC_SUBST(MACOS_SDK_DIR)
AC_SUBST(NEXT_ROOT)

if test "$MACOS_SDK_DIR"; then
  dnl Sync this section with the ones in NSPR and NSS.
  dnl Changes to the cross environment here need to be accounted for in
  dnl the libIDL checks (below) and xpidl build.

  if test ! -d "$MACOS_SDK_DIR"; then
    AC_MSG_ERROR([SDK not found.  When using --with-macos-sdk, you must
specify a valid SDK.  SDKs are installed when the optional cross-development
tools are selected during the Xcode/Developer Tools installation.])
  fi

  GCC_VERSION_MAJOR=`echo $GCC_VERSION_FULL | $PERL -pe 's/(^\d*).*/$1/;'`
  if test "$GCC_VERSION_MAJOR" -lt "4" ; then
    AC_MSG_ERROR([You need to upgrade the compiler version to 4.x])
  else
    CFLAGS="$CFLAGS -isysroot ${MACOS_SDK_DIR}"
    CXXFLAGS="$CXXFLAGS -isysroot ${MACOS_SDK_DIR}"

    dnl CPP/CXXCPP needs to be set for AC_CHECK_HEADER.
    CPP="$CPP -isysroot ${MACOS_SDK_DIR}"
    CXXCPP="$CXXCPP -isysroot ${MACOS_SDK_DIR}"

    if test "$GCC_VERSION_FULL" = "4.0.0" ; then
      dnl If gcc >= 4.0, we're guaranteed to be on Tiger, which has an ld
      dnl that supports -syslibroot.  Don't set NEXT_ROOT because it will
      dnl be ignored and cause warnings when -syslibroot is specified.
      dnl gcc 4.0.1 will pass -syslibroot to ld automatically based on
      dnl the -isysroot it receives, so this is only needed with 4.0.0.
      LDFLAGS="$LDFLAGS -Wl,-syslibroot,${MACOS_SDK_DIR}"
    fi
  fi

  AC_LANG_SAVE
  AC_MSG_CHECKING([for valid compiler/Mac OS X SDK combination])
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([#include <new>
                 int main() { return 0; }],
   result=yes,
   result=no)
  AC_LANG_RESTORE
  AC_MSG_RESULT($result)

  if test "$result" = "no" ; then
    AC_MSG_ERROR([The selected compiler and Mac OS X SDK are incompatible.])
  fi
fi

fi # COMPILE_ENVIRONMENT

dnl Be sure the make we use is GNU make.
dnl on win32, gmake.exe is the generally the wrong version
if test -n "$MAKE"; then
  if test `echo $MAKE | grep -c make.py` != 1; then
     NOT_PYMAKE=$MAKE
  fi
fi

case "$host_os" in
cygwin*|mingw*|mks*|msvc*)
    MOZ_PATH_PROGS(GMAKE, $GMAKE $NOT_PYMAKE make gmake, :)
    ;;
*)
    MOZ_PATH_PROGS(GMAKE, $GMAKE $NOT_PYMAKE gmake make, :)
    ;;
esac
if test "$GMAKE" = ":"; then
   AC_MSG_ERROR([GNU make not found])
fi
AC_SUBST(GMAKE)

if test "$COMPILE_ENVIRONMENT"; then

AC_PATH_XTRA

dnl Check in X11 include directory too.
if test "$no_x" != "yes"; then
    CPPFLAGS="$CPPFLAGS $X_CFLAGS"
fi

XCFLAGS="$X_CFLAGS"

fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl set the defaults first
dnl ========================================================
AS_BIN=$AS
AR_FLAGS='cr $@'
AR_LIST='$(AR) t'
AR_EXTRACT='$(AR) x'
AR_DELETE='$(AR) d'
AS='$(CC)'
AS_DASH_C_FLAG='-c'
DLL_PREFIX=lib
LIB_PREFIX=lib
DLL_SUFFIX=.so
OBJ_SUFFIX=o
LIB_SUFFIX=a
ASM_SUFFIX=s
IMPORT_LIB_SUFFIX=
TARGET_MD_ARCH=unix
DIRENT_INO=d_ino
CYGWIN_WRAPPER=
WIN_TOP_SRC=
MOZ_USER_DIR=".mozilla"
HOST_AR='$(AR)'
HOST_AR_FLAGS='$(AR_FLAGS)'

MOZ_JPEG_CFLAGS=
MOZ_JPEG_LIBS='$(call EXPAND_LIBNAME_PATH,mozjpeg,$(DEPTH)/jpeg)'
MOZ_ZLIB_CFLAGS=
MOZ_ZLIB_LIBS='$(call EXPAND_LIBNAME_PATH,mozz,$(DEPTH)/modules/zlib/src)'
MOZ_BZ2_CFLAGS=
MOZ_BZ2_LIBS='$(call EXPAND_LIBNAME_PATH,bz2,$(DEPTH)/modules/libbz2/src)'
MOZ_PNG_CFLAGS=
MOZ_PNG_LIBS='$(call EXPAND_LIBNAME_PATH,mozpng,$(DEPTH)/modules/libimg/png)'

MOZ_JS_LIBS='-L$(LIBXUL_DIST)/bin -lmozjs'
DYNAMIC_XPCOM_LIBS='-L$(LIBXUL_DIST)/bin -lxpcom -lxpcom_core'
MOZ_FIX_LINK_PATHS='-Wl,-rpath-link,$(LIBXUL_DIST)/bin -Wl,-rpath-link,$(prefix)/lib'
XPCOM_FROZEN_LDOPTS='-L$(LIBXUL_DIST)/bin -lxpcom'
LIBXUL_LIBS='$(XPCOM_FROZEN_LDOPTS) -lxul'
XPCOM_GLUE_LDOPTS='$(LIBXUL_DIST)/lib/$(LIB_PREFIX)xpcomglue_s.$(LIB_SUFFIX) $(XPCOM_FROZEN_LDOPTS)'
XPCOM_STANDALONE_GLUE_LDOPTS='$(LIBXUL_DIST)/lib/$(LIB_PREFIX)xpcomglue.$(LIB_SUFFIX)'

MOZ_FS_LAYOUT=unix

MOZ_COMPONENT_NSPR_LIBS='-L$(LIBXUL_DIST)/bin $(NSPR_LIBS)'
MOZ_XPCOM_OBSOLETE_LIBS='-L$(LIBXUL_DIST)/lib -lxpcom_compat'

USE_DEPENDENT_LIBS=1

_PLATFORM_DEFAULT_TOOLKIT=cairo-gtk2
MOZ_GFX_TOOLKIT='$(MOZ_WIDGET_TOOLKIT)'

MOZ_ENABLE_POSTSCRIPT=1 

if test -n "$CROSS_COMPILE"; then
    OS_TARGET="${target_os}"
    OS_ARCH=`echo $target_os | sed -e 's|/|_|g'`
    OS_RELEASE=
    case "${target_os}" in
        linux*)       OS_ARCH=Linux OS_TARGET=Linux ;;
        kfreebsd*-gnu) OS_ARCH=GNU_kFreeBSD OS_TARGET=GNU_kFreeBSD ;;
        solaris*)     OS_ARCH=SunOS OS_RELEASE=5 ;;
        mingw*)       OS_ARCH=WINNT ;;
        wince*)       OS_ARCH=WINCE ;;
        darwin*)      OS_ARCH=Darwin OS_TARGET=Darwin ;;
    esac
else
    OS_TARGET=`uname -s`
    OS_ARCH=`uname -s | sed -e 's|/|_|g'`
    OS_RELEASE=`uname -r`
fi

# Before this used `uname -m` when not cross compiling
# but that breaks when you have a 64 bit kernel with a 32 bit userland.
OS_TEST="${target_cpu}"

_COMPILER_PREFIX=

HOST_OS_ARCH=`echo $host_os | sed -e 's|/|_|g'`

#######################################################################
# Master "Core Components" macros for getting the OS target           #
#######################################################################

#
# If OS_TARGET is not specified, it defaults to $(OS_ARCH), i.e., no
# cross-compilation.
#

#
# Define and override various archtecture-specific variables, including
# HOST_OS_ARCH
# OS_ARCH
# OS_TEST
# OS_TARGET
# OS_RELEASE
# OS_MINOR_RELEASE
#

case "$HOST_OS_ARCH" in
cygwin*|mingw*|mks*|msvc*)
    HOST_OS_ARCH=WINNT
    ;;
darwin*)
    HOST_OS_ARCH=Darwin
    ;;
linux*)
    HOST_OS_ARCH=Linux
    ;;
solaris*)
    HOST_OS_ARCH=SunOS
    SOLARIS_SUNPRO_CC=
    SOLARIS_SUNPRO_CXX=
    if test -z "$GNU_CC"; then
        if test "`$CC -V 2>&1 | egrep -c 'Sun.*C '`" != "0"; then
            SOLARIS_SUNPRO_CC=1
       fi
    fi

    if test -z "$GNU_CXX"; then
       if test "`$CXX -V 2>&1 | egrep -c 'Sun.*C\+\+ '`" != "0"; then
           SOLARIS_SUNPRO_CXX=1
       fi
    fi
    AC_SUBST(SOLARIS_SUNPRO_CC)
    AC_SUBST(SOLARIS_SUNPRO_CXX)
    ;;
BSD_386)
    HOST_OS_ARCH=BSD
    ;;
dgux)
    HOST_OS_ARCH=DGUX
    ;;
IRIX64)
    HOST_OS_ARCH=IRIX
    ;;
UNIX_SV)
    if "`cat /etc/bcheckrc | grep -c NCR 2>/dev/null`" != "0"; then
        HOST_OS_ARCH=NCR
    else
        HOST_OS_ARCH=UNIXWARE
    fi
    ;;
ncr)
    HOST_OS_ARCH=NCR
    ;;
UNIX_SYSTEM_V)
    HOST_OS_ARCH=NEC
    ;;
OSF1)
    ;;
*OpenVMS*)
    HOST_OS_ARCH=OpenVMS
    ;;
OS_2)
    HOST_OS_ARCH=OS2
    ;;
QNX)
    ;;
SCO_SV)
    HOST_OS_ARCH=SCOOS
    ;;
SINIX-N | SINIX-Y | SINIX-Z |ReliantUNIX-M)
    HOST_OS_ARCH=SINIX
    ;;
UnixWare)
    HOST_OS_ARCH=UNIXWARE
    ;;
esac

case "$OS_ARCH" in
WINNT)
    OS_TEST=`uname -p`
    ;;
Windows_NT)
#
# If uname -s returns "Windows_NT", we assume that we are using
# the uname.exe in MKS toolkit.
#
# The -r option of MKS uname only returns the major version number.
# So we need to use its -v option to get the minor version number.
# Moreover, it doesn't have the -p option, so we need to use uname -m.
#
    OS_ARCH=WINNT
    OS_TARGET=WINNT
    OS_MINOR_RELEASE=`uname -v`
    if test "$OS_MINOR_RELEASE" = "00"; then
        OS_MINOR_RELEASE=0
    fi
    OS_RELEASE="${OS_RELEASE}.${OS_MINOR_RELEASE}"
    ;;
CYGWIN32_NT|CYGWIN_NT*|MINGW*_NT*)
#
# If uname -s returns "CYGWIN_NT-4.0", we assume that we are using
# the uname.exe in the Cygwin tools.
# Prior to the Beta 20 release, Cygwin was called GNU-Win32.
# If uname -s returns "CYGWIN32/NT", we assume that we are using
# the uname.exe in the GNU-Win32 tools.
# If uname -s returns MINGW32_NT-5.1, we assume that we are using
# the uname.exe in the MSYS tools.
#
    OS_RELEASE=`expr $OS_ARCH : '.*NT-\(.*\)'`
    OS_ARCH=WINNT
    OS_TARGET=WINNT
    ;;
AIX)
    OS_RELEASE=`uname -v`.`uname -r`
    OS_TEST=${target_cpu}
    ;;
BSD_386)
    OS_ARCH=BSD
    ;;
dgux)
    OS_ARCH=DGUX
    ;;
IRIX64)
    OS_ARCH=IRIX
    ;;
UNIX_SV)
    if "`cat /etc/bcheckrc | grep -c NCR 2>/dev/null`" != "0"; then
        OS_ARCH=NCR
    else
        OS_ARCH=UNIXWARE
        OS_RELEASE=`uname -v`
    fi
    ;;
ncr)
    OS_ARCH=NCR
    ;;
UNIX_SYSTEM_V)
    OS_ARCH=NEC
    ;;
OSF1)
    case `uname -v` in
    148)
        OS_RELEASE=V3.2C
        ;;
    564)
        OS_RELEASE=V4.0B
        ;;
    878)
        OS_RELEASE=V4.0D
        ;;
    esac
    ;;
*OpenVMS*)
    OS_ARCH=OpenVMS
    OS_RELEASE=`uname -v`
    OS_TEST=`uname -p`
    ;;
OS_2)
    OS_ARCH=OS2
    OS_TARGET=OS2
    OS_RELEASE=`uname -v`
    ;;
QNX)
    if test "$OS_TARGET" != "NTO"; then
        changequote(,)
        OS_RELEASE=`uname -v | sed 's/^\([0-9]\)\([0-9]*\)$/\1.\2/'`
        changequote([,])
    fi
    OS_TEST=x86
    ;;
SCO_SV)
    OS_ARCH=SCOOS
    OS_RELEASE=5.0
    ;;
SINIX-N | SINIX-Y | SINIX-Z |ReliantUNIX-M)
    OS_ARCH=SINIX
    OS_TEST=`uname -p`
    ;;
UnixWare)
    OS_ARCH=UNIXWARE
    OS_RELEASE=`uname -v`
    ;;
WINCE)
    OS_ARCH=WINCE
    OS_TARGET=WINCE
    ;;
Darwin)
    case "${target_cpu}" in
    powerpc*)
        OS_TEST=ppc
        ;;
    i*86*)
        OS_TEST=i386 
        ;;
    x86_64)
        OS_TEST=x86_64
        ;;
    *)
        if test -z "$CROSS_COMPILE" ; then
            OS_TEST=`uname -p`
        fi
        ;;
    esac
    ;;
esac

if test "$OS_ARCH" = "NCR"; then
    changequote(,)
    OS_RELEASE=`awk '{print $3}' /etc/.relid | sed 's/^\([0-9]\)\(.\)\(..\)\(.*\)$/\2.\3/'`
    changequote([,])
fi

# Only set CPU_ARCH if we recognize the value of OS_TEST

case "$OS_TEST" in
*86 | i86pc)
    CPU_ARCH=x86
    ;;

powerpc64 | ppc64)
    CPU_ARCH=ppc64
    ;;

powerpc | ppc | rs6000)
    CPU_ARCH=ppc
    ;;

Alpha | alpha | ALPHA)
    CPU_ARCH=Alpha
    ;;

s390)
    CPU_ARCH=s390
    ;;

s390x)
    CPU_ARCH=s390x
    ;;

hppa* | parisc)
    CPU_ARCH=hppa
    ;;

sun4u | sparc*)
    CPU_ARCH=sparc
    ;;

x86_64 | ia64)
    CPU_ARCH="$OS_TEST"
    ;;

arm)
    if test "$OS_TARGET" = "WINCE"; then
        CPU_ARCH="$OS_TEST"
    fi
    ;;
esac

if test -z "$OS_TARGET"; then
    OS_TARGET=$OS_ARCH
fi
OS_CONFIG="${OS_TARGET}${OS_RELEASE}"

dnl ========================================================
dnl GNU specific defaults
dnl ========================================================
if test "$GNU_CC"; then
    # FIXME: Let us build with strict aliasing. bug 414641.
    CFLAGS="$CFLAGS -fno-strict-aliasing"
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-h,$@ -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-h,$@ -o $@'
    DSO_LDOPTS='-shared'
    if test "$GCC_USE_GNU_LD"; then
        # Don't allow undefined symbols in libraries
        DSO_LDOPTS="$DSO_LDOPTS -Wl,-z,defs"
    fi
    WARNINGS_AS_ERRORS='-Werror'
    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-fPIC'
    ASFLAGS="$ASFLAGS -fPIC"
    _MOZ_RTTI_FLAGS_ON=${_COMPILER_PREFIX}-frtti
    _MOZ_RTTI_FLAGS_OFF=${_COMPILER_PREFIX}-fno-rtti
    _MOZ_EXCEPTIONS_FLAGS_ON='-fhandle-exceptions'
    _MOZ_EXCEPTIONS_FLAGS_OFF='-fno-handle-exceptions'

    # Turn on GNU specific features
    # -Wall - turn on all warnings
    # -pedantic - make compiler warn about non-ANSI stuff, and
    #             be a little bit stricter
    # Warnings slamm took out for now (these were giving more noise than help):
    # -Wbad-function-cast - warns when casting a function to a new return type
    # -Wshadow - removed because it generates more noise than help --pete
    _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wall -W -Wno-unused -Wpointer-arith"
    if test -z "$INTEL_CC"; then
       # Don't use -Wcast-align with ICC
       case "$CPU_ARCH" in
           # And don't use it on hppa, ia64, sparc, since it's noisy there
           hppa | ia64 | sparc)
           ;;
           *)
        _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wcast-align"
           ;;
       esac
    fi

    dnl Turn pedantic on but disable the warnings for long long
    _PEDANTIC=1

    if test -z "$INTEL_CC"; then
      _IGNORE_LONG_LONG_WARNINGS=1
      _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -W"
    else
      _IGNORE_LONG_LONG_WARNINGS=
    fi


    _DEFINES_CFLAGS='-include $(DEPTH)/mozilla-config.h -DMOZILLA_CLIENT'
    _USE_CPP_INCLUDE_FLAG=1
elif test "$SOLARIS_SUNPRO_CC"; then
    MKSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'
    MKCSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'

    DSO_LDOPTS='-shared'
    if test "$GNU_LD"; then
        # Don't allow undefined symbols in libraries
        DSO_LDOPTS="$DSO_LDOPTS -z defs"
    fi

    DSO_CFLAGS=''
    if test "$CPU_ARCH" = "sparc"; then
        # for Sun Studio on Solaris/SPARC
        DSO_PIC_CFLAGS='-xcode=pic32'
    else
        DSO_PIC_CFLAGS='-KPIC'
    fi
    _DEFINES_CFLAGS='$(ACDEFINES) -D_MOZILLA_CONFIG_H_ -DMOZILLA_CLIENT'
else
    MKSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'
    MKCSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'

    DSO_LDOPTS='-shared'
    if test "$GNU_LD"; then
        # Don't allow undefined symbols in libraries
        DSO_LDOPTS="$DSO_LDOPTS -z defs"
    fi

    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-KPIC'
    _DEFINES_CFLAGS='$(ACDEFINES) -D_MOZILLA_CONFIG_H_ -DMOZILLA_CLIENT'
fi

if test "$GNU_CXX"; then
    # FIXME: Let us build with strict aliasing. bug 414641.
    CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
    # Turn on GNU specific features
    _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wall -Wpointer-arith -Woverloaded-virtual -Wsynth -Wno-ctor-dtor-privacy -Wno-non-virtual-dtor"
    if test -z "$INTEL_CC"; then
       # Don't use -Wcast-align with ICC
       case "$CPU_ARCH" in
           # And don't use it on hppa, ia64, sparc, since it's noisy there
           hppa | ia64 | sparc)
           ;;
           *)
        _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wcast-align"
           ;;
       esac
    fi

    _DEFINES_CXXFLAGS='-DMOZILLA_CLIENT -include $(DEPTH)/mozilla-config.h'
    _USE_CPP_INCLUDE_FLAG=1

    AC_CACHE_CHECK(whether the compiler supports -Wno-invalid-offsetof,
                   ac_has_wno_invalid_offsetof,
        [
            AC_LANG_SAVE
            AC_LANG_CPLUSPLUS
            _SAVE_CXXFLAGS="$CXXFLAGS"
            CXXFLAGS="$CXXFLAGS ${_COMPILER_PREFIX}-Wno-invalid-offsetof"
            AC_TRY_COMPILE([],
                           [return(0);],
                           ac_has_wno_invalid_offsetof="yes",
                           ac_has_wno_invalid_offsetof="no")
            CXXFLAGS="$_SAVE_CXXFLAGS"
            AC_LANG_RESTORE
        ])
    if test "$ac_has_wno_invalid_offsetof" = "yes"; then
        _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} ${_COMPILER_PREFIX}-Wno-invalid-offsetof"
    fi
else
    _DEFINES_CXXFLAGS='-DMOZILLA_CLIENT -D_MOZILLA_CONFIG_H_ $(ACDEFINES)'
fi

dnl gcc can come with its own linker so it is better to use the pass-thru calls
dnl MKSHLIB_FORCE_ALL is used to force the linker to include all object
dnl files present in an archive. MKSHLIB_UNFORCE_ALL reverts the linker to
dnl normal behavior.
dnl ========================================================
MKSHLIB_FORCE_ALL=
MKSHLIB_UNFORCE_ALL=

if test "$COMPILE_ENVIRONMENT"; then
if test "$GNU_CC"; then
  AC_MSG_CHECKING(whether ld has archive extraction flags)
  AC_CACHE_VAL(ac_cv_mkshlib_force_and_unforce,
   [_SAVE_LDFLAGS=$LDFLAGS; _SAVE_LIBS=$LIBS
    ac_cv_mkshlib_force_and_unforce="no"
    exec 3<&0 <<LOOP_INPUT
	force="-Wl,--whole-archive";   unforce="-Wl,--no-whole-archive"
	force="-Wl,-z -Wl,allextract"; unforce="-Wl,-z -Wl,defaultextract"
	force="-Wl,-all";              unforce="-Wl,-none"
LOOP_INPUT
    while read line
    do
      eval $line
      LDFLAGS=$force
      LIBS=$unforce
      AC_TRY_LINK(,, ac_cv_mkshlib_force_and_unforce=$line; break)
    done
    exec 0<&3 3<&-
    LDFLAGS=$_SAVE_LDFLAGS; LIBS=$_SAVE_LIBS
   ])
  if test "$ac_cv_mkshlib_force_and_unforce" = "no"; then
    AC_MSG_RESULT(no)
  else
    AC_MSG_RESULT(yes)
    eval $ac_cv_mkshlib_force_and_unforce
    MKSHLIB_FORCE_ALL=$force
    MKSHLIB_UNFORCE_ALL=$unforce
  fi
fi # GNU_CC
fi # COMPILE_ENVIRONMENT

dnl =================================================================
dnl Set up and test static assertion macros used to avoid AC_TRY_RUN,
dnl which is bad when cross compiling.
dnl =================================================================
if test "$COMPILE_ENVIRONMENT"; then
configure_static_assert_macros='
#define CONFIGURE_STATIC_ASSERT(condition) CONFIGURE_STATIC_ASSERT_IMPL(condition, __LINE__)
#define CONFIGURE_STATIC_ASSERT_IMPL(condition, line) CONFIGURE_STATIC_ASSERT_IMPL2(condition, line)
#define CONFIGURE_STATIC_ASSERT_IMPL2(condition, line) typedef int static_assert_line_##line[(condition) ? 1 : -1]
'

dnl test that the macros actually work:
AC_MSG_CHECKING(that static assertion macros used in autoconf tests work)
AC_CACHE_VAL(ac_cv_static_assertion_macros_work,
 [AC_LANG_SAVE
  AC_LANG_C
  ac_cv_static_assertion_macros_work="yes"
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(1)],
                 ,
                 ac_cv_static_assertion_macros_work="no")
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(0)],
                 ac_cv_static_assertion_macros_work="no",
                 )
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(1)],
                 ,
                 ac_cv_static_assertion_macros_work="no")
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(0)],
                 ac_cv_static_assertion_macros_work="no",
                 )
  AC_LANG_RESTORE
 ])
AC_MSG_RESULT("$ac_cv_static_assertion_macros_work")
if test "$ac_cv_static_assertion_macros_work" = "no"; then
    AC_MSG_ERROR([Compiler cannot compile macros used in autoconf tests.])
fi
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl Checking for 64-bit OS
dnl ========================================================
if test "$COMPILE_ENVIRONMENT"; then
AC_LANG_SAVE
AC_LANG_C
AC_MSG_CHECKING(for 64-bit OS)
AC_TRY_COMPILE([$configure_static_assert_macros],
               [CONFIGURE_STATIC_ASSERT(sizeof(long) == 8)],
               result="yes", result="no")
AC_MSG_RESULT("$result")
if test "$result" = "yes"; then
    AC_DEFINE(HAVE_64BIT_OS)
    HAVE_64BIT_OS=1
fi
AC_SUBST(HAVE_64BIT_OS)
AC_LANG_RESTORE
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl Enable high-memory support on OS/2 by default.
dnl ========================================================
MOZ_OS2_HIGH_MEMORY=1
MOZ_ARG_DISABLE_BOOL(os2-high-mem,
[  --disable-os2-high-mem  Disable high-memory support on OS/2],
    MOZ_OS2_HIGH_MEMORY=,
    MOZ_OS2_HIGH_MEMORY=1 )
AC_SUBST(MOZ_OS2_HIGH_MEMORY)

dnl ========================================================
dnl System overrides of the defaults for host
dnl ========================================================
case "$host" in
*-beos*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_BEOS -DBeOS -DBEOS -D_POSIX_SOURCE -DNO_X11"
    HOST_NSPR_MDCPUCFG='\"md/_beos.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O3}"
    ;;

*cygwin*|*mingw*|*mks*|*msvc*|*wince)
    # we need Python 2.5 on Windows
    PYTHON_VERSION=2.5
    if test -n "$_WIN32_MSVC"; then
        HOST_AR=lib
        HOST_AR_FLAGS='-NOLOGO -OUT:"$@"'
        HOST_CFLAGS="$HOST_CFLAGS -TC -nologo -Fd\$(HOST_PDBFILE)"
        HOST_RANLIB='echo ranlib'
    else
        HOST_CFLAGS="$HOST_CFLAGS -mno-cygwin"
    fi
    HOST_CFLAGS="$HOST_CFLAGS -DXP_WIN32 -DXP_WIN -DWIN32 -D_WIN32 -DNO_X11"
    HOST_NSPR_MDCPUCFG='\"md/_winnt.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    HOST_BIN_SUFFIX=.exe
    case "$host" in
    *mingw*)
    dnl MinGW/MSYS does not need CYGWIN_WRAPPER
        ;;
    *)
        CYGWIN_WRAPPER="${srcdir}/build/cygwin-wrapper"
        if test "`echo ${srcdir} | grep -c ^/ 2>/dev/null`" = 0; then
            _pwd=`pwd`
            CYGWIN_WRAPPER="${_pwd}/${srcdir}/build/cygwin-wrapper"
        fi
        if test "`${PERL} -v | grep -c cygwin  2>/dev/null`" = 0; then
            AS_PERL=1
            PERL="${CYGWIN_WRAPPER} $PERL"
        fi

        if test "`${PYTHON} -c 'import sys; print sys.platform;'`" != "cygwin"; then
            PYTHON="${CYGWIN_WRAPPER} $PYTHON"
        fi
        ;;
    esac
    ;;

*-darwin*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX -DXP_MACOSX -DNO_X11"
    HOST_NSPR_MDCPUCFG='\"md/_darwin.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O3}"
    MOZ_FIX_LINK_PATHS='-Wl,-executable_path,$(LIBXUL_DIST)/bin'
    ;;

*-linux*|*-kfreebsd*-gnu)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    HOST_NSPR_MDCPUCFG='\"md/_linux.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O3}"
    ;;

*os2*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_OS2 -DNO_X11 -Zomf"
    HOST_NSPR_MDCPUCFG='\"md/_os2.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    HOST_BIN_SUFFIX=.exe
    MOZ_FIX_LINK_PATHS=
    ;;

*-osf*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    HOST_NSPR_MDCPUCFG='\"md/_osf1.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    ;;

*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    ;;
esac

dnl We require version 2.4 or newer of Python to build,
dnl and 2.5 or newer on Windows.
AC_MSG_CHECKING([for minimum required Python version >= $PYTHON_VERSION])
changequote(,)
$PYTHON -c "import sys; sys.exit(sys.version[:3] < sys.argv[1])" $PYTHON_VERSION
_python_res=$?
changequote([,])
if test "$_python_res" != 0; then
    AC_MSG_ERROR([Python $PYTHON_VERSION or higher is required.])
fi
AC_MSG_RESULT([yes])

dnl Get mozilla version from central milestone file
MOZILLA_VERSION=`$PERL $srcdir/config/milestone.pl -topsrcdir $srcdir`

dnl Get version of various core apps from the version files.
FIREFOX_VERSION=`cat $topsrcdir/browser/config/version.txt`

AC_DEFINE_UNQUOTED(MOZILLA_VERSION,"$MOZILLA_VERSION")
AC_DEFINE_UNQUOTED(MOZILLA_VERSION_U,$MOZILLA_VERSION)

dnl ========================================================
dnl System overrides of the defaults for target
dnl ========================================================

case "$target" in
*-aix*)
    AC_DEFINE(AIX)
    if test ! "$GNU_CC"; then
        if test ! "$HAVE_64BIT_OS"; then
            # Compiling with Visual Age C++ object model compat is the
            # default. To compile with object model ibm, add 
            # AIX_OBJMODEL=ibm to .mozconfig.
            if test "$AIX_OBJMODEL" = "ibm"; then
                CXXFLAGS="$CXXFLAGS -qobjmodel=ibm"
            else
                AIX_OBJMODEL=compat
            fi
        else
            AIX_OBJMODEL=compat
        fi
        AC_SUBST(AIX_OBJMODEL)
        DSO_LDOPTS='-qmkshrobj=1'
        DSO_CFLAGS='-qflag=w:w'
        DSO_PIC_CFLAGS=
        LDFLAGS="$LDFLAGS -Wl,-brtl -blibpath:/usr/lib:/lib"
        AC_MSG_WARN([Clearing MOZ_FIX_LINK_PATHS till we can fix bug 332075.])
        MOZ_FIX_LINK_PATHS=
        MKSHLIB='$(CXX) $(DSO_LDOPTS) -o $@'
        MKCSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
        if test "$COMPILE_ENVIRONMENT"; then
            AC_LANG_SAVE
            AC_LANG_CPLUSPLUS
            AC_MSG_CHECKING([for VisualAge C++ compiler version >= 6.0.0.3])
            AC_TRY_COMPILE([],
                [#if (__IBMCPP__ < 600)
                 #error "Bad compiler"
                 #endif],
                _BAD_COMPILER=,_BAD_COMPILER=1)
            if test -n "$_BAD_COMPILER"; then
                AC_MSG_RESULT([no])    
                AC_MSG_ERROR([VisualAge C++ version 6.0.0.3 or higher is required to build.])
            else
                AC_MSG_RESULT([yes])    
            fi
            AC_LANG_RESTORE
            TARGET_COMPILER_ABI="ibmc"
            CC_VERSION=`lslpp -Lcq vac.C 2>/dev/null | awk -F: '{ print $3 }'`
            CXX_VERSION=`lslpp -Lcq vacpp.cmp.core 2>/dev/null | awk -F: '{ print $3 }'`
        fi
    fi
    case "${target_os}" in
    aix4.1*)
        DLL_SUFFIX='_shr.a'
        ;;
    esac
    if test "$COMPILE_ENVIRONMENT"; then
        AC_CHECK_HEADERS(sys/inttypes.h)
    fi
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    ;;

*-beos*)
    no_x=yes
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_LDOPTS) -Wl,-h,$@ -o $@'
    _PLATFORM_DEFAULT_TOOLKIT="cairo-beos"
    DSO_LDOPTS='-nostart'
    TK_LIBS='-lbe -lroot'
    LIBS="$LIBS -lbe"
    if test "$COMPILE_ENVIRONMENT"; then
        AC_CHECK_LIB(bind,main,LIBS="$LIBS -lbind")
        AC_CHECK_LIB(zeta,main,LIBS="$LIBS -lzeta")
    fi
    _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wno-multichar"
    _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wno-multichar"
    _MOZ_USE_RTTI=1
    USE_DEPENDENT_LIBS=
    MOZ_USER_DIR="Mozilla"
    ;;

*-bsdi*)
    dnl -pedantic doesn't play well with BSDI's _very_ modified gcc (shlicc2)
    _PEDANTIC=
    _IGNORE_LONG_LONG_WARNINGS=
    case $OS_RELEASE in
	4.*|5.*)
            STRIP="$STRIP -d"
            ;;
	*)
	    DSO_CFLAGS=''
	    DSO_LDOPTS='-r'
	    _WARNINGS_CFLAGS="-Wall"
	    _WARNINGS_CXXFLAGS="-Wall"
	    # The test above doesn't work properly, at least on 3.1.
	    MKSHLIB_FORCE_ALL=''
	    MKSHLIB_UNFORCE_ALL=''
	;;
    esac
    ;;

*-darwin*) 
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MOZ_OPTIMIZE_FLAGS="-O3"
    _PEDANTIC=
    CFLAGS="$CFLAGS -fpascal-strings -fno-common"
    CXXFLAGS="$CXXFLAGS -fpascal-strings -fno-common"
    DLL_SUFFIX=".dylib"
    DSO_LDOPTS=''
    STRIP="$STRIP -x -S"
    _PLATFORM_DEFAULT_TOOLKIT='cairo-cocoa'
    MOZ_ENABLE_POSTSCRIPT=
    TARGET_NSPR_MDCPUCFG='\"md/_darwin.cfg\"'
    # The ExceptionHandling framework is needed for Objective-C exception
    # logging code in nsObjCExceptions.h. Currently we only use that in debug
    # builds.
    MOZ_DEBUG_LDFLAGS="$MOZ_DEBUG_LDFLAGS -framework ExceptionHandling"

    dnl DTrace and -dead_strip don't interact well. See bug 403132.
    dnl ===================================================================
    if test "x$enable_dtrace" = "xyes"; then
        echo "Skipping -dead_strip because DTrace is enabled. See bug 403132."
    else
        dnl check for the presence of the -dead_strip linker flag
        AC_MSG_CHECKING([for -dead_strip option to ld])
        _SAVE_LDFLAGS=$LDFLAGS
        LDFLAGS="$LDFLAGS -Wl,-dead_strip"
        AC_TRY_LINK(,[return 0;],_HAVE_DEAD_STRIP=1,_HAVE_DEAD_STRIP=)
        if test -n "$_HAVE_DEAD_STRIP" ; then
            AC_MSG_RESULT([yes])
            MOZ_OPTIMIZE_LDFLAGS="-Wl,-dead_strip"
        else
            AC_MSG_RESULT([no])
        fi
        
        LDFLAGS=$_SAVE_LDFLAGS
    fi
    ;;

*-freebsd*)
    if test `test -x /usr/bin/objformat && /usr/bin/objformat || echo elf` != "elf"; then
	DLL_SUFFIX=".so.1.0"
	DSO_LDOPTS="-shared"
    fi
    if test ! "$GNU_CC"; then
	DSO_LDOPTS="-Bshareable $DSO_LDOPTS"
    fi
# Can't have force w/o an unforce.
#    # Hack for FreeBSD 2.2
#    if test -z "$MKSHLIB_FORCE_ALL"; then
#	MKSHLIB_FORCE_ALL='-Wl,-Bforcearchive'
#	MKSHLIB_UNFORCE_ALL=''
#    fi
    ;; 

*-hpux*)
    DLL_SUFFIX=".sl"
    if test ! "$GNU_CC"; then
    	DSO_LDOPTS='-b -Wl,+s'
    	DSO_CFLAGS=""
    	DSO_PIC_CFLAGS="+Z"
    	MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -o $@'
    	MKCSHLIB='$(LD) -b +s -L$(LIBXUL_DIST)/bin -o $@'
        CXXFLAGS="$CXXFLAGS -Wc,-ansi_for_scope,on"
    else
        DSO_LDOPTS='-b -E +s'
        MKSHLIB='$(LD) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -L$(LIBXUL_DIST)/lib -o $@'
        MKCSHLIB='$(LD) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -L$(LIBXUL_DIST)/lib -o $@'
    fi
    MOZ_POST_PROGRAM_COMMAND='chatr +s enable'
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    ;;

*-irix5*)
    AC_DEFINE(IRIX)
    DSO_LDOPTS='-elf -shared'

    if test "$GNU_CC"; then
       MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
       MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
       MKSHLIB_FORCE_ALL='-Wl,-all'
       MKSHLIB_UNFORCE_ALL='-Wl,-none'
       CXXFLAGS="$CXXFLAGS -D_LANGUAGE_C_PLUS_PLUS"
    else
       MKSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
       MKCSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
       MKSHLIB_FORCE_ALL='-all'
       MKSHLIB_UNFORCE_ALL='-none'
    fi
    ;;

*-irix6*)
    AC_DEFINE(IRIX)
    dnl the irix specific xptcinvoke code is written against the n32 ABI so we *must* 
    dnl compile and link using -n32
    USE_N32=1
    TARGET_COMPILER_ABI=n32
    DSO_LDOPTS='-elf -shared'
    MKSHLIB='$(CCC) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    _MOZ_EXCEPTIONS_FLAGS_OFF="-LANG:exceptions=OFF"
    _MOZ_EXCEPTIONS_FLAGS_ON="-LANG:exceptions=ON"
    if test "$GNU_CC"; then
       MKSHLIB_FORCE_ALL='-Wl,-all'
       MKSHLIB_UNFORCE_ALL='-Wl,-none'
       _WARNINGS_CFLAGS="-Wall"
       _WARNINGS_CXXFLAGS="-Wall"
       CXXFLAGS="$CXXFLAGS -D_LANGUAGE_C_PLUS_PLUS"
    else
       MKSHLIB_FORCE_ALL='-all'
       MKSHLIB_UNFORCE_ALL='-none'
	   AR_LIST="$AR t"
	   AR_EXTRACT="$AR x"
	   AR_DELETE="$AR d"
	   AR='$(CXX) -ar'
	   AR_FLAGS='-o $@'
       CFLAGS="$CFLAGS -woff 3262 -G 4"
       CXXFLAGS="$CXXFLAGS -woff 3262 -G 4"
       if test -n "$USE_N32"; then
	   ASFLAGS="$ASFLAGS -n32"
	   CFLAGS="$CFLAGS -n32"
	   CXXFLAGS="$CXXFLAGS -n32"
	   LDFLAGS="$LDFLAGS -n32"
       fi
       AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
       AC_MSG_WARN([Clearing MOZ_FIX_LINK_PATHS for OSF/1 as fix for bug 333545 (till the reference bug 332075 is fixed.])
       MOZ_FIX_LINK_PATHS=
    fi
    if test -z "$GNU_CXX"; then
      MIPSPRO_CXX=1
    fi
    ;;

*-*linux*)
    # Note: both GNU_CC and INTEL_CC are set when using Intel's C compiler.
    # Similarly for GNU_CXX and INTEL_CXX.
    if test "$INTEL_CC" || test "$INTEL_CXX"; then
        # -Os has been broken on Intel's C/C++ compilers for quite a
        # while; Intel recommends against using it.
        MOZ_OPTIMIZE_FLAGS="-O2"
        MOZ_DEBUG_FLAGS="-g -fno-inline"
    elif test "$GNU_CC" || test "$GNU_CXX"; then
        GCC_VERSION=`$CC -v 2>&1 | awk '/^gcc version/ { print $3 }'`
        case $GCC_VERSION in
        4.1.*|4.2.*)
            # -Os is broken on gcc 4.1.x and 4.2.x, we need to tweak it to get good results.
            MOZ_OPTIMIZE_SIZE_TWEAK="-finline-limit=50"
        esac
        MOZ_OPTIMIZE_FLAGS="-Os -freorder-blocks -fno-reorder-functions $MOZ_OPTIMIZE_SIZE_TWEAK"
        MOZ_DEBUG_FLAGS="-g -fno-inline"  # most people on linux use gcc/gdb,
                                          # and that combo is not yet good at
                                          # debugging inlined functions (even
                                          # when using DWARF2 as the debugging
                                          # format)
    fi

    TARGET_NSPR_MDCPUCFG='\"md/_linux.cfg\"'

    MOZ_MEMORY=1

    case "${target_cpu}" in
    alpha*)
    	CFLAGS="$CFLAGS -mieee"
    	CXXFLAGS="$CXXFLAGS -mieee"
    ;;
    i*86)
    	USE_ELF_DYNSTR_GC=1
        MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS=1
    ;;
    mips*)
        MOZ_DEBUG_FLAGS="-g" # We want inlining
    ;;
    esac
    ;;

*-wince*)
    TARGET_COMPILER_ABI=msvc
    MOZ_TOOLS_DIR=`cd $MOZ_TOOLS && pwd -W`
    MOZ_BUILD_ROOT=`cd $MOZ_BUILD_ROOT && pwd -W`
    AR_LIST="$AR -list"
    AR_EXTRACT="$AR -extract"
    AR_DELETE="$AR d"
    AR_FLAGS='-OUT:"$@"'

    if test "$AS_BIN"; then
        AS="$AS_BIN"
    fi
    DSO_CFLAGS=
    DSO_PIC_CFLAGS=
    DLL_SUFFIX=.dll
    BIN_SUFFIX='.exe'
    if test -z "$RC"; then 
        RC=rc.exe  
    fi
    # certain versions of cygwin's makedepend barf on the 
    # #include <string> vs -I./dist/include/string issue so don't use it
    SYSTEM_MAKEDEPEND=

    HOST_CC=cl
    HOST_CXX=cl
    HOST_LD=link
    HOST_AR='lib -OUT:$@'
    HOST_RANLIB='echo ranlib'
    HOST_CFLAGS="$HOST_CFLAGS -D_X86_"
        
        
    WARNINGS_AS_ERRORS='-WX'
    MOZ_OPTIMIZE_FLAGS='-Ox'
    AR_FLAGS='-NOLOGO -OUT:"$@"'
    ASM_SUFFIX=asm
    CFLAGS="$CFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
    CXXFLAGS="$CXXFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
    DLL_PREFIX=
    DOXYGEN=:
    DSO_LDOPTS=-SUBSYSTEM:WINDOWSCE
    DYNAMIC_XPCOM_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xpcom_core.lib'
    GARBAGE=
    IMPORT_LIB_SUFFIX=lib
    LIBS="$LIBS"
    LIBXUL_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xul.lib'
    LIB_PREFIX=
    LIB_SUFFIX=lib 
    MKCSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ $(DSO_LDOPTS)'
    MKSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ $(DSO_LDOPTS)'
    MKSHLIB_FORCE_ALL=
    MKSHLIB_UNFORCE_ALL=
    MOZ_COMPONENT_NSPR_LIBS='$(NSPR_LIBS)'
    MOZ_COMPONENT_NSPR_LIBS='$(NSPR_LIBS)'
    MOZ_DEBUG_FLAGS='-Zi'
    MOZ_DEBUG_LDFLAGS='-DEBUG -DEBUGTYPE:CV'
    MOZ_FIX_LINK_PATHS=
    MOZ_JS_LIBS='$(LIBXUL_DIST)/lib/js$(MOZ_BITS)$(VERSION_NUMBER).lib'
    MOZ_XPCOM_OBSOLETE_LIBS='$(LIBXUL_DIST)/lib/xpcom_compat.lib'
    OBJ_SUFFIX=obj
    RANLIB='echo not_ranlib'
    STRIP='echo not_strip'
    TARGET_NSPR_MDCPUCFG='\"md/_wince.cfg\"'
    UNZIP=unzip
    XARGS=xargs
    XPCOM_FROZEN_LDOPTS='$(LIBXUL_DIST)/lib/xpcom.lib'
    ZIP=zip
    LIBIDL_CFLAGS="-I$MOZ_TOOLS_DIR/include ${GLIB_CFLAGS}"
    LIBIDL_LIBS="$MOZ_TOOLS_DIR/lib/libidl-0.6_s.lib $MOZ_TOOLS_DIR/lib/glib-1.2_s.lib"
    STATIC_LIBIDL=1
    MOZ_TREE_FREETYPE=1

    AC_DEFINE(HAVE_SNPRINTF)
    AC_DEFINE(_WINDOWS)
    AC_DEFINE(WIN32)
    AC_DEFINE(XP_WIN)
    AC_DEFINE(XP_WIN32)
    AC_DEFINE(HW_THREADS)
    AC_DEFINE(STDC_HEADERS)
    AC_DEFINE(NEW_H, <new>)
    AC_DEFINE(WIN32_LEAN_AND_MEAN)
    AC_DEFINE(HAVE_LOCALTIME_R)

    TARGET_MD_ARCH=win32
    _PLATFORM_DEFAULT_TOOLKIT='cairo-windows'
    BIN_SUFFIX='.exe'
    USE_SHORT_LIBNAME=1
    MOZ_ENABLE_POSTSCRIPT=
    MOZ_USER_DIR="Mozilla"

    MOZ_GFX_OPTIMIZE_MOBILE=1

    # Sanity check for WINCE_WINDOWS_MOBILE
    # XXX disabled until we can fix the mobile tinderbox
    ##if test "$WINCE_WINDOWS_MOBILE"; then
    ##   AC_CHECK_HEADER(tpcshell.h, [],
    ##        AC_MSG_ERROR([Can't find tpcshell.h in your SDK; are you sure you don't need --disable-windows-mobile-components?]))
    ##fi
;;


*-mingw*|*-cygwin*|*-msvc*|*-mks*)
    DSO_CFLAGS=
    DSO_PIC_CFLAGS=
    DLL_SUFFIX=.dll
    RC=rc.exe
    # certain versions of cygwin's makedepend barf on the 
    # #include <string> vs -I./dist/include/string issue so don't use it
    SYSTEM_MAKEDEPEND=
    if test -n "$GNU_CC"; then
        CC="$CC -mno-cygwin"
        CXX="$CXX -mno-cygwin"
        CPP="$CPP -mno-cygwin"
        CFLAGS="$CFLAGS -mms-bitfields"
        CXXFLAGS="$CXXFLAGS -mms-bitfields"
        DSO_LDOPTS='-shared'
        MKSHLIB='$(CXX) $(DSO_LDOPTS) -o $@'
        MKCSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
        RC='$(WINDRES)'
        # Use temp file for windres (bug 213281)
        RCFLAGS='-O coff --use-temp-file'
        # mingw doesn't require kernel32, user32, and advapi32 explicitly
        LIBS="$LIBS -lgdi32 -lwinmm -lwsock32"
        MOZ_JS_LIBS='-L$(LIBXUL_DIST)/lib -ljs$(MOZ_BITS)$(VERSION_NUMBER)'
        MOZ_FIX_LINK_PATHS=
        DYNAMIC_XPCOM_LIBS='-L$(LIBXUL_DIST)/lib -lxpcom -lxpcom_core'
        XPCOM_FROZEN_LDOPTS='-L$(LIBXUL_DIST)/lib -lxpcom'
        DLL_PREFIX=
        IMPORT_LIB_SUFFIX=dll.a
    else
        TARGET_COMPILER_ABI=msvc
        HOST_CC='$(CC)'
        HOST_CXX='$(CXX)'
        HOST_LD='$(LD)'
        AR='lib -NOLOGO -OUT:"$@"'
        AR_FLAGS=
        RANLIB='echo not_ranlib'
        STRIP='echo not_strip'
        XARGS=xargs
        ZIP=zip
        UNZIP=unzip
        DOXYGEN=:
        GARBAGE='$(OBJDIR)/vc20.pdb $(OBJDIR)/vc40.pdb'
        OBJ_SUFFIX=obj
        LIB_SUFFIX=lib
        DLL_PREFIX=
        LIB_PREFIX=
        IMPORT_LIB_SUFFIX=lib
        MKSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ -PDB:$(LINK_PDBFILE) $(DSO_LDOPTS)'
        MKCSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ -PDB:$(LINK_PDBFILE) $(DSO_LDOPTS)'
        MKSHLIB_FORCE_ALL=
        MKSHLIB_UNFORCE_ALL=
        DSO_LDOPTS=-SUBSYSTEM:WINDOWS
        CFLAGS="$CFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
        CXXFLAGS="$CXXFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
        LIBS="$LIBS kernel32.lib user32.lib gdi32.lib winmm.lib wsock32.lib advapi32.lib"
        MOZ_DEBUG_FLAGS='-Zi'
        MOZ_DEBUG_LDFLAGS='-DEBUG -DEBUGTYPE:CV'
        WARNINGS_AS_ERRORS='-WX'
    	MOZ_OPTIMIZE_FLAGS='-O1'
        MOZ_JS_LIBS='$(LIBXUL_DIST)/lib/js$(MOZ_BITS)$(VERSION_NUMBER).lib'
        MOZ_FIX_LINK_PATHS=
        DYNAMIC_XPCOM_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xpcom_core.lib'
        XPCOM_FROZEN_LDOPTS='$(LIBXUL_DIST)/lib/xpcom.lib'
        LIBXUL_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xul.lib'
        MOZ_COMPONENT_NSPR_LIBS='$(NSPR_LIBS)'
        MOZ_XPCOM_OBSOLETE_LIBS='$(LIBXUL_DIST)/lib/xpcom_compat.lib'
        if test $_MSC_VER -ge 1400; then
            LDFLAGS="$LDFLAGS -NXCOMPAT -SAFESEH"
            dnl For profile-guided optimization
            PROFILE_GEN_CFLAGS="-GL"
            PROFILE_GEN_LDFLAGS="-LTCG:PGINSTRUMENT"
            dnl XXX: PGO builds can fail with warnings treated as errors,
            dnl specifically "no profile data available" appears to be
            dnl treated as an error sometimes. This might be a consequence
            dnl of using WARNINGS_AS_ERRORS in some modules, combined
            dnl with the linker doing most of the work in the whole-program
            dnl optimization/PGO case. I think it's probably a compiler bug,
            dnl but we work around it here.
            PROFILE_USE_CFLAGS="-GL -wd4624 -wd4952"
            dnl XXX: should be -LTCG:PGOPTIMIZE, but that fails on libxul.
            dnl Probably also a compiler bug, but what can you do?
            PROFILE_USE_LDFLAGS="-LTCG:PGUPDATE"
            if test -n "$_USE_DYNAMICBASE"; then
               LDFLAGS="$LDFLAGS -DYNAMICBASE"
            fi
        fi
    fi
    MOZ_JPEG_LIBS='$(call EXPAND_LIBNAME_PATH,jpeg$(MOZ_BITS)$(VERSION_NUMBER),$(DEPTH)/jpeg)'
    MOZ_PNG_LIBS='$(call EXPAND_LIBNAME_PATH,png,$(DEPTH)/modules/libimg/png)'
    AC_DEFINE(HAVE_SNPRINTF)
    AC_DEFINE(_WINDOWS)
    AC_DEFINE(WIN32)
    AC_DEFINE(XP_WIN)
    AC_DEFINE(XP_WIN32)
    AC_DEFINE(HW_THREADS)
    AC_DEFINE(STDC_HEADERS)
    AC_DEFINE(NEW_H, <new>)
    AC_DEFINE(WIN32_LEAN_AND_MEAN)
    TARGET_MD_ARCH=win32
    _PLATFORM_DEFAULT_TOOLKIT='cairo-windows'
    BIN_SUFFIX='.exe'
    USE_SHORT_LIBNAME=1
    MOZ_ENABLE_POSTSCRIPT=
    MOZ_USER_DIR="Mozilla"

    dnl Hardcode to win95 for now - cls
    TARGET_NSPR_MDCPUCFG='\"md/_win95.cfg\"'

    dnl set NO_X11 defines here as the general check is skipped on win32
    no_x=yes
    AC_DEFINE(NO_X11)

    dnl MinGW/MSYS doesn't provide or need cygpath
    case "$host" in
    *-mingw*)
	CYGPATH_W=echo
	CYGPATH_S=cat
	MOZ_BUILD_ROOT=`cd $MOZ_BUILD_ROOT && pwd -W`
	;;
    *-cygwin*|*-msvc*|*-mks*)
	CYGPATH_W="cygpath -a -w"
	CYGPATH_S="sed -e s|\\\\|/|g"
	MOZ_BUILD_ROOT=`$CYGPATH_W $MOZ_BUILD_ROOT | $CYGPATH_S`
	;;
    esac
    case "$host" in
    *-mingw*|*-cygwin*|*-msvc*|*-mks*)

    if test -z "$MOZ_TOOLS"; then
        AC_MSG_ERROR([MOZ_TOOLS is not set])
    fi

    MOZ_TOOLS_DIR=`cd $MOZ_TOOLS && pwd -W`
    if test "$?" != "0" || test -z "$MOZ_TOOLS_DIR"; then
        AC_MSG_ERROR([cd \$MOZ_TOOLS failed. MOZ_TOOLS ==? $MOZ_TOOLS])
    fi
    MOZ_TOOLS_BIN_DIR="$(cd "$MOZ_TOOLS_DIR/bin" && pwd)"
    if test `echo ${PATH}: | grep -ic "$MOZ_TOOLS_BINDIR:"` = 0; then
        AC_MSG_ERROR([\$MOZ_TOOLS\\bin must be in your path.])
    fi
    MOZ_TOOLS_DIR=`$CYGPATH_W $MOZ_TOOLS_DIR | $CYGPATH_S`

    if test -n "$GLIB_PREFIX"; then
        _GLIB_PREFIX_DIR=`cd $GLIB_PREFIX && pwd -W`
        if test "$?" = "0"; then
            if test `echo ${PATH}: | grep -ic "$_GLIB_PREFIX_DIR/bin:"` = 0; then
                AC_MSG_ERROR([GLIB_PREFIX must be in your \$PATH.])
            fi
            _GLIB_PREFIX_DIR=`$CYGPATH_W $_GLIB_PREFIX_DIR | $CYGPATH_S`
        else
            AC_MSG_ERROR([GLIB_PREFIX is set but "${GLIB_PREFIX}" is not a directory.])
        fi
    else
        _GLIB_PREFIX_DIR=$MOZ_TOOLS_DIR
    fi
    if test ! -f "${_GLIB_PREFIX_DIR}/include/glib.h"; then
        AC_MSG_ERROR([Cannot find $_GLIB_PREFIX_DIR/include/glib.h .])
    fi
    GLIB_CFLAGS="-I${_GLIB_PREFIX_DIR}/include"
    if test -f "${_GLIB_PREFIX_DIR}/lib/glib-1.2_s.lib"; then
        GLIB_LIBS="${_GLIB_PREFIX_DIR}/lib/glib-1.2_s.lib"
    elif test -f "${_GLIB_PREFIX_DIR}/lib/glib-1.2.lib"; then
        GLIB_LIBS="${_GLIB_PREFIX_DIR}/lib/glib-1.2.lib"
    else
        AC_MSG_ERROR([Cannot find $_GLIB_PREFIX_DIR/lib/glib-1.2.lib or $_GLIB_PREFIX_DIR/lib/glib-1.2_s.lib])
    fi

    if test -n "$LIBIDL_PREFIX"; then
        _LIBIDL_PREFIX_DIR=`cd $LIBIDL_PREFIX && pwd -W`
        if test "$?" = "0"; then
            if test `echo ${PATH}: | grep -ic "$_LIBIDL_PREFIX_DIR/bin:"` = 0; then
                AC_MSG_ERROR([LIBIDL_PREFIX must be in your \$PATH.])
            fi
            _LIBIDL_PREFIX_DIR=`$CYGPATH_W $_LIBIDL_PREFIX_DIR | $CYGPATH_S`
        else
            AC_MSG_ERROR([LIBIDL_PREFIX is set but "${LIBIDL_PREFIX}" is not a directory.])
        fi
    else
        _LIBIDL_PREFIX_DIR=$MOZ_TOOLS_DIR
    fi        
    if test ! -f "${_LIBIDL_PREFIX_DIR}/include/libIDL/IDL.h"; then
        AC_MSG_ERROR([Cannot find $_LIBIDL_PREFIX_DIR/include/libIDL/IDL.h .])
    fi
    LIBIDL_CFLAGS="-I${_LIBIDL_PREFIX_DIR}/include ${GLIB_CFLAGS}"
    if test -f "${_LIBIDL_PREFIX_DIR}/lib/libidl-0.6_s.lib"; then
        LIBIDL_LIBS="${_LIBIDL_PREFIX_DIR}/lib/libidl-0.6_s.lib"
        STATIC_LIBIDL=1
    elif test -f "${_LIBIDL_PREFIX_DIR}/lib/libidl-0.6.lib"; then
        LIBIDL_LIBS="${_LIBIDL_PREFIX_DIR}/lib/libidl-0.6.lib"
    else
        AC_MSG_ERROR([Cannot find $_LIBIDL_PREFIX_DIR/lib/libidl-0.6.lib or $_LIBIDL_PREFIX_DIR/lib/libidl-0.6_s.lib])
    fi
    LIBIDL_LIBS="${LIBIDL_LIBS} ${GLIB_LIBS}"
    ;;

    *) # else cross-compiling
        if test -n "$GLIB_PREFIX"; then
            GLIB_CFLAGS="-I${GLIB_PREFIX}/include"
            if test -f "${GLIB_PREFIX}/lib/glib-1.2_s.lib"; then
                GLIB_LIBS="${GLIB_PREFIX}/lib/glib-1.2_s.lib"
            elif test -f "${GLIB_PREFIX}/lib/glib-1.2.lib"; then
                GLIB_LIBS="${GLIB_PREFIX}/lib/glib-1.2.lib"
            else
                AC_MSG_ERROR([Cannot find $GLIB_PREFIX/lib/glib-1.2.lib or $GLIB_PREFIX/lib/glib-1.2_s.lib])
            fi
        fi
        if test -n "$LIBIDL_PREFIX"; then
            LIBIDL_CFLAGS="-I${LIBIDL_PREFIX}/include ${GLIB_CFLAGS}"
            if test -f "${LIBIDL_PREFIX}/lib/libIDL-0.6_s.lib"; then
                LIBIDL_LIBS="${LIBIDL_PREFIX}/lib/libIDL-0.6_s.lib"
                STATIC_LIBIDL=1
            elif test -f "${LIBIDL_PREFIX}/lib/libIDL-0.6.lib"; then
                LIBIDL_LIBS="${LIBIDL_PREFIX}/lib/libIDL-0.6.lib"
            else
                AC_MSG_ERROR([Cannot find $LIBIDL_PREFIX/lib/libIDL-0.6.lib or $LIBIDL_PREFIX/lib/libIDL-0.6_s.lib])
            fi
        fi
        LIBIDL_LIBS="${LIBIDL_LIBS} ${GLIB_LIBS}"
        ;;
    esac 


    case "$host_os" in
    cygwin*|msvc*|mks*)
        AC_MSG_WARN([Using a cygwin build environment is unsupported. Configure cannot check for the presence of necessary headers. Please upgrade to MozillaBuild; see http://developer.mozilla.org/en/docs/Windows_Build_Prerequisites])
        ;;

    *)
        AC_CHECK_HEADERS(mmintrin.h oleacc.idl)

        AC_LANG_SAVE
        AC_LANG_CPLUSPLUS
        AC_CHECK_HEADERS(atlbase.h wpcapi.h)
        AC_LANG_RESTORE
        ;;
    esac

    case "$target" in
    i*86-*)
    	AC_DEFINE(_X86_)
	;;
    alpha-*)
    	AC_DEFINE(_ALPHA_)
	;;
    mips-*)
    	AC_DEFINE(_MIPS_)
	;;
    *)
    	AC_DEFINE(_CPU_ARCH_NOT_DEFINED)
	;;
    esac
    ;;

*-netbsd*)
    DSO_CFLAGS=''
    CFLAGS="$CFLAGS -Dunix"
    CXXFLAGS="$CXXFLAGS -Dunix"
    if $CC -E - -dM </dev/null | grep __ELF__ >/dev/null; then
        DLL_SUFFIX=".so"
        DSO_PIC_CFLAGS='-fPIC -DPIC'
        DSO_LDOPTS='-shared'
	BIN_FLAGS='-Wl,--export-dynamic'
    else
    	DSO_PIC_CFLAGS='-fPIC -DPIC'
    	DLL_SUFFIX=".so.1.0"
    	DSO_LDOPTS='-shared'
    fi
    # This will fail on a.out systems prior to 1.5.1_ALPHA.
    MKSHLIB_FORCE_ALL='-Wl,--whole-archive'
    MKSHLIB_UNFORCE_ALL='-Wl,--no-whole-archive'
    if test "$LIBRUNPATH"; then
	DSO_LDOPTS="-Wl,-R$LIBRUNPATH $DSO_LDOPTS"
    fi
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,lib$(LIBRARY_NAME)$(DLL_SUFFIX) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,lib$(LIBRARY_NAME)$(DLL_SUFFIX) -o $@'
    ;;

*-nto*) 
	AC_DEFINE(NTO)	
	AC_DEFINE(_QNX_SOURCE)
	AC_DEFINE(_i386)
	OS_TARGET=NTO
	WARNINGS_AS_ERRORS=''
	MOZ_OPTIMIZE_FLAGS="-O"
	MOZ_DEBUG_FLAGS="-gstabs"
	USE_PTHREADS=1
	_PEDANTIC=
	LIBS="$LIBS -lsocket -lstdc++"
	_DEFINES_CFLAGS='-Wp,-include -Wp,$(DEPTH)/mozilla-config.h -DMOZILLA_CLIENT -D_POSIX_C_SOURCE=199506'
	_DEFINES_CXXFLAGS='-DMOZILLA_CLIENT -Wp,-include -Wp,$(DEPTH)/mozilla-config.h -D_POSIX_C_SOURCE=199506'
	if test "$with_x" != "yes"
	then
		_PLATFORM_DEFAULT_TOOLKIT="photon"
	    TK_CFLAGS='-I/usr/include/photon'
		TK_LIBS='-lph'
	fi
	case "${target_cpu}" in
	ppc*)
	AC_DEFINE(HAVE_VA_LIST_AS_ARRAY)	
	;;
	esac
	case "${host_cpu}" in
	i*86)
	USE_ELF_DYNSTR_GC=1
	;;
	esac
	;;

*-openbsd*)
    DLL_SUFFIX=".so.1.0"
    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-fPIC'
    DSO_LDOPTS='-shared -fPIC'
    if test "$LIBRUNPATH"; then
	DSO_LDOPTS="-R$LIBRUNPATH $DSO_LDOPTS"
    fi
    ;;

*-openvms*) 
    AC_DEFINE(NO_PW_GECOS)
    AC_DEFINE(NO_UDSOCK)
    AC_DEFINE(POLL_WITH_XCONNECTIONNUMBER)
    USE_PTHREADS=1
    MKSHLIB_FORCE_ALL='-all'
    MKSHLIB_UNFORCE_ALL='-none'
    AS='as'
    AS_DASH_C_FLAG='-Wc/names=as_is'
    AR_FLAGS='c $@'
    DSO_LDOPTS='-shared -auto_symvec'
    DSO_PIC_CFLAGS=
    MOZ_DEBUG_LDFLAGS='-g'
    COMPAQ_CXX=1
    CC_VERSION=`$CC -V 2>&1 | awk '/ C / { print $3 }'`
    CXX_VERSION=`$CXX -V 2>&1 | awk '/ C\+\+ / { print $3 }'`
    ;;


*-os2*)
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    AC_DEFINE(OS2)
    AC_DEFINE(XP_OS2)
    AC_DEFINE(OS2EMX_PLAIN_CHAR)
    AC_DEFINE(TCPV40HDRS)
    USE_SHORT_LIBNAME=1
    DLL_PREFIX=
    LIB_PREFIX=
    LIB_SUFFIX=lib
    BIN_SUFFIX=".exe"
    DLL_SUFFIX=".dll"
    IMPORT_LIB_SUFFIX=lib
    DSO_PIC_CFLAGS=
    AR=emxomfar
    AR_FLAGS='r $@'
    CFLAGS="$CFLAGS -Zomf"
    CXXFLAGS="$CXXFLAGS -Zomf"
    DSO_LDOPTS='-Zdll'
    BIN_FLAGS='-Zlinker /ST:0x100000'
    IMPLIB='emximp -o'
    FILTER='emxexp -o'
    LDFLAGS='-Zmap'
    WARNINGS_AS_ERRORS='-Werror'
    MOZ_DEBUG_FLAGS="-g -fno-inline"
    MOZ_OPTIMIZE_FLAGS="-O2"
    MOZ_OPTIMIZE_LDFLAGS="-s -Zlinker /EXEPACK:2 -Zlinker /PACKCODE -Zlinker /PACKDATA"
    MOZ_XPCOM_OBSOLETE_LIBS='-L$(LIBXUL_DIST)/lib $(LIBXUL_DIST)/lib/xpcomct.lib'
    DYNAMIC_XPCOM_LIBS='-L$(LIBXUL_DIST)/lib $(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xpcomcor.lib'
    LIBXUL_LIBS='-L$(LIBXUL_DIST)/lib $(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xul.lib'
    TARGET_MD_ARCH=os2
    _PLATFORM_DEFAULT_TOOLKIT="cairo-os2"
    MOZ_ENABLE_POSTSCRIPT=
    RC=rc.exe
    RCFLAGS='-n'
    MOZ_USER_DIR="Mozilla"

    if test "$MOZTOOLS"; then
        MOZ_TOOLS_DIR=`echo $MOZTOOLS | sed -e 's|\\\\|/|g'`
    else
        AC_MSG_ERROR([MOZTOOLS is not set])
    fi
    if test -n "$MOZ_OS2_HIGH_MEMORY"; then
        DSO_LDOPTS="$DSO_LDOPTS -Zhigh-mem"
        LDFLAGS="$LDFLAGS -Zhigh-mem"
        MOZ_OPTIMIZE_LDFLAGS="$MOZ_OPTIMIZE_LDFLAGS -Zhigh-mem"
        AC_DEFINE(MOZ_OS2_HIGH_MEMORY)
    fi

    # GCC for OS/2 currently predefines these, but we don't want them
    _DEFINES_CFLAGS="$_DEFINES_CFLAGS -Uunix -U__unix -U__unix__"
    _DEFINES_CXXFLAGS="$_DEFINES_CXXFLAGS -Uunix -U__unix -U__unix__"

    AC_CACHE_CHECK(for __declspec(dllexport),
        ac_os2_declspec,
        [AC_TRY_COMPILE([__declspec(dllexport) void ac_os2_declspec(void) {}],
                        [return 0;],
                        ac_os2_declspec="yes",
                        ac_os2_declspec="no")])
    if test "$ac_os2_declspec" = "yes"; then
        FILTER='true'
        MOZ_OS2_USE_DECLSPEC='1'
    fi
    ;;

alpha*-*-osf*)
    if test "$GNU_CC"; then
      MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,$@ -o $@'
      MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,$@ -o $@'

    else
	MOZ_DEBUG_FLAGS='-g'
	ASFLAGS='-I$(topsrcdir)/xpcom/reflect/xptcall/public -g'
	CFLAGS="$CFLAGS -ieee"
	CXXFLAGS="$CXXFLAGS "'-noexceptions -ieee  -ptr $(DIST)/cxx_repository'
	DSO_LDOPTS='-shared -msym -expect_unresolved \* -update_registry $(DIST)/so_locations'
	DSO_CFLAGS=
	DSO_PIC_CFLAGS=
	MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -soname $@ -o $@'
	MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -soname $@ -o $@'
	MKSHLIB_FORCE_ALL='-all'
	MKSHLIB_UNFORCE_ALL='-none'
	dnl Might fix the libxpcom.so breakage on this platform as well....
	AC_DEFINE(NSCAP_DISABLE_TEST_DONTQUERY_CASES)
	AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    fi
    if test -z "$GNU_CXX"; then
      COMPAQ_CXX=1
    fi
    AC_DEFINE(NEED_USLEEP_PROTOTYPE)
    ;;

*-qnx*) 
    DIRENT_INO=d_stat.st_ino
    dnl Solves the problems the QNX compiler has with nsCOMPtr.h.
    AC_DEFINE(NSCAP_DISABLE_TEST_DONTQUERY_CASES)
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    dnl Explicit set STDC_HEADERS to workaround QNX 6.0's failing of std test
    AC_DEFINE(STDC_HEADERS)
    if test "$no_x" = "yes"; then
	    _PLATFORM_DEFAULT_TOOLKIT='photon'
	    TK_CFLAGS='-I/usr/nto/include/photon'
	    TK_LIBS='-lphoton -lphrender'
    fi
    ;;

*-sco*) 
    AC_DEFINE(NSCAP_DISABLE_TEST_DONTQUERY_CASES)
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    CXXFLAGS="$CXXFLAGS -I/usr/include/CC"
    if test ! "$GNU_CC"; then
       DSO_LDOPTS='-G'
    fi
    ;;

dnl the qsort routine under solaris is faulty
*-solaris*) 
    AC_DEFINE(SOLARIS)
    TARGET_NSPR_MDCPUCFG='\"md/_solaris.cfg\"'
    SYSTEM_MAKEDEPEND=
    # $ORIGIN/.. is for shared libraries under components/ to locate shared
    # libraries one level up (e.g. libnspr4.so)
    LDFLAGS="$LDFLAGS -z ignore -R '\$\$ORIGIN:\$\$ORIGIN/..'"
    MOZ_MEMORY=1
    if test "$SOLARIS_SUNPRO_CC"; then
       LIBS="-lCrun -lCstd $LIBS"
       NS_USE_NATIVE=1
       MOZ_FIX_LINK_PATHS=
       AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
       CFLAGS="$CFLAGS -xlibmieee -xstrconst -xbuiltin=%all"
       CXXFLAGS="$CXXFLAGS -xlibmieee -xbuiltin=%all -features=tmplife -norunpath"
       LDFLAGS="-xildoff -z lazyload -z combreloc $LDFLAGS"
       if test -z "$CROSS_COMPILE" && test -f /usr/lib/ld/map.noexstk; then
           _SAVE_LDFLAGS=$LDFLAGS
           LDFLAGS="-M /usr/lib/ld/map.noexstk $LDFLAGS" 
           AC_TRY_LINK([#include <stdio.h>],
                       [printf("Hello World\n");],
                       ,
                       [LDFLAGS=$_SAVE_LDFLAGS])
       fi
       WARNINGS_AS_ERRORS='-Werror'
       MOZ_OPTIMIZE_FLAGS="-xO4"
       MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_FLAGS) $(DSO_LDOPTS) -h $@ -o $@'
       MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_FLAGS) -G -z muldefs -h $@ -o $@'
       MKSHLIB_FORCE_ALL='-z allextract'
       MKSHLIB_UNFORCE_ALL='-z defaultextract'
       DSO_LDOPTS='-G -z muldefs'
       AR_LIST="$AR t"
       AR_EXTRACT="$AR x"
       AR_DELETE="$AR d"
       AR='$(CXX) -xar'
       AR_FLAGS='-o $@'
       AS='/usr/ccs/bin/as'
       ASFLAGS="$ASFLAGS -K PIC -L -P -D_ASM -D__STDC__=0"
       AS_DASH_C_FLAG=''
       TARGET_COMPILER_ABI="sunc"
       CC_VERSION=`$CC -V 2>&1 | grep '^cc:' 2>/dev/null | $AWK -F\: '{ print $2 }'`
       CXX_VERSION=`$CXX -V 2>&1 | grep '^CC:' 2>/dev/null | $AWK -F\: '{ print $2 }'`
       AC_MSG_CHECKING([for Sun C++ compiler version >= 5.9])
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([],
           [#if (__SUNPRO_CC < 0x590)
           #error "Denied"
           #endif],
           _BAD_COMPILER=,_BAD_COMPILER=1)
        if test -n "$_BAD_COMPILER"; then
            _res="no"
            AC_MSG_ERROR([Sun C++ 5.9 (Sun Studio 12) or higher is required to build. Your compiler version is $CXX_VERSION .])
        else
            _res="yes"
        fi
        AC_MSG_RESULT([$_res])
        AC_LANG_RESTORE
    else
       ASFLAGS="$ASFLAGS -fPIC"
       DSO_LDOPTS='-G'
       _WARNINGS_CFLAGS=''
       _WARNINGS_CXXFLAGS=''
       if test "$OS_RELEASE" = "5.3"; then
	  AC_DEFINE(MUST_UNDEF_HAVE_BOOLEAN_AFTER_INCLUDES)
       fi
    fi
    if test "$OS_RELEASE" = "5.5.1"; then
       AC_DEFINE(NEED_USLEEP_PROTOTYPE)
    fi
    ;;

*-sunos*) 
    DSO_LDOPTS='-Bdynamic'
    MKSHLIB='-$(LD) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='-$(LD) $(DSO_LDOPTS) -o $@'
    AC_DEFINE(SUNOS4)
    AC_DEFINE(SPRINTF_RETURNS_STRING)
    case "$(target_os)" in
    sunos4.1*)
        DLL_SUFFIX='.so.1.0'
        ;;
    esac
    ;;

*-sysv4.2uw7*) 
	NSPR_LIBS="-lnspr$NSPR_VERSION -lplc$NSPR_VERSION -lplds$NSPR_VERSION -L/usr/ccs/lib -lcrt"
    ;;

*-os2*)
    HOST_NSPR_MDCPUCFG='\"md/_os2.cfg\"'
    ;;

esac

dnl Only one oddball right now (QNX), but this gives us flexibility
dnl if any other platforms need to override this in the future.
AC_DEFINE_UNQUOTED(D_INO,$DIRENT_INO)

dnl ========================================================
dnl Any platform that doesn't have MKSHLIB_FORCE_ALL defined
dnl by now will not have any way to link most binaries (tests
dnl as well as viewer, apprunner, etc.), because some symbols
dnl will be left out of the "composite" .so's by ld as unneeded.
dnl So, by defining NO_LD_ARCHIVE_FLAGS for these platforms,
dnl they can link in the static libs that provide the missing
dnl symbols.
dnl ========================================================
NO_LD_ARCHIVE_FLAGS=
if test -z "$MKSHLIB_FORCE_ALL" || test -z "$MKSHLIB_UNFORCE_ALL"; then
    NO_LD_ARCHIVE_FLAGS=1
fi
case "$target" in
*-os2*)
    NO_LD_ARCHIVE_FLAGS=
    ;;
*-aix4.3*|*-aix5*)
    NO_LD_ARCHIVE_FLAGS=
    ;;
*-openvms*)
    NO_LD_ARCHIVE_FLAGS=
    ;;
*-msvc*|*-mks*|*-mingw*|*-cygwin*|*-wince)
    if test -z "$GNU_CC"; then
        NO_LD_ARCHIVE_FLAGS=
    fi
    ;;
esac
AC_SUBST(NO_LD_ARCHIVE_FLAGS)

dnl ========================================================
dnl = Flags to strip unused symbols from .so components
dnl ========================================================
case "$target" in
    *-linux*|*-kfreebsd*-gnu)
        MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
        ;;
    *-solaris*)
        if test -z "$GNU_CC"; then
         MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-M $(BUILD_TOOLS)/gnu-ld-scripts/components-mapfile'
        else
         if test -z "$GCC_USE_GNU_LD"; then
          MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,-M -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-mapfile'
         else
          MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
         fi
        fi
        ;;
    *-nto*) 
        MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
        ;;
    *-darwin*)
        MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,-exported_symbols_list -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-export-list'
        ;;
    *-cygwin*|*-mingw*|*-mks*|*-msvc|*-wince)
        if test -n "$GNU_CC"; then
           MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
        fi
        ;;
esac

if test -z "$COMPILE_ENVIRONMENT"; then
    SKIP_COMPILER_CHECKS=1
    SKIP_LIBRARY_CHECKS=1
fi

if test -z "$SKIP_COMPILER_CHECKS"; then
dnl Checks for typedefs, structures, and compiler characteristics.
dnl ========================================================
AC_LANG_C
AC_HEADER_STDC
AC_C_CONST
AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_STRUCT_ST_BLKSIZE
AC_MSG_CHECKING(for siginfo_t)
AC_CACHE_VAL(ac_cv_siginfo_t,
 [AC_TRY_COMPILE([#define _POSIX_C_SOURCE 199506L
                  #include <signal.h>],
                 [siginfo_t* info;],
                 [ac_cv_siginfo_t=true],
                 [ac_cv_siginfo_t=false])])
if test "$ac_cv_siginfo_t" = true ; then
  AC_DEFINE(HAVE_SIGINFO_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

dnl Check for int16_t, int32_t, int64_t, int64, uint, uint_t, and uint16_t.
dnl ========================================================
AC_MSG_CHECKING(for int16_t)
AC_CACHE_VAL(ac_cv_int16_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [int16_t foo = 0;],
                 [ac_cv_int16_t=true],
                 [ac_cv_int16_t=false])])
if test "$ac_cv_int16_t" = true ; then
  AC_DEFINE(HAVE_INT16_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for int32_t)
AC_CACHE_VAL(ac_cv_int32_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [int32_t foo = 0;],
                 [ac_cv_int32_t=true],
                 [ac_cv_int32_t=false])])
if test "$ac_cv_int32_t" = true ; then
  AC_DEFINE(HAVE_INT32_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for int64_t)
AC_CACHE_VAL(ac_cv_int64_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [int64_t foo = 0;],
                 [ac_cv_int64_t=true],
                 [ac_cv_int64_t=false])])
if test "$ac_cv_int64_t" = true ; then
  AC_DEFINE(HAVE_INT64_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for int64)
AC_CACHE_VAL(ac_cv_int64,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [int64 foo = 0;],
                 [ac_cv_int64=true],
                 [ac_cv_int64=false])])
if test "$ac_cv_int64" = true ; then
  AC_DEFINE(HAVE_INT64)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for uint)
AC_CACHE_VAL(ac_cv_uint,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [uint foo = 0;],
                 [ac_cv_uint=true],
                 [ac_cv_uint=false])])
if test "$ac_cv_uint" = true ; then
  AC_DEFINE(HAVE_UINT)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for uint_t)
AC_CACHE_VAL(ac_cv_uint_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [uint_t foo = 0;],
                 [ac_cv_uint_t=true],
                 [ac_cv_uint_t=false])])
if test "$ac_cv_uint_t" = true ; then
  AC_DEFINE(HAVE_UINT_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for uint16_t)
AC_CACHE_VAL(ac_cv_uint16_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [uint16_t foo = 0;],
                 [ac_cv_uint16_t=true],
                 [ac_cv_uint16_t=false])])
if test "$ac_cv_uint16_t" = true ; then
  AC_DEFINE(HAVE_UINT16_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

dnl On the gcc trunk (as of 2001-02-09) _GNU_SOURCE, and thus __USE_GNU,
dnl are defined when compiling C++ but not C.  Since the result of this
dnl test is used only in C++, do it in C++.
AC_LANG_CPLUSPLUS

AC_MSG_CHECKING(for uname.domainname)
AC_CACHE_VAL(ac_cv_have_uname_domainname_field,
    [AC_TRY_COMPILE([#include <sys/utsname.h>],
        [ struct utsname *res; char *domain; 
            (void)uname(res);  if (res != 0) { domain = res->domainname; } ],
        [ac_cv_have_uname_domainname_field=true],
        [ac_cv_have_uname_domainname_field=false])])

if test "$ac_cv_have_uname_domainname_field" = "true"; then
    AC_DEFINE(HAVE_UNAME_DOMAINNAME_FIELD)
    AC_MSG_RESULT(yes)
else
    AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(for uname.__domainname)
AC_CACHE_VAL(ac_cv_have_uname_us_domainname_field,
    [AC_TRY_COMPILE([#include <sys/utsname.h>],
        [ struct utsname *res; char *domain; 
            (void)uname(res);  if (res != 0) { domain = res->__domainname; } ],
        [ac_cv_have_uname_us_domainname_field=true],
        [ac_cv_have_uname_us_domainname_field=false])])

if test "$ac_cv_have_uname_us_domainname_field" = "true"; then
    AC_DEFINE(HAVE_UNAME_US_DOMAINNAME_FIELD)
    AC_MSG_RESULT(yes)
else
    AC_MSG_RESULT(no)
fi

AC_LANG_CPLUSPLUS

dnl Check for usable char16_t (2 bytes, unsigned)
dnl (we might not need the unsignedness check anymore)
AC_CACHE_CHECK(for usable char16_t (2 bytes, unsigned),
    ac_cv_have_usable_char16_t,
    [AC_TRY_COMPILE([$configure_static_assert_macros],
                    [CONFIGURE_STATIC_ASSERT(sizeof(char16_t) == 2);
                     CONFIGURE_STATIC_ASSERT(char16_t(-1) > char16_t(0));
                     CONFIGURE_STATIC_ASSERT(sizeof((u"hello")[0]) == 2);
                     CONFIGURE_STATIC_ASSERT(sizeof(u'a') == 2);
                     CONFIGURE_STATIC_ASSERT(u'\xFFFF' > u'\x0')],
                    ac_cv_have_usable_char16_t="yes",
                    ac_cv_have_usable_char16_t="no")])
if test "$ac_cv_have_usable_char16_t" = "yes"; then
    AC_DEFINE(HAVE_CPP_CHAR16_T)
    HAVE_CPP_CHAR16_T=1
fi

dnl Check for usable wchar_t (2 bytes, unsigned)
dnl (we really don't need the unsignedness check anymore)
dnl ========================================================

AC_CACHE_CHECK(for usable wchar_t (2 bytes, unsigned),
    ac_cv_have_usable_wchar_v2,
    [AC_TRY_COMPILE([#include <stddef.h>
                     $configure_static_assert_macros],
                    [CONFIGURE_STATIC_ASSERT(sizeof(wchar_t) == 2);
                     CONFIGURE_STATIC_ASSERT((wchar_t)-1 > (wchar_t) 0)],
                    ac_cv_have_usable_wchar_v2="yes",
                    ac_cv_have_usable_wchar_v2="no")])
if test "$ac_cv_have_usable_wchar_v2" = "yes"; then
    AC_DEFINE(HAVE_CPP_2BYTE_WCHAR_T)
    HAVE_CPP_2BYTE_WCHAR_T=1
elif test "$ac_cv_have_usable_char16_t" != "yes"; then
dnl This is really gcc-only
dnl Do this test using CXX only since some versions of gcc
dnl 2.95-2.97 have a signed wchar_t in c++ only and some versions
dnl only have short-wchar support for c++.
dnl Note that we assume that mac & win32 have short wchar (see nscore.h)

    _SAVE_CXXFLAGS=$CXXFLAGS
    CXXFLAGS="$CXXFLAGS -fshort-wchar"

    AC_CACHE_CHECK(for compiler -fshort-wchar option, 
        ac_cv_have_usable_wchar_option_v2,
        [AC_TRY_LINK([#include <stddef.h>
                      $configure_static_assert_macros],
                     [CONFIGURE_STATIC_ASSERT(sizeof(wchar_t) == 2);
                      CONFIGURE_STATIC_ASSERT((wchar_t)-1 > (wchar_t) 0)],
                     ac_cv_have_usable_wchar_option_v2="yes",
                     ac_cv_have_usable_wchar_option_v2="no")])

    if test "$ac_cv_have_usable_wchar_option_v2" = "yes"; then
        AC_DEFINE(HAVE_CPP_2BYTE_WCHAR_T)
        HAVE_CPP_2BYTE_WCHAR_T=1
        WCHAR_CFLAGS="-fshort-wchar"
    else    
        CXXFLAGS=$_SAVE_CXXFLAGS
    fi
fi

AC_LANG_C

dnl Check for .hidden assembler directive and visibility attribute.
dnl Borrowed from glibc configure.in
dnl ===============================================================
if test "$GNU_CC"; then
  AC_CACHE_CHECK(for visibility(hidden) attribute,
                 ac_cv_visibility_hidden,
                 [cat > conftest.c <<EOF
                  int foo __attribute__ ((visibility ("hidden"))) = 1;
EOF
                  ac_cv_visibility_hidden=no
                  if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                    if egrep '\.(hidden|private_extern).*foo' conftest.s >/dev/null; then
                      ac_cv_visibility_hidden=yes
                    fi
                  fi
                  rm -f conftest.[cs]
                 ])
  if test "$ac_cv_visibility_hidden" = "yes"; then
    AC_DEFINE(HAVE_VISIBILITY_HIDDEN_ATTRIBUTE)

    AC_CACHE_CHECK(for visibility(default) attribute,
                   ac_cv_visibility_default,
                   [cat > conftest.c <<EOF
                    int foo __attribute__ ((visibility ("default"))) = 1;
EOF
                    ac_cv_visibility_default=no
                    if ${CC-cc} -fvisibility=hidden -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                      if ! egrep '\.(hidden|private_extern).*foo' conftest.s >/dev/null; then
                        ac_cv_visibility_default=yes
                      fi
                    fi
                    rm -f conftest.[cs]
                   ])
    if test "$ac_cv_visibility_default" = "yes"; then
      AC_DEFINE(HAVE_VISIBILITY_ATTRIBUTE)

      AC_CACHE_CHECK(for visibility pragma support,
                     ac_cv_visibility_pragma,
                     [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
                      int foo_hidden = 1;
#pragma GCC visibility push(default)
                      int foo_default = 1;
EOF
                      ac_cv_visibility_pragma=no
                      if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                        if egrep '\.(hidden|private_extern).*foo_hidden' conftest.s >/dev/null; then
                          if ! egrep '\.(hidden|private_extern).*foo_default' conftest.s > /dev/null; then
                            ac_cv_visibility_pragma=yes
                          fi
                        fi
                      fi
                      rm -f conftest.[cs]
                    ])
      if test "$ac_cv_visibility_pragma" = "yes"; then
        AC_CACHE_CHECK(For gcc visibility bug with class-level attributes (GCC bug 26905),
                       ac_cv_have_visibility_class_bug,
                       [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
struct __attribute__ ((visibility ("default"))) TestStruct {
  static void Init();
};
__attribute__ ((visibility ("default"))) void TestFunc() {
  TestStruct::Init();
}
EOF
                       ac_cv_have_visibility_class_bug=no
                       if ! ${CXX-g++} ${CXXFLAGS} ${DSO_PIC_CFLAGS} ${DSO_LDOPTS} -S -o conftest.S conftest.c > /dev/null 2>&1 ; then
                         ac_cv_have_visibility_class_bug=yes
                       else
                         if test `egrep -c '@PLT|\\$stub' conftest.S` = 0; then
                           ac_cv_have_visibility_class_bug=yes
                         fi
                       fi
                       rm -rf conftest.{c,S}
                       ])

        AC_CACHE_CHECK(For x86_64 gcc visibility bug with builtins (GCC bug 20297),
                       ac_cv_have_visibility_builtin_bug,
                       [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
#pragma GCC visibility push(default)
#include <string.h>
#pragma GCC visibility pop

__attribute__ ((visibility ("default"))) void Func() {
  char c[[100]];
  memset(c, 0, sizeof(c));
}
EOF
                       ac_cv_have_visibility_builtin_bug=no
                       if ! ${CC-cc} ${CFLAGS} ${DSO_PIC_CFLAGS} ${DSO_LDOPTS} -O2 -S -o conftest.S conftest.c > /dev/null 2>&1 ; then
                         ac_cv_have_visibility_builtin_bug=yes
                       else
                         if test `grep -c "@PLT" conftest.S` = 0; then
                           ac_cv_visibility_builtin_bug=yes
                         fi
                       fi
                       rm -f conftest.{c,S}
                       ])
        if test "$ac_cv_have_visibility_builtin_bug" = "no" -a \
                "$ac_cv_have_visibility_class_bug" = "no"; then
          VISIBILITY_FLAGS='-I$(DIST)/system_wrappers -include $(topsrcdir)/config/gcc_hidden.h'
          WRAP_SYSTEM_INCLUDES=1
        else
          VISIBILITY_FLAGS='-fvisibility=hidden'
        fi # have visibility pragma bug
      fi   # have visibility pragma
    fi     # have visibility(default) attribute
  fi       # have visibility(hidden) attribute
fi         # GNU_CC

# visibility hidden flag for Sun Studio on Solaris
if test "$SOLARIS_SUNPRO_CC"; then
VISIBILITY_FLAGS='-xldscope=hidden'
fi         # Sun Studio on Solaris

AC_SUBST(WRAP_SYSTEM_INCLUDES)
AC_SUBST(VISIBILITY_FLAGS)

dnl Checks for header files.
dnl ========================================================
AC_HEADER_DIRENT
case "$target_os" in
freebsd*)
# for stuff like -lXshm
    CPPFLAGS="${CPPFLAGS} ${X_CFLAGS}"
    ;;
esac
AC_CHECK_HEADERS(sys/byteorder.h compat.h getopt.h)
AC_CHECK_HEADERS(sys/bitypes.h memory.h unistd.h)
AC_CHECK_HEADERS(gnu/libc-version.h nl_types.h)
AC_CHECK_HEADERS(malloc.h)
AC_CHECK_HEADERS(X11/XKBlib.h)
AC_CHECK_HEADERS(io.h)

dnl These are all the places some variant of statfs can be hiding.
AC_CHECK_HEADERS(sys/statvfs.h sys/statfs.h sys/vfs.h sys/mount.h)

dnl Try for MMX support
dnl NB - later gcc versions require -mmmx for this header to be successfully
dnl included (or another option which implies it, such as -march=pentium-mmx)
AC_CHECK_HEADERS(mmintrin.h)

dnl Check whether the compiler supports the new-style C++ standard
dnl library headers (i.e. <new>) or needs the old "new.h"
AC_LANG_CPLUSPLUS
NEW_H=new.h
AC_CHECK_HEADER(new, [NEW_H=new])
AC_DEFINE_UNQUOTED(NEW_H, <$NEW_H>)
AC_LANG_C

AC_ARG_ENABLE(dtrace,
              [  --enable-dtrace         build with dtrace support if available (default=no)],
              [enable_dtrace="yes"],)
if test "x$enable_dtrace" = "xyes"; then
  AC_CHECK_HEADER(sys/sdt.h, HAVE_DTRACE=1)
  if test -n "$HAVE_DTRACE"; then
      AC_DEFINE(INCLUDE_MOZILLA_DTRACE)
  else
      AC_MSG_ERROR([dtrace enabled but sys/sdt.h not found]);
  fi
fi
AC_SUBST(HAVE_DTRACE)

case $target in
*-aix4.3*|*-aix5*)
	;;
*)
	AC_CHECK_HEADERS(sys/cdefs.h)
	;;
esac

dnl Checks for libraries.
dnl ========================================================
case $target in
*-hpux11.*)
	;;
*)
	AC_CHECK_LIB(c_r, gethostbyname_r)
	;;
esac

dnl We don't want to link with libdl even if it's present on OS X, since
dnl it's not used and not part of the default installation.
dnl The same goes for BeOS.
dnl We don't want to link against libm or libpthread on Darwin since
dnl they both are just symlinks to libSystem and explicitly linking
dnl against libSystem causes issues when debugging (see bug 299601).
case $target in
*-darwin*)
    ;;
*-beos*)
    ;;
*)
    AC_CHECK_LIB(m, atan)
    AC_CHECK_LIB(dl, dlopen,
    AC_CHECK_HEADER(dlfcn.h, 
        LIBS="-ldl $LIBS"
        AC_DEFINE(HAVE_LIBDL)))
    ;;
esac

_SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -D_GNU_SOURCE"
AC_CHECK_FUNCS(dladdr)
CFLAGS="$_SAVE_CFLAGS"

if test ! "$GNU_CXX"; then

    case $target in
    *-aix*)
	AC_CHECK_LIB(C_r, demangle)
	;;
     *)
	AC_CHECK_LIB(C, demangle)
	;;
     esac
fi
AC_CHECK_LIB(socket, socket)

dnl ========================================================
dnl Check whether we can compile code for Core Text
dnl (Mac OS X 10.5 or later)
dnl ========================================================
case "$target" in
*-darwin*)
  AC_MSG_CHECKING([for Core Text])
  AC_TRY_COMPILE([#include <ApplicationServices/ApplicationServices.h>],
                 [CTLineRef lineRef;],
                  ac_cv_have_core_text="yes",
                  ac_cv_have_core_text="no")
  AC_MSG_RESULT([$ac_cv_have_core_text])

  case "${target_cpu}" in
  x86_64)
    MOZ_CORETEXT=1
    ;;
  esac

  MOZ_ARG_ENABLE_BOOL(coretext,
[  --enable-coretext      Use CoreText instead of ATSUI for text rendering],
    MOZ_CORETEXT=1,
    MOZ_CORETEXT=)

  if test -n "$MOZ_CORETEXT"; then
    if test "$ac_cv_have_core_text" = "no"; then
      AC_MSG_ERROR([--enable-coretext requires MacOS SDK 10.5 or newer])
     fi
     AC_DEFINE(MOZ_CORETEXT)
  fi
  ;;
esac

AC_SUBST(MOZ_CORETEXT)

XLDFLAGS="$X_LIBS"
XLIBS="$X_EXTRA_LIBS"

dnl ========================================================
dnl Checks for X libraries.
dnl Ordering is important.
dnl Xt is dependent upon SM as of X11R6
dnl ========================================================
if test "$no_x" = "yes"; then
    AC_DEFINE(NO_X11)
else
    AC_DEFINE_UNQUOTED(FUNCPROTO,15)
	XLIBS="-lX11 $XLIBS"
	_SAVE_LDFLAGS="$LDFLAGS"
	LDFLAGS="$XLDFLAGS $LDFLAGS"
	AC_CHECK_LIB(X11, XDrawLines, [X11_LIBS="-lX11"],
		[MISSING_X="$MISSING_X -lX11"], $XLIBS)
	AC_CHECK_LIB(Xext, XextAddDisplay, [XEXT_LIBS="-lXext"],
		[MISSING_X="$MISSING_X -lXext"], $XLIBS)
     
	AC_CHECK_LIB(Xt, XtFree, [ XT_LIBS="-lXt"], [
        unset ac_cv_lib_Xt_XtFree
	    AC_CHECK_LIB(ICE, IceFlush, [XT_LIBS="-lICE $XT_LIBS"],, $XT_LIBS $XLIBS)
	    AC_CHECK_LIB(SM, SmcCloseConnection, [XT_LIBS="-lSM $XT_LIBS"],, $XT_LIBS $XLIBS) 
        AC_CHECK_LIB(Xt, XtFree, [ XT_LIBS="-lXt $XT_LIBS"],
		    [MISSING_X="$MISSING_X -lXt"], $X_PRE_LIBS $XT_LIBS $XLIBS)
        ])

    # AIX needs the motif library linked before libXt to prevent
    # crashes in plugins linked against Motif - Bug #98892
    case "${target_os}" in
    aix*)
        XT_LIBS="-lXm $XT_LIBS"
        ;;
    esac

    dnl ========================================================
    dnl = Check for XShm
    dnl ========================================================
    AC_CHECK_LIB(Xext, XShmCreateImage, _HAVE_XSHM_XEXT=1,,
        $XLIBS $XEXT_LIBS)
    AC_CHECK_HEADER(X11/extensions/XShm.h)
    if test "$ac_cv_header_X11_extensions_XShm_h" = "yes" &&
        test -n "$_HAVE_XSHM_XEXT"; then
        AC_DEFINE(HAVE_XSHM)
    fi

    dnl ========================================================
    dnl = Check for XIE
    dnl ========================================================
    AC_CHECK_LIB(XIE, XieFloGeometry, [MOZ_XIE_LIBS="-lXIE"],,
        $XLIBS $XEXT_LIBS)
    AC_CHECK_HEADER(X11/extensions/XIElib.h)

    if test "$MOZ_XIE_LIBS"; then
	dnl ====================================================
	dnl = If XIE is present and is desired, turn it on
	dnl ====================================================
	case $target in
	    *-hpux*)
		;;
	    *)
		HAVE_XIE=1
		;;
	esac
    fi

	LDFLAGS="$_SAVE_LDFLAGS"

    dnl ========================================================
    dnl = Check for freetype2 and its functionality
    dnl ========================================================
    AC_CHECK_FT2(6.1.0, [_HAVE_FREETYPE2=1], [_HAVE_FREETYPE2=])

    if test "$_HAVE_FREETYPE2"; then
    	_SAVE_LIBS="$LIBS"
    	_SAVE_CFLAGS="$CFLAGS"
    	LIBS="$LIBS $FT2_LIBS"
    	CFLAGS="$CFLAGS $FT2_CFLAGS"

        AC_CACHE_CHECK(for FT_Bitmap_Size.y_ppem,
            ac_cv_member_FT_Bitmap_Size_y_ppem,
            [AC_TRY_COMPILE([#include <ft2build.h>
                             #include FT_FREETYPE_H],
                            [FT_Bitmap_Size s;
                             if (sizeof s.y_ppem) return 0;
                             return 1],
                            ac_cv_member_FT_Bitmap_Size_y_ppem=yes,
                            ac_cv_member_FT_Bitmap_Size_y_ppem=no)])
        if test "$ac_cv_member_FT_Bitmap_Size_y_ppem" = yes; then
            HAVE_FT_BITMAP_SIZE_Y_PPEM=1
        else
            HAVE_FT_BITMAP_SIZE_Y_PPEM=0
        fi
        AC_DEFINE_UNQUOTED(HAVE_FT_BITMAP_SIZE_Y_PPEM,
                           $HAVE_FT_BITMAP_SIZE_Y_PPEM,
                           [FT_Bitmap_Size structure includes y_ppem field])

        AC_CHECK_FUNCS(FT_GlyphSlot_Embolden FT_Load_Sfnt_Table FT_Select_Size)

    	LIBS="$_SAVE_LIBS"
    	CFLAGS="$_SAVE_CFLAGS"
    fi

fi # $no_x

AC_SUBST(XCFLAGS)
AC_SUBST(XLDFLAGS)
AC_SUBST(XLIBS)
AC_SUBST(XEXT_LIBS)
AC_SUBST(XT_LIBS)

AC_MSG_CHECKING(for ARM SIMD support in compiler)
AC_TRY_COMPILE([],
               [asm("uqadd8 r1, r1, r2");],
               result="yes", result="no")
AC_MSG_RESULT("$result")
if test "$result" = "yes"; then
    AC_DEFINE(HAVE_ARM_SIMD)
    HAVE_ARM_SIMD=1
fi
AC_SUBST(HAVE_ARM_SIMD)

AC_MSG_CHECKING(for ARM NEON support in compiler)
_SAVE_CFLAGS="$CFLAGS"
if test "$GNU_CC"; then
  # gcc needs -mfpu=neon to recognize NEON instructions
  CFLAGS="$CFLAGS -mfpu=neon"
fi
AC_TRY_COMPILE([],
               [asm("vadd.i8 d0, d0, d0");],
               result="yes", result="no")
AC_MSG_RESULT("$result")
if test "$result" = "yes"; then
    AC_DEFINE(HAVE_ARM_NEON)
    HAVE_ARM_NEON=1
fi
CFLAGS="$_SAVE_CFLAGS"
AC_SUBST(HAVE_ARM_NEON)

dnl ========================================================
dnl = pthread support
dnl = Start by checking whether the system support pthreads
dnl ========================================================
case "$target_os" in
darwin*)
    USE_PTHREADS=1
    ;;
*)
    MOZ_CHECK_PTHREADS(pthreads,
        USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthreads",
        MOZ_CHECK_PTHREADS(pthread,
            USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthread",
            MOZ_CHECK_PTHREADS(c_r,
                USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lc_r",
                MOZ_CHECK_PTHREADS(c,
                    USE_PTHREADS=1
                )
            )
        )
    )
    ;;
esac

dnl ========================================================
dnl Check the command line for --with-pthreads 
dnl ========================================================
MOZ_ARG_WITH_BOOL(pthreads,
[  --with-pthreads         Force use of system pthread library with NSPR ],
[ if test "$USE_PTHREADS"x = x; then
    AC_MSG_ERROR([ --with-pthreads specified for a system without pthread support ]);
fi],
    USE_PTHREADS=
    _PTHREAD_LDFLAGS=
)

dnl ========================================================
dnl Do the platform specific pthread hackery
dnl ========================================================
if test "$USE_PTHREADS"x != x
then
	dnl
	dnl See if -pthread is supported.
	dnl
	rm -f conftest*
	ac_cv_have_dash_pthread=no
	AC_MSG_CHECKING(whether ${CC-cc} accepts -pthread)
	echo 'int main() { return 0; }' | cat > conftest.c
	${CC-cc} -pthread -o conftest conftest.c > conftest.out 2>&1
	if test $? -eq 0; then
		if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthread`" && test -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
			ac_cv_have_dash_pthread=yes
	        case "$target_os" in
	        freebsd*)
# Freebsd doesn't use -pthread for compiles, it uses them for linking
                ;;
	        *)
			    CFLAGS="$CFLAGS -pthread"
			    CXXFLAGS="$CXXFLAGS -pthread"
                ;;
	        esac
		fi
	fi
	rm -f conftest*
    AC_MSG_RESULT($ac_cv_have_dash_pthread)

	dnl
	dnl See if -pthreads is supported.
	dnl
    ac_cv_have_dash_pthreads=no
    if test "$ac_cv_have_dash_pthread" = "no"; then
	    AC_MSG_CHECKING(whether ${CC-cc} accepts -pthreads)
    	echo 'int main() { return 0; }' | cat > conftest.c
	    ${CC-cc} -pthreads -o conftest conftest.c > conftest.out 2>&1
    	if test $? -eq 0; then
	    	if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthreads`" && test -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
			    ac_cv_have_dash_pthreads=yes
			    CFLAGS="$CFLAGS -pthreads"
			    CXXFLAGS="$CXXFLAGS -pthreads"
		    fi
	    fi
	    rm -f conftest*
    	AC_MSG_RESULT($ac_cv_have_dash_pthreads)
    fi

	case "$target" in
	    *-*-freebsd*)
			AC_DEFINE(_REENTRANT)
			AC_DEFINE(_THREAD_SAFE)
			dnl -pthread links in -lc_r, so don't specify it explicitly.
			if test "$ac_cv_have_dash_pthread" = "yes"; then
				_PTHREAD_LDFLAGS="-pthread"
			else
				_PTHREAD_LDFLAGS="-lc_r"
			fi
			;;

	    *-*-openbsd*|*-*-bsdi*)
			AC_DEFINE(_REENTRANT)
			AC_DEFINE(_THREAD_SAFE)
			dnl -pthread links in -lc_r, so don't specify it explicitly.
			if test "$ac_cv_have_dash_pthread" = "yes"; then
                _PTHREAD_LDFLAGS="-pthread"
			fi
			;;

	    *-*-linux*|*-*-kfreebsd*-gnu)
			AC_DEFINE(_REENTRANT) 
			;;

	    *-*-nto*) 
			AC_DEFINE(_REENTRANT) 
			;;

	    *-aix4.3*|*-aix5*)
			AC_DEFINE(_REENTRANT) 
			;;

	    *-hpux11.*)
			AC_DEFINE(_REENTRANT) 
			;;

	    alpha*-*-osf*)
			AC_DEFINE(_REENTRANT)
			;;

	    *-*-solaris*) 
			AC_DEFINE(_REENTRANT)
			if test "$SOLARIS_SUNPRO_CC"; then
				CFLAGS="$CFLAGS -mt" 
				CXXFLAGS="$CXXFLAGS -mt" 
			fi
			;;
	esac
    LDFLAGS="${_PTHREAD_LDFLAGS} ${LDFLAGS}"
fi

dnl ========================================================
dnl See if mmap sees writes
dnl For cross compiling, just define it as no, which is a safe default
dnl ========================================================
AC_MSG_CHECKING(whether mmap() sees write()s)

changequote(,)
mmap_test_prog='
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>

    char fname[] = "conftest.file";
    char zbuff[1024]; /* Fractional page is probably worst case */

    int main() {
	char *map;
	int fd;
	int i;
	unlink(fname);
	fd = open(fname, O_RDWR | O_CREAT, 0660);
	if(fd<0) return 1;
	unlink(fname);
	write(fd, zbuff, sizeof(zbuff));
	lseek(fd, 0, SEEK_SET);
	map = (char*)mmap(0, sizeof(zbuff), PROT_READ, MAP_SHARED, fd, 0);
	if(map==(char*)-1) return 2;
	for(i=0; fname[i]; i++) {
	    int rc = write(fd, &fname[i], 1);
	    if(map[i]!=fname[i]) return 4;
	}
	return 0;
    }
'
changequote([,])

AC_TRY_RUN($mmap_test_prog , result="yes", result="no", result="yes")

AC_MSG_RESULT("$result")

if test "$result" = "no"; then
    AC_DEFINE(MMAP_MISSES_WRITES)
fi


dnl Checks for library functions.
dnl ========================================================
AC_PROG_GCC_TRADITIONAL
AC_FUNC_MEMCMP
AC_CHECK_FUNCS(random strerror lchown fchmod snprintf statvfs memmove rint stat64 lstat64 truncate64 statvfs64 setbuf isatty)
AC_CHECK_FUNCS(flockfile getpagesize)
AC_CHECK_FUNCS(localtime_r strtok_r)

dnl check for wcrtomb/mbrtowc
dnl =======================================================================
if test -z "$MACOS_DEPLOYMENT_TARGET" || test "$MACOS_DEPLOYMENT_TARGET" -ge "100300"; then
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_CACHE_CHECK(for wcrtomb,
    ac_cv_have_wcrtomb,
    [AC_TRY_LINK([#include <wchar.h>],
                 [mbstate_t ps={0};wcrtomb(0,'f',&ps);],
                 ac_cv_have_wcrtomb="yes",
                 ac_cv_have_wcrtomb="no")])
if test "$ac_cv_have_wcrtomb" = "yes"; then
    AC_DEFINE(HAVE_WCRTOMB)
fi
AC_CACHE_CHECK(for mbrtowc,
    ac_cv_have_mbrtowc,
    [AC_TRY_LINK([#include <wchar.h>],
                 [mbstate_t ps={0};mbrtowc(0,0,0,&ps);],
                 ac_cv_have_mbrtowc="yes",
                 ac_cv_have_mbrtowc="no")])
if test "$ac_cv_have_mbrtowc" = "yes"; then
    AC_DEFINE(HAVE_MBRTOWC)
fi
AC_LANG_RESTORE
fi

AC_CACHE_CHECK(
    [for res_ninit()],
    ac_cv_func_res_ninit,
    [AC_TRY_LINK([
        #ifdef linux
        #define _BSD_SOURCE 1
        #endif
        #include <resolv.h>
        ],
        [int foo = res_ninit(&_res);],
        [ac_cv_func_res_ninit=yes],
        [ac_cv_func_res_ninit=no])
    ])

if test "$ac_cv_func_res_ninit" = "yes"; then
    AC_DEFINE(HAVE_RES_NINIT)
dnl must add the link line we do something as foolish as this... dougt
dnl else
dnl    AC_CHECK_LIB(bind, res_ninit, AC_DEFINE(HAVE_RES_NINIT),
dnl        AC_CHECK_LIB(resolv, res_ninit, AC_DEFINE(HAVE_RES_NINIT)))
fi

AC_LANG_CPLUSPLUS
AC_CACHE_CHECK(
    [for gnu_get_libc_version()],
    ac_cv_func_gnu_get_libc_version,
    [AC_TRY_LINK([
        #ifdef HAVE_GNU_LIBC_VERSION_H
        #include <gnu/libc-version.h>
        #endif
        ],
        [const char *glibc_version = gnu_get_libc_version();],
        [ac_cv_func_gnu_get_libc_version=yes],
        [ac_cv_func_gnu_get_libc_version=no] 
        )]
    )

if test "$ac_cv_func_gnu_get_libc_version" = "yes"; then
    AC_DEFINE(HAVE_GNU_GET_LIBC_VERSION)
fi

case $target_os in
    os2*|msvc*|mks*|cygwin*|mingw*|darwin*|wince*|beos*)
        ;;
    *)
    
AC_CHECK_LIB(c, iconv, [_ICONV_LIBS="$_ICONV_LIBS"],
    AC_CHECK_LIB(iconv, iconv, [_ICONV_LIBS="$_ICONV_LIBS -liconv"],
        AC_CHECK_LIB(iconv, libiconv, [_ICONV_LIBS="$_ICONV_LIBS -liconv"])))
_SAVE_LIBS=$LIBS
LIBS="$LIBS $_ICONV_LIBS"
AC_CACHE_CHECK(
    [for iconv()],
    ac_cv_func_iconv,
    [AC_TRY_LINK([
        #include <stdlib.h>
        #include <iconv.h>
        ],
        [
            iconv_t h = iconv_open("", "");
            iconv(h, NULL, NULL, NULL, NULL);
            iconv_close(h);
        ],
        [ac_cv_func_iconv=yes],
        [ac_cv_func_iconv=no] 
        )]
    )
if test "$ac_cv_func_iconv" = "yes"; then
    AC_DEFINE(HAVE_ICONV)
    DYNAMIC_XPCOM_LIBS="$DYNAMIC_XPCOM_LIBS $_ICONV_LIBS"
    LIBXUL_LIBS="$LIBXUL_LIBS $_ICONV_LIBS"
    LIBICONV="$_ICONV_LIBS"
    AC_CACHE_CHECK(
        [for iconv() with const input],
        ac_cv_func_const_iconv,
        [AC_TRY_COMPILE([
            #include <stdlib.h>
            #include <iconv.h>
            ],
            [
                const char *input = "testing";
                iconv_t h = iconv_open("", "");
                iconv(h, &input, NULL, NULL, NULL);
                iconv_close(h);
            ],
            [ac_cv_func_const_iconv=yes],
            [ac_cv_func_const_iconv=no] 
            )]
        )
    if test "$ac_cv_func_const_iconv" = "yes"; then
        AC_DEFINE(HAVE_ICONV_WITH_CONST_INPUT)
    fi
fi
LIBS=$_SAVE_LIBS

    ;;
esac

AM_LANGINFO_CODESET

AC_LANG_C

dnl **********************
dnl *** va_copy checks ***
dnl **********************
dnl we currently check for all three va_copy possibilities, so we get
dnl all results in config.log for bug reports.
AC_MSG_CHECKING(for an implementation of va_copy())
AC_CACHE_VAL(ac_cv_va_copy,[
    AC_TRY_RUN([
        #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; }],
        ac_cv_va_copy=yes,
        ac_cv_va_copy=no,
        ac_cv_va_copy=no
    )
])
AC_MSG_RESULT($ac_cv_va_copy)
AC_MSG_CHECKING(for an implementation of __va_copy())
AC_CACHE_VAL(ac_cv___va_copy,[
    AC_TRY_RUN([
        #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; }],
        ac_cv___va_copy=yes,
        ac_cv___va_copy=no,
        ac_cv___va_copy=no
    )
])
AC_MSG_RESULT($ac_cv___va_copy)
AC_MSG_CHECKING(whether va_lists can be copied by value)
AC_CACHE_VAL(ac_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; }],
        ac_cv_va_val_copy=yes,
        ac_cv_va_val_copy=no,
        ac_cv_va_val_copy=yes
    )
])
if test "x$ac_cv_va_copy" = "xyes"; then
    AC_DEFINE(VA_COPY, va_copy)
    AC_DEFINE(HAVE_VA_COPY)
elif test "x$ac_cv___va_copy" = "xyes"; then
    AC_DEFINE(VA_COPY, __va_copy)
    AC_DEFINE(HAVE_VA_COPY)
fi

if test "x$ac_cv_va_val_copy" = "xno"; then
   AC_DEFINE(HAVE_VA_LIST_AS_ARRAY)
fi
AC_MSG_RESULT($ac_cv_va_val_copy)

dnl Check for dll-challenged libc's.
dnl This check is apparently only needed for Linux.
case "$target" in
	*-linux*)
	    dnl ===================================================================
	    _curdir=`pwd`
	    export _curdir
	    rm -rf conftest* _conftest
	    mkdir _conftest
	    cat >> conftest.C <<\EOF
#include <stdio.h>
#include <link.h>
#include <dlfcn.h>
#ifdef _dl_loaded
void __dump_link_map(void) {
  struct link_map *map = _dl_loaded;
  while (NULL != map) {printf("0x%08x %s\n", map->l_addr, map->l_name); map = map->l_next;}
}
int main() {
  dlopen("./conftest1.so",RTLD_LAZY);
  dlopen("./../_conftest/conftest1.so",RTLD_LAZY);
  dlopen("CURDIR/_conftest/conftest1.so",RTLD_LAZY);
  dlopen("CURDIR/_conftest/../_conftest/conftest1.so",RTLD_LAZY);
  __dump_link_map();
}
#else
/* _dl_loaded isn't defined, so this should be either a libc5 (glibc1) system, or a glibc2 system that doesn't have the multiple load bug (i.e., RH6.0).*/
int main() { printf("./conftest1.so\n"); }
#endif
EOF

	    $PERL -p -i -e "s/CURDIR/\$ENV{_curdir}/g;" conftest.C

	    cat >> conftest1.C <<\EOF
#include <stdio.h>
void foo(void) {printf("foo in dll called\n");}
EOF
	    ${CXX-g++} -fPIC -c -g conftest1.C
	    ${CXX-g++} -shared -Wl,-h -Wl,conftest1.so -o conftest1.so conftest1.o
	    ${CXX-g++} -g conftest.C -o conftest -ldl
	    cp -f conftest1.so conftest _conftest
	    cd _conftest
	    if test `./conftest | grep conftest1.so | wc -l` -gt 1
	    then
		echo
		echo "*** Your libc has a bug that can result in loading the same dynamic"
		echo "*** library multiple times.  This bug is known to be fixed in glibc-2.0.7-32"
		echo "*** or later.  However, if you choose not to upgrade, the only effect"
		echo "*** will be excessive memory usage at runtime."
		echo
	    fi
	    cd ${_curdir}
	    rm -rf conftest* _conftest
	    dnl ===================================================================
	    ;;
esac

dnl ===================================================================
dnl ========================================================
dnl By default, turn rtti and exceptions off on g++/egcs
dnl ========================================================
if test "$GNU_CXX"; then

  AC_MSG_CHECKING(for C++ exceptions flag)

  dnl They changed -f[no-]handle-exceptions to -f[no-]exceptions in g++ 2.8
  AC_CACHE_VAL(ac_cv_cxx_exceptions_flags,
  [echo "int main() { return 0; }" | cat > conftest.C

  ${CXX-g++} ${CXXFLAGS} -c -fno-handle-exceptions conftest.C > conftest.out 2>&1

  if egrep "warning.*renamed" conftest.out >/dev/null; then
    ac_cv_cxx_exceptions_flags=${_COMPILER_PREFIX}-fno-exceptions
  else
    ac_cv_cxx_exceptions_flags=${_COMPILER_PREFIX}-fno-handle-exceptions
  fi

  rm -f conftest*])

  AC_MSG_RESULT($ac_cv_cxx_exceptions_flags)
  _MOZ_EXCEPTIONS_FLAGS_OFF=$ac_cv_cxx_exceptions_flags
  _MOZ_EXCEPTIONS_FLAGS_ON=`echo $ac_cv_cxx_exceptions_flags | sed 's|no-||'`
fi

dnl ========================================================
dnl Put your C++ language/feature checks below
dnl ========================================================
AC_LANG_CPLUSPLUS

HAVE_GCC3_ABI=
if test "$GNU_CC"; then
  AC_CACHE_CHECK(for gcc 3.0 ABI,
      ac_cv_gcc_three_abi,
      [AC_TRY_COMPILE([],
                      [
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */
  return 0;
#else
#error Not gcc3.
#endif
                      ],
                      ac_cv_gcc_three_abi="yes",
                      ac_cv_gcc_three_abi="no")])
  if test "$ac_cv_gcc_three_abi" = "yes"; then
      TARGET_COMPILER_ABI="${TARGET_COMPILER_ABI-gcc3}"
      HAVE_GCC3_ABI=1
  else
      TARGET_COMPILER_ABI="${TARGET_COMPILER_ABI-gcc2}"
  fi
fi
AC_SUBST(HAVE_GCC3_ABI)


AC_CACHE_CHECK(for C++ \"explicit\" keyword,
               ac_cv_cpp_explicit,
               [AC_TRY_COMPILE(class X {
                               public: explicit X(int i) : i_(i) {}
                               private: int i_;
                               };,
                               X x(3);,
                               ac_cv_cpp_explicit=yes,
                               ac_cv_cpp_explicit=no)])
if test "$ac_cv_cpp_explicit" = yes ; then
   AC_DEFINE(HAVE_CPP_EXPLICIT)
fi

AC_CACHE_CHECK(for C++ \"typename\" keyword,
               ac_cv_cpp_typename,
               [AC_TRY_COMPILE(class param {
                               public:
                                   typedef unsigned long num_type;
                               };

                               template <class T> class tplt {
                               public:
                                   typedef typename T::num_type t_num_type;
                                   t_num_type foo(typename T::num_type num) {
                                       return num;
                                   }
                               };,
                               tplt<param> A;
                               A.foo(0);,
                               ac_cv_cpp_typename=yes,
                               ac_cv_cpp_typename=no)])
if test "$ac_cv_cpp_typename" = yes ; then
   AC_DEFINE(HAVE_CPP_TYPENAME)
fi

dnl Check for support of modern template specialization syntax
dnl Test code and requirement from scc@netscape.com.
dnl Autoconf cut-and-paste job by waterson@netscape.com
AC_CACHE_CHECK(for modern C++ template specialization syntax support,
               ac_cv_cpp_modern_specialize_template_syntax,
               [AC_TRY_COMPILE(template <class T> struct X { int a; };
                               class Y {};
                               template <> struct X<Y> { double a; };,
                               X<int> int_x;
                               X<Y> y_x;,
                               ac_cv_cpp_modern_specialize_template_syntax=yes,
                               ac_cv_cpp_modern_specialize_template_syntax=no)])
if test "$ac_cv_cpp_modern_specialize_template_syntax" = yes ; then
  AC_DEFINE(HAVE_CPP_MODERN_SPECIALIZE_TEMPLATE_SYNTAX)
fi


dnl Some compilers support only full specialization, and some don't.
AC_CACHE_CHECK(whether partial template specialization works,
               ac_cv_cpp_partial_specialization,
               [AC_TRY_COMPILE(template <class T> class Foo {};
                               template <class T> class Foo<T*> {};,
                               return 0;,
                               ac_cv_cpp_partial_specialization=yes,
                               ac_cv_cpp_partial_specialization=no)])
if test "$ac_cv_cpp_partial_specialization" = yes ; then
  AC_DEFINE(HAVE_CPP_PARTIAL_SPECIALIZATION)
fi

dnl Some compilers have limited support for operators with templates;
dnl specifically, it is necessary to define derived operators when a base
dnl class's operator declaration should suffice.
AC_CACHE_CHECK(whether operators must be re-defined for templates derived from templates,
               ac_cv_need_derived_template_operators,
               [AC_TRY_COMPILE([template <class T> class Base { };
                                template <class T>
                                Base<T> operator+(const Base<T>& lhs, const Base<T>& rhs) { return lhs; }
                                template <class T> class Derived : public Base<T> { };],
                               [Derived<char> a, b;
                                Base<char> c = a + b;
                                return 0;],
                               ac_cv_need_derived_template_operators=no,
                               ac_cv_need_derived_template_operators=yes)])
if test "$ac_cv_need_derived_template_operators" = yes ; then
  AC_DEFINE(NEED_CPP_DERIVED_TEMPLATE_OPERATORS)
fi


dnl Some compilers have trouble detecting that a template class
dnl that derives from another template is actually an instance
dnl of the base class. This test checks for that.
AC_CACHE_CHECK(whether we need to cast a derived template to pass as its base class,
               ac_cv_need_cpp_template_cast_to_base,
               [AC_TRY_COMPILE([template <class T> class Base { };
                                template <class T> class Derived : public Base<T> { };
                                template <class T> int foo(const Base<T>&) { return 0; }],
                               [Derived<char> bar; return foo(bar);],
                               ac_cv_need_cpp_template_cast_to_base=no,
                               ac_cv_need_cpp_template_cast_to_base=yes)])
if test "$ac_cv_need_cpp_template_cast_to_base" = yes ; then
  AC_DEFINE(NEED_CPP_TEMPLATE_CAST_TO_BASE)
fi

dnl Some compilers have trouble resolving the ambiguity between two
dnl functions whose arguments differ only by cv-qualifications.
AC_CACHE_CHECK(whether the compiler can resolve const ambiguities for templates,
               ac_cv_can_resolve_const_ambiguity,
               [AC_TRY_COMPILE([
                                template <class T> class ptrClass {
                                  public: T* ptr;
                                };

                                template <class T> T* a(ptrClass<T> *arg) {
                                  return arg->ptr;
                                }

                                template <class T>
                                const T* a(const ptrClass<T> *arg) {
                                  return arg->ptr;
                                }
                               ],
                               [ ptrClass<int> i;
                                 a(&i); ],
                               ac_cv_can_resolve_const_ambiguity=yes,
                               ac_cv_can_resolve_const_ambiguity=no)])
if test "$ac_cv_can_resolve_const_ambiguity" = no ; then
  AC_DEFINE(CANT_RESOLVE_CPP_CONST_AMBIGUITY)
fi

dnl
dnl We don't do exceptions on unix.  The only reason this used to be here
dnl is that mozilla/xpcom/tests/TestCOMPtr.cpp has a test which uses 
dnl exceptions.  But, we turn exceptions off by default and this test breaks.
dnl So im commenting this out until someone writes some artificial 
dnl intelligence to detect not only if the compiler has exceptions, but if 
dnl they are enabled as well.
dnl 
dnl AC_CACHE_CHECK(for C++ \"exceptions\",
dnl                ac_cv_cpp_exceptions,
dnl                [AC_TRY_COMPILE(class X { public: X() {} };
dnl                                static void F() { throw X(); },
dnl                                try { F(); } catch(X & e) { },
dnl                                ac_cv_cpp_exceptions=yes,
dnl                                ac_cv_cpp_exceptions=no)])
dnl if test $ac_cv_cpp_exceptions = yes ; then
dnl    AC_DEFINE(HAVE_CPP_EXCEPTIONS)
dnl fi

dnl Some compilers have marginal |using| support; for example, gcc-2.7.2.3
dnl supports it well enough to allow us to use it to change access, but not
dnl to resolve ambiguity. The next two tests determine how well the |using|
dnl keyword is supported.
dnl
dnl Check to see if we can change access with |using|.  Test both a
dnl legal and an illegal example.
AC_CACHE_CHECK(whether the C++ \"using\" keyword can change access,
               ac_cv_cpp_access_changing_using2,
               [AC_TRY_COMPILE(
                   class A { protected: int foo() { return 0; } };
                   class B : public A { public: using A::foo; };,
                   B b; return b.foo();,
                   [AC_TRY_COMPILE(
                       class A { public: int foo() { return 1; } };
                       class B : public A { private: using A::foo; };,
                       B b; return b.foo();,
                       ac_cv_cpp_access_changing_using2=no,
                       ac_cv_cpp_access_changing_using2=yes)],
                   ac_cv_cpp_access_changing_using2=no)])
if test "$ac_cv_cpp_access_changing_using2" = yes ; then
   AC_DEFINE(HAVE_CPP_ACCESS_CHANGING_USING)
fi

dnl Check to see if we can resolve ambiguity with |using|.
AC_CACHE_CHECK(whether the C++ \"using\" keyword resolves ambiguity,
               ac_cv_cpp_ambiguity_resolving_using,
               [AC_TRY_COMPILE(class X { 
                                 public: int go(const X&) {return 3;}
                                         int jo(const X&) {return 3;}
                               };
                               class Y : public X {
                                 public:  int go(int) {return 2;}
                                          int jo(int) {return 2;}
                                          using X::jo;
                                 private: using X::go;
                               };,
                               X x; Y y; y.jo(x);,
                               ac_cv_cpp_ambiguity_resolving_using=yes,
                               ac_cv_cpp_ambiguity_resolving_using=no)])
if test "$ac_cv_cpp_ambiguity_resolving_using" = yes ; then
   AC_DEFINE(HAVE_CPP_AMBIGUITY_RESOLVING_USING)
fi

dnl Check to see if the |std| namespace is supported. If so, we'll want
dnl to qualify any standard library calls with "std::" to ensure that
dnl those functions can be resolved.
AC_CACHE_CHECK(for \"std::\" namespace,
               ac_cv_cpp_namespace_std,
               [AC_TRY_COMPILE([#include <algorithm>],
                               [return std::min(0, 1);],
                               ac_cv_cpp_namespace_std=yes,
                               ac_cv_cpp_namespace_std=no)])
if test "$ac_cv_cpp_namespace_std" = yes ; then
   AC_DEFINE(HAVE_CPP_NAMESPACE_STD)
fi

dnl Older compilers are overly ambitious with respect to using the standard
dnl template library's |operator!=()| when |operator==()| is defined. In
dnl which case, defining |operator!=()| in addition to |operator==()| causes
dnl ambiguity at compile-time. This test checks for that case.
AC_CACHE_CHECK(whether standard template operator!=() is ambiguous,
               ac_cv_cpp_unambiguous_std_notequal,
               [AC_TRY_COMPILE([#include <algorithm>
                                struct T1 {};
                                int operator==(const T1&, const T1&) { return 0; }
                                int operator!=(const T1&, const T1&) { return 0; }],
                               [T1 a,b; return a != b;],
                               ac_cv_cpp_unambiguous_std_notequal=unambiguous,
                               ac_cv_cpp_unambiguous_std_notequal=ambiguous)])
if test "$ac_cv_cpp_unambiguous_std_notequal" = unambiguous ; then
  AC_DEFINE(HAVE_CPP_UNAMBIGUOUS_STD_NOTEQUAL)
fi


AC_CACHE_CHECK(for C++ reinterpret_cast,
               ac_cv_cpp_reinterpret_cast,
               [AC_TRY_COMPILE(struct X { int i; };
                               struct Y { int i; };,
                               X x; X*const z = &x;Y*y = reinterpret_cast<Y*>(z);,
                               ac_cv_cpp_reinterpret_cast=yes,
                               ac_cv_cpp_reinterpret_cast=no)])
if test "$ac_cv_cpp_reinterpret_cast" = yes ; then
   AC_DEFINE(HAVE_CPP_NEW_CASTS)
fi

dnl See if a dynamic_cast to void* gives the most derived object.
AC_CACHE_CHECK(for C++ dynamic_cast to void*,
               ac_cv_cpp_dynamic_cast_void_ptr,
               [AC_TRY_RUN([class X { int i; public: virtual ~X() { } };
                            class Y { int j; public: virtual ~Y() { } };
                            class Z : public X, public Y { int k; };

                            int main() {
                                 Z mdo;
                                 X *subx = (X*)&mdo;
                                 Y *suby = (Y*)&mdo;
                                 return !((((void*)&mdo != (void*)subx) &&
                                           ((void*)&mdo == dynamic_cast<void*>(subx))) ||
                                          (((void*)&mdo != (void*)suby) &&
                                           ((void*)&mdo == dynamic_cast<void*>(suby))));
                            }],
                           ac_cv_cpp_dynamic_cast_void_ptr=yes,
                           ac_cv_cpp_dynamic_cast_void_ptr=no,
                           ac_cv_cpp_dynamic_cast_void_ptr=no)])
if test "$ac_cv_cpp_dynamic_cast_void_ptr" = yes ; then
   AC_DEFINE(HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR)
fi


dnl note that this one is reversed - if the test fails, then
dnl we require implementations of unused virtual methods. Which
dnl really blows because it means we'll have useless vtable
dnl bloat.
AC_CACHE_CHECK(whether C++ requires implementation of unused virtual methods,
               ac_cv_cpp_unused_required,
               [AC_TRY_LINK(class X {private: virtual void never_called();};,
                               X x;,
                               ac_cv_cpp_unused_required=no,
                               ac_cv_cpp_unused_required=yes)])
if test "$ac_cv_cpp_unused_required" = yes ; then
   AC_DEFINE(NEED_CPP_UNUSED_IMPLEMENTATIONS)
fi


dnl Some compilers have trouble comparing a constant reference to a templatized
dnl class to zero, and require an explicit operator==() to be defined that takes
dnl an int. This test separates the strong from the weak.

AC_CACHE_CHECK(for trouble comparing to zero near std::operator!=(),
               ac_cv_trouble_comparing_to_zero,
               [AC_TRY_COMPILE([#include <algorithm>
                                template <class T> class Foo {};
                                class T2;
                                template <class T> int operator==(const T2*, const T&) { return 0; }
                                template <class T> int operator!=(const T2*, const T&) { return 0; }],
                               [Foo<int> f; return (0 != f);],
                               ac_cv_trouble_comparing_to_zero=no,
                               ac_cv_trouble_comparing_to_zero=yes)])
if test "$ac_cv_trouble_comparing_to_zero" = yes ; then
  AC_DEFINE(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
fi

# try harder, when checking for __thread support, see bug 521750 comment #33 and below
_SAVE_LDFLAGS=$LDFLAGS
LDFLAGS="$LDFLAGS $DSO_PIC_CFLAGS $DSO_LDOPTS"
AC_CACHE_CHECK(for __thread keyword for TLS variables,
               ac_cv_thread_keyword,
               [AC_TRY_LINK([__thread bool tlsIsMainThread = false;],
                            [return tlsIsMainThread;],
                            ac_cv_thread_keyword=yes,
                            ac_cv_thread_keyword=no)])
LDFLAGS=$_SAVE_LDFLAGS
if test "$ac_cv_thread_keyword" = yes; then
  AC_DEFINE(HAVE_THREAD_TLS_KEYWORD)
fi

dnl End of C++ language/feature checks
AC_LANG_C

dnl ========================================================
dnl =  Internationalization checks
dnl ========================================================
dnl
dnl Internationalization and Locale support is different
dnl on various UNIX platforms.  Checks for specific i18n
dnl features go here.

dnl check for LC_MESSAGES
AC_CACHE_CHECK(for LC_MESSAGES,
		ac_cv_i18n_lc_messages,
		[AC_TRY_COMPILE([#include <locale.h>],
				[int category = LC_MESSAGES;],
				ac_cv_i18n_lc_messages=yes,
				ac_cv_i18n_lc_messages=no)])
if test "$ac_cv_i18n_lc_messages" = yes; then
   AC_DEFINE(HAVE_I18N_LC_MESSAGES)
fi 	

fi # SKIP_COMPILER_CHECKS

TARGET_XPCOM_ABI=
if test -n "${CPU_ARCH}" -a -n "${TARGET_COMPILER_ABI}"; then
    TARGET_XPCOM_ABI="${CPU_ARCH}-${TARGET_COMPILER_ABI}"
fi

dnl Mozilla specific options
dnl ========================================================
dnl The macros used for command line options
dnl are defined in build/autoconf/altoptions.m4.


dnl ========================================================
dnl =
dnl = Check for external package dependencies
dnl =
dnl ========================================================
MOZ_ARG_HEADER(External Packages)

MOZ_ENABLE_LIBXUL=1

MOZ_ARG_WITH_STRING(libxul-sdk,
[  --with-libxul-sdk=PFX   Use the libXUL SDK at <PFX>],
  LIBXUL_SDK_DIR=$withval)

if test "$LIBXUL_SDK_DIR" = "yes"; then
    AC_MSG_ERROR([--with-libxul-sdk must specify a path])
elif test -n "$LIBXUL_SDK_DIR" -a "$LIBXUL_SDK_DIR" != "no"; then
    LIBXUL_SDK=`cd "$LIBXUL_SDK_DIR" && pwd`

    if test ! -f "$LIBXUL_SDK/include/xpcom-config.h"; then
        AC_MSG_ERROR([$LIBXUL_SDK/include/xpcom-config.h doesn't exist])
    fi

    MOZ_ENABLE_LIBXUL=1
fi
AC_SUBST(LIBXUL_SDK)

if test -n "$LIBXUL_SDK"; then
    LIBXUL_DIST="$LIBXUL_SDK"
else
    LIBXUL_DIST="$MOZ_BUILD_ROOT/dist"
fi
AC_SUBST(LIBXUL_DIST)

SYSTEM_LIBXUL=

MOZ_ARG_WITH_BOOL(system-libxul,
[  --with-system-libxul   Use system installed libxul SDK],
    SYSTEM_LIBXUL=1)

if test -n "$SYSTEM_LIBXUL" && test -z "$MOZ_ENABLE_LIBXUL"; then
    AC_MSG_ERROR([--with-system-libxul needs --with-libxul-sdk])
fi

dnl ========================================================
dnl = If NSPR was not detected in the system, 
dnl = use the one in the source tree (mozilla/nsprpub)
dnl ========================================================
MOZ_ARG_WITH_BOOL(system-nspr,
[  --with-system-nspr      Use system installed NSPR],
    _USE_SYSTEM_NSPR=1 )

if test -n "$_USE_SYSTEM_NSPR"; then
    AM_PATH_NSPR(4.8.0, [MOZ_NATIVE_NSPR=1], [MOZ_NATIVE_NSPR=])
fi

if test -n "$MOZ_NATIVE_NSPR"; then
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $NSPR_CFLAGS"
    AC_TRY_COMPILE([#include "prlog.h"],
                [#ifndef PR_STATIC_ASSERT
                 #error PR_STATIC_ASSERT not defined
                 #endif],
                [MOZ_NATIVE_NSPR=1],
                AC_MSG_ERROR([system NSPR does not support PR_STATIC_ASSERT]))
    CFLAGS=$_SAVE_CFLAGS
else
    if test "$OS_ARCH" = "WINCE"; then
        NSPR_CFLAGS="-I${LIBXUL_DIST}/include/nspr"
        NSPR_LIBS="${LIBXUL_DIST}/lib/nspr${NSPR_VERSION}.lib ${LIBXUL_DIST}/lib/plc${NSPR_VERSION}.lib ${LIBXUL_DIST}/lib/plds${NSPR_VERSION}.lib "
    elif test "$OS_ARCH" = "WINNT"; then
        NSPR_CFLAGS="-I${LIBXUL_DIST}/include/nspr"
        if test -n "$GNU_CC"; then
            NSPR_LIBS="-L${LIBXUL_DIST}/lib -lnspr${NSPR_VERSION} -lplc${NSPR_VERSION} -lplds${NSPR_VERSION}"
        else
            NSPR_LIBS="${LIBXUL_DIST}/lib/nspr${NSPR_VERSION}.lib ${LIBXUL_DIST}/lib/plc${NSPR_VERSION}.lib ${LIBXUL_DIST}/lib/plds${NSPR_VERSION}.lib "
        fi
    else
        NSPR_CFLAGS='`$(LIBXUL_DIST)/bin/nspr-config --prefix='${LIBXUL_DIST}' --includedir='${LIBXUL_DIST}'/include/nspr --cflags`'
        NSPR_LIBS='`$(LIBXUL_DIST)/bin/nspr-config --prefix='${LIBXUL_DIST}' --libdir='${LIBXUL_DIST}'/lib --libs`'
    fi
fi

dnl system libevent Support
dnl ========================================================
MOZ_ARG_WITH_STRING(system-libevent,
[  --with-system-libevent=[PFX]
                          Use system libevent [installed at prefix PFX]],
    LIBEVENT_DIR=$withval)

_SAVE_CFLAGS=$CFLAGS
_SAVE_LDFLAGS=$LDFLAGS
_SAVE_LIBS=$LIBS
if test -z "$LIBEVENT_DIR" -o "$LIBEVENT_DIR" = no; then
    MOZ_NATIVE_LIBEVENT=
else
    if test "${LIBEVENT_DIR}" = "yes"; then
        LIBEVENT_DIR=/usr
    fi
    CFLAGS="-I${LIBEVENT_DIR}/include $CFLAGS"
    LDFLAGS="-L${LIBEVENT_DIR}/lib $LDFLAGS"
    AC_CHECK_HEADER(event.h,
                    [if test ! -f "${LIBEVENT_DIR}/include/event.h"; then
                         AC_MSG_ERROR([event.h found, but is not in ${LIBEVENT_DIR}/include])
                     fi],
                    AC_MSG_ERROR([--with-system-libevent requested but event.h not found]))
    AC_CHECK_LIB(event, event_init,
                 [MOZ_NATIVE_LIBEVENT=1
                  MOZ_LIBEVENT_INCLUDES="${LIBEVENT_DIR}/include"
                  MOZ_LIBEVENT_LIBS="-L${LIBEVENT_DIR}/lib -levent"],
                 [MOZ_NATIVE_LIBEVENT= MOZ_LIBEVENT_INCLUDES= MOZ_LIBEVENT_LIBS=])
fi
CFLAGS=$_SAVE_CFLAGS
LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS

AC_SUBST(MOZ_NATIVE_LIBEVENT)
AC_SUBST(MOZ_LIBEVENT_INCLUDES)
AC_SUBST(MOZ_LIBEVENT_LIBS)

dnl ========================================================
dnl = If NSS was not detected in the system, 
dnl = use the one in the source tree (mozilla/security/nss)
dnl ========================================================

MOZ_ARG_WITH_BOOL(system-nss,
[  --with-system-nss      Use system installed NSS],
    _USE_SYSTEM_NSS=1 )

if test -n "$_USE_SYSTEM_NSS"; then
    AM_PATH_NSS(3.12.6, [MOZ_NATIVE_NSS=1], [MOZ_NATIVE_NSS=])
fi

if test -n "$MOZ_NATIVE_NSS"; then
   NSS_LIBS="$NSS_LIBS -lcrmf"
else
   NSS_CFLAGS='-I$(LIBXUL_DIST)/include/nss'
   NSS_DEP_LIBS="\
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)crmf.\$(LIB_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(DLL_PREFIX)smime$NSS_VERSION\$(DLL_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(DLL_PREFIX)ssl$NSS_VERSION\$(DLL_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(DLL_PREFIX)nss$NSS_VERSION\$(DLL_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(DLL_PREFIX)nssutil$NSS_VERSION\$(DLL_SUFFIX)"

   if test -z "$GNU_CC" && test "$OS_ARCH" = "WINNT" -o "$OS_ARCH" = "WINCE" -o "$OS_ARCH" = "OS2"; then
       NSS_LIBS="\
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)crmf.\$(LIB_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)smime$NSS_VERSION.\$(IMPORT_LIB_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)ssl$NSS_VERSION.\$(IMPORT_LIB_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)nss$NSS_VERSION.\$(IMPORT_LIB_SUFFIX) \
        \$(LIBXUL_DIST)/lib/\$(LIB_PREFIX)nssutil$NSS_VERSION.\$(IMPORT_LIB_SUFFIX)"
   else
       NSS_LIBS='$(LIBS_DIR)'" -lcrmf -lsmime$NSS_VERSION -lssl$NSS_VERSION -lnss$NSS_VERSION -lnssutil$NSS_VERSION"
   fi
fi

if test -z "$SKIP_LIBRARY_CHECKS"; then
dnl system JPEG support
dnl ========================================================
MOZ_ARG_WITH_STRING(system-jpeg,
[  --with-system-jpeg[=PFX]
                          Use system libjpeg [installed at prefix PFX]],
    JPEG_DIR=$withval)

_SAVE_CFLAGS=$CFLAGS
_SAVE_LDFLAGS=$LDFLAGS
_SAVE_LIBS=$LIBS
if test -n "${JPEG_DIR}" -a "${JPEG_DIR}" != "yes"; then
    CFLAGS="-I${JPEG_DIR}/include $CFLAGS"
    LDFLAGS="-L${JPEG_DIR}/lib $LDFLAGS"
fi
if test -z "$JPEG_DIR" -o "$JPEG_DIR" = no; then
    SYSTEM_JPEG=
else
    AC_CHECK_LIB(jpeg, jpeg_destroy_compress, [SYSTEM_JPEG=1 JPEG_LIBS="-ljpeg $JPEG_LIBS"], SYSTEM_JPEG=, $JPEG_LIBS)
fi

if test "$SYSTEM_JPEG" = 1; then
    LIBS="$JPEG_LIBS $LIBS"
    AC_TRY_COMPILE([ #include <stdio.h>
                     #include <sys/types.h>
                     #include <jpeglib.h> ],
                   [ #if JPEG_LIB_VERSION < $MOZJPEG
                     #error "Insufficient JPEG library version ($MOZJPEG required)."
                     #endif ],
                   SYSTEM_JPEG=1,
                   [SYSTEM_JPEG= JPEG_CFLAGS= JPEG_LIBS=]) 
fi 
CFLAGS=$_SAVE_CFLAGS
LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS

if test -n "${JPEG_DIR}" -a -d "${JPEG_DIR}" -a "$SYSTEM_JPEG" = 1; then
    JPEG_CFLAGS="-I${JPEG_DIR}/include"
    JPEG_LIBS="-L${JPEG_DIR}/lib ${JPEG_LIBS}"
fi

dnl system ZLIB support
dnl ========================================================
MOZ_ARG_WITH_STRING(system-zlib,
[  --with-system-zlib[=PFX]
                          Use system libz [installed at prefix PFX]],
    ZLIB_DIR=$withval)

_SAVE_CFLAGS=$CFLAGS
_SAVE_LDFLAGS=$LDFLAGS
_SAVE_LIBS=$LIBS
if test -n "${ZLIB_DIR}" -a "${ZLIB_DIR}" != "yes"; then
    CFLAGS="-I${ZLIB_DIR}/include $CFLAGS"
    LDFLAGS="-L${ZLIB_DIR}/lib $LDFLAGS"
fi
if test -z "$ZLIB_DIR" -o "$ZLIB_DIR" = no; then
    SYSTEM_ZLIB=
else
    AC_CHECK_LIB(z, gzread, [SYSTEM_ZLIB=1 ZLIB_LIBS="-lz $ZLIB_LIBS"], 
	[SYSTEM_ZLIB= ZLIB_CFLAGS= ZLIB_LIBS=], $ZLIB_LIBS)
fi
if test "$SYSTEM_ZLIB" = 1; then
    LIBS="$ZLIB_LIBS $LIBS"
    AC_TRY_COMPILE([ #include <stdio.h>
                     #include <string.h>
                     #include <zlib.h> ],
                   [ #if ZLIB_VERNUM < $MOZZLIB 
                     #error "Insufficient zlib version ($MOZZLIB required)."
                     #endif ],
                   SYSTEM_ZLIB=1,
                   [SYSTEM_ZLIB= ZLIB_CFLAGS= ZLIB_LIBS=]) 
fi
CFLAGS=$_SAVE_CFLAGS
LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS

if test "${ZLIB_DIR}" -a -d "${ZLIB_DIR}" -a "$SYSTEM_ZLIB" = 1; then
    ZLIB_CFLAGS="-I${ZLIB_DIR}/include"
    ZLIB_LIBS="-L${ZLIB_DIR}/lib ${ZLIB_LIBS}"
fi

dnl system BZIP2 Support
dnl ========================================================
MOZ_ARG_WITH_STRING(system-bz2,
[  --with-system-bz2[=PFX]
                          Use system libbz2 [installed at prefix PFX]],
    BZ2_DIR=$withval)

_SAVE_CFLAGS=$CFLAGS
_SAVE_LDFLAGS=$LDFLAGS
_SAVE_LIBS=$LIBS
if test -n "${BZ2_DIR}" -a "${BZ2_DIR}" != "yes"; then
    CFLAGS="-I${BZ2_DIR}/include $CFLAGS"
    LDFLAGS="-L${BZ2_DIR}/lib $LDFLAGS"
fi
if test -z "$BZ2_DIR" -o "$BZ2_DIR" = no; then
    SYSTEM_BZ2=
else
    AC_CHECK_LIB(bz2, BZ2_bzread, [SYSTEM_BZ2=1 BZ2_LIBS="-lbz2"],
	[SYSTEM_BZ2= BZ2_CFLAGS= BZ2_LIBS=], $BZ2_LIBS)
fi
CFLAGS=$_SAVE_CFLAGS
LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS

if test "${BZ2_DIR}" -a -d "${BZ2_DIR}" -a "$SYSTEM_BZ2" = 1; then
    BZ2_CFLAGS="-I${BZ2_DIR}/include"
    BZ2_LIBS="-L${BZ2_DIR}/lib ${MOZ_BZ2_LIBS}"
fi

dnl system PNG Support
dnl ========================================================
MOZ_ARG_WITH_STRING(system-png, 
[  --with-system-png[=PFX]
                          Use system libpng [installed at prefix PFX]],
    PNG_DIR=$withval)

_SAVE_CFLAGS=$CFLAGS
_SAVE_LDFLAGS=$LDFLAGS
_SAVE_LIBS=$LIBS
CFLAGS="$ZLIB_CFLAGS $CFLAGS"
LDFLAGS="$ZLIB_LIBS -lz $LDFLAGS"
if test -n "${PNG_DIR}" -a "${PNG_DIR}" != "yes"; then
    CFLAGS="-I${PNG_DIR}/include $CFLAGS"
    LDFLAGS="-L${PNG_DIR}/lib $LDFLAGS"
fi
if test -z "$PNG_DIR" -o "$PNG_DIR" = no; then
    SYSTEM_PNG=
else
    _SAVE_PNG_LIBS=$PNG_LIBS
    AC_CHECK_LIB(png, png_get_valid, [SYSTEM_PNG=1 PNG_LIBS="-lpng $PNG_LIBS"],
                 AC_MSG_ERROR([--with-system-png requested but no working libpng found]), 
                 $PNG_LIBS)
    AC_CHECK_LIB(png, png_get_acTL, ,
                 AC_MSG_ERROR([--with-system-png won't work because the system's libpng doesn't have APNG support]),
                 $_SAVE_PNG_LIBS)
fi
if test "$SYSTEM_PNG" = 1; then
    LIBS="$PNG_LIBS $LIBS"
    AC_TRY_COMPILE([ #include <stdio.h>
                     #include <sys/types.h>
                     #include <png.h> ],
                   [ #if PNG_LIBPNG_VER < $MOZPNG
                     #error "Insufficient libpng version ($MOZPNG required)."
                     #endif
                     #ifndef PNG_UINT_31_MAX
                     #error "Insufficient libpng version."
                     #endif ],
                   SYSTEM_PNG=1,
                   AC_MSG_ERROR([--with-system-png requested but no working libpng found]))
fi
CFLAGS=$_SAVE_CFLAGS
LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS

if test "${PNG_DIR}" -a -d "${PNG_DIR}" -a "$SYSTEM_PNG" = 1; then
    PNG_CFLAGS="-I${PNG_DIR}/include"
    PNG_LIBS="-L${PNG_DIR}/lib ${PNG_LIBS}"
fi

fi # SKIP_LIBRARY_CHECKS

dnl system HunSpell Support
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(system-hunspell,
[  --enable-system-hunspell  Use system hunspell (located with pkgconfig)],
    SYSTEM_HUNSPELL=1 )

if test -n "$SYSTEM_HUNSPELL"; then
    PKG_CHECK_MODULES(MOZ_HUNSPELL, hunspell)
fi

AC_SUBST(SYSTEM_HUNSPELL)

dnl ========================================================
dnl Java SDK support
dnl ========================================================
JAVA_INCLUDE_PATH=
MOZ_ARG_WITH_STRING(java-include-path,
[  --with-java-include-path=dir   Location of Java SDK headers],
    JAVA_INCLUDE_PATH=$withval)

JAVA_BIN_PATH=
MOZ_ARG_WITH_STRING(java-bin-path,
[  --with-java-bin-path=dir   Location of Java binaries (java, javac, jar)],
    JAVA_BIN_PATH=$withval)

dnl ========================================================
dnl Use ARM userspace kernel helpers; tell NSPR to enable
dnl their usage and use them in spidermonkey.
dnl ========================================================
MOZ_ARG_WITH_BOOL(arm-kuser,
[  --with-arm-kuser         Use kuser helpers (Linux/ARM only -- requires kernel 2.6.13 or later)],
    USE_ARM_KUSER=1,
    USE_ARM_KUSER=)
if test -n "$USE_ARM_KUSER"; then
   AC_DEFINE(USE_ARM_KUSER)
fi

dnl ========================================================
dnl =
dnl = Application
dnl =
dnl ========================================================

MOZ_ARG_HEADER(Application)

BUILD_STATIC_LIBS=
ENABLE_TESTS=1
MOZ_ACTIVEX_SCRIPTING_SUPPORT=
MOZ_BRANDING_DIRECTORY=
MOZ_OFFICIAL_BRANDING=
MOZ_DBGRINFO_MODULES=
MOZ_ENABLE_CANVAS=1
MOZ_ENABLE_CANVAS3D=
MOZ_FEEDS=1
MOZ_IMG_DECODERS_DEFAULT="png gif jpeg bmp icon"
MOZ_IMG_ENCODERS_DEFAULT="png jpeg"
MOZ_IPC=1
MOZ_JAVAXPCOM=
MOZ_JSDEBUGGER=1
MOZ_JSLOADER=1
MOZ_MATHML=1
MOZ_MORK=1
MOZ_MORKREADER=
MOZ_AUTH_EXTENSION=1
MOZ_NO_ACTIVEX_SUPPORT=1
MOZ_NO_INSPECTOR_APIS=
MOZ_NO_XPCOM_OBSOLETE=
MOZ_NO_FAST_LOAD=
MOZ_OGG=1
MOZ_SYDNEYAUDIO=
MOZ_WAVE=1
MOZ_MEDIA=
MOZ_PERMISSIONS=1
MOZ_PLACES=
MOZ_PLAINTEXT_EDITOR_ONLY=
MOZ_PLUGINS=1
MOZ_PREF_EXTENSIONS=1
MOZ_PROFILELOCKING=1
MOZ_PSM=1
MOZ_RDF=1
MOZ_REFLOW_PERF=
MOZ_SAFE_BROWSING=
MOZ_FASTSTART=
MOZ_HELP_VIEWER=
MOZ_SPELLCHECK=1
MOZ_SPLASHSCREEN=
MOZ_STATIC_MAIL_BUILD=
MOZ_STORAGE=1
MOZ_SVG=1
MOZ_TIMELINE=
MOZ_UI_LOCALE=en-US
MOZ_UNIVERSALCHARDET=1
MOZ_URL_CLASSIFIER=
MOZ_USE_NATIVE_UCONV=
MOZ_VIEW_SOURCE=1
MOZ_XPFE_COMPONENTS=1
MOZ_XPINSTALL=1
MOZ_XSLT_STANDALONE=
MOZ_XTF=1
MOZ_XUL=1
MOZ_ZIPWRITER=1
NS_PRINTING=1
NECKO_WIFI=1
NECKO_COOKIES=1
NECKO_DISK_CACHE=1
NECKO_PROTOCOLS_DEFAULT="about data file ftp gopher http res viewsource"
XPC_IDISPATCH_SUPPORT=


case "$target_os" in
darwin*)
    ACCESSIBILITY=
    ;;
*)
    ACCESSIBILITY=1
    ;;
esac

case "$target_os" in
    msvc*|mks*|cygwin*|mingw*)
        if test -z "$GNU_CC"; then 
            XPC_IDISPATCH_SUPPORT=1
            MOZ_NO_ACTIVEX_SUPPORT=
        fi
        ;;
esac

MOZ_ARG_ENABLE_STRING(application,
[  --enable-application=APP
                          Options include:
                            browser (Firefox)
                            xulrunner
                            content/xslt (Standalone Transformiix XSLT)
                            netwerk (Standalone Necko)
                            tools/update-packaging (AUS-related packaging tools)
                            standalone (use this for standalone
                              xpcom/xpconnect or to manually drive a build)],
[ MOZ_BUILD_APP=$enableval ] )

MOZ_EMBEDDING_PROFILE=default
MOZ_ARG_WITH_STRING(embedding-profile,
[  --with-embedding-profile=default|basic|minimal
                       see http://wiki.mozilla.org/Gecko:Small_Device_Support],
[ MOZ_EMBEDDING_PROFILE=$withval ])

case "$MOZ_EMBEDDING_PROFILE" in
default)
  MOZ_EMBEDDING_LEVEL_DEFAULT=1
  MOZ_EMBEDDING_LEVEL_BASIC=1
  MOZ_EMBEDDING_LEVEL_MINIMAL=1
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_DEFAULT)
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_BASIC)
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_MINIMAL)
  ;;

basic)
  MOZ_EMBEDDING_LEVEL_DEFAULT=
  MOZ_EMBEDDING_LEVEL_BASIC=1
  MOZ_EMBEDDING_LEVEL_MINIMAL=1
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_BASIC)
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_MINIMAL)
  ENABLE_TESTS=
  MOZ_ACTIVEX_SCRIPTING_SUPPORT=
  MOZ_ENABLE_CANVAS=
  MOZ_ENABLE_POSTSCRIPT=
  MOZ_EXTENSIONS_DEFAULT=" spatialnavigation"
  MOZ_IMG_DECODERS_DEFAULT="png gif jpeg"
  MOZ_IMG_ENCODERS_DEFAULT=
  MOZ_IMG_ENCODERS=
  MOZ_INSTALLER=
  MOZ_JSDEBUGGER=
  MOZ_MATHML=
  MOZ_AUTH_EXTENSION=
  MOZ_NO_ACTIVEX_SUPPORT=1
  MOZ_NO_INSPECTOR_APIS=1
  MOZ_NO_XPCOM_OBSOLETE=1
  MOZ_NO_FAST_LOAD=1
  MOZ_PLAINTEXT_EDITOR_ONLY=1
#  MOZ_PLUGINS=
  MOZ_PREF_EXTENSIONS=
  MOZ_PROFILELOCKING=
  MOZ_SPELLCHECK=
  MOZ_SVG=
  MOZ_UNIVERSALCHARDET=
  MOZ_UPDATER=
  MOZ_USE_NATIVE_UCONV=
  MOZ_VIEW_SOURCE=
  MOZ_XPFE_COMPONENTS=
  MOZ_XPINSTALL=
  MOZ_XTF=
  MOZ_ZIPWRITER=
  NECKO_DISK_CACHE=
  NECKO_PROTOCOLS_DEFAULT="about data http file res"
  NECKO_SMALL_BUFFERS=1
  NS_DISABLE_LOGGING=1
  NS_PRINTING=
  ;;

minimal)
  MOZ_EMBEDDING_LEVEL_DEFAULT=
  MOZ_EMBEDDING_LEVEL_BASIC=
  MOZ_EMBEDDING_LEVEL_MINIMAL=1
  AC_DEFINE(MOZ_EMBEDDING_LEVEL_MINIMAL)
  ENABLE_TESTS=
  MOZ_ACTIVEX_SCRIPTING_SUPPORT=
  MOZ_ENABLE_CANVAS=
  MOZ_ENABLE_POSTSCRIPT=
  MOZ_EXTENSIONS_DEFAULT=" spatialnavigation"
  MOZ_IMG_DECODERS_DEFAULT="png gif jpeg"
  MOZ_IMG_ENCODERS_DEFAULT=
  MOZ_IMG_ENCODERS=
  MOZ_INSTALLER=
  MOZ_JSDEBUGGER=
  MOZ_MATHML=
  MOZ_AUTH_EXTENSION=
  MOZ_NO_ACTIVEX_SUPPORT=1
  MOZ_NO_INSPECTOR_APIS=1
  MOZ_NO_XPCOM_OBSOLETE=1
  MOZ_NO_FAST_LOAD=1
  MOZ_PLAINTEXT_EDITOR_ONLY=1
  MOZ_PLUGINS=
  MOZ_PREF_EXTENSIONS=
  MOZ_PROFILELOCKING=
  MOZ_SPELLCHECK=
  MOZ_STORAGE=1
  MOZ_PLACES=
  MOZ_SVG=
  MOZ_UNIVERSALCHARDET=
  MOZ_UPDATER=
  MOZ_USE_NATIVE_UCONV=1
  MOZ_VIEW_SOURCE=
  MOZ_XPFE_COMPONENTS=
  MOZ_XPINSTALL=
  MOZ_XTF=
  MOZ_XUL=
  MOZ_ZIPWRITER=
  MOZ_RDF=
  NECKO_DISK_CACHE=
  NECKO_PROTOCOLS_DEFAULT="about data http file res"
  NECKO_SMALL_BUFFERS=1
  NS_DISABLE_LOGGING=1
  NS_PRINTING=
  ;;

*)
  AC_MSG_ERROR([Unrecognized value: --with-embedding-profile=$MOZ_EMBEDDING_PROFILE])
  ;;
esac

AC_SUBST(MOZ_EMBEDDING_LEVEL_DEFAULT)
AC_SUBST(MOZ_EMBEDDING_LEVEL_BASIC)
AC_SUBST(MOZ_EMBEDDING_LEVEL_MINIMAL)

MOZ_ARG_WITH_STRING(xulrunner-stub-name,
[  --with-xulrunner-stub-name=appname   Create the xulrunner stub with the given name],
  XULRUNNER_STUB_NAME=$withval)

if test -z "$XULRUNNER_STUB_NAME"; then
  case "$target_os" in
  darwin*)
    XULRUNNER_STUB_NAME=xulrunner
    ;;
  *)
    XULRUNNER_STUB_NAME=xulrunner-stub
  esac
fi
AC_SUBST(XULRUNNER_STUB_NAME)

if test -z "$MOZ_BUILD_APP"; then
  AC_MSG_ERROR([--enable-application=APP was not specified and is required.])
else
  # We have a valid application only if it has a build.mk file in its top
  # directory.
  if test ! -f "${srcdir}/${MOZ_BUILD_APP}/build.mk" ; then
    AC_MSG_ERROR([--enable-application value not recognized (${MOZ_BUILD_APP}/build.mk does not exist).])
  fi
fi

# Allow the application to influence configure with a confvars.sh script.

AC_MSG_CHECKING([if app-specific confvars.sh exists])
if test -f "${srcdir}/${MOZ_BUILD_APP}/confvars.sh" ; then
  AC_MSG_RESULT([${srcdir}/${MOZ_BUILD_APP}/confvars.sh])
  . "${srcdir}/${MOZ_BUILD_APP}/confvars.sh"
else
  AC_MSG_RESULT([no])
fi

# Now is a good time to test for logic errors, define mismatches, etc.
case "$MOZ_BUILD_APP" in
xulrunner)
  if test "$LIBXUL_SDK"; then
    AC_MSG_ERROR([Building XULRunner --with-libxul-sdk doesn't make sense; XULRunner provides the libxul SDK.])
  fi
  ;;
esac

# Special cases where we need to AC_DEFINE something. Also a holdover for apps
# that haven't made a confvars.sh yet. Don't add new stuff here, use
# MOZ_BUILD_APP.
case "$MOZ_BUILD_APP" in
browser)
  AC_DEFINE(MOZ_PHOENIX)
  ;;

xulrunner)
  AC_DEFINE(MOZ_XULRUNNER)
  ;;

content/xslt)
  AC_DEFINE(TX_EXE)
  ;;

standalone) 
  MOZ_APP_NAME=mozilla
  MOZ_APP_DISPLAYNAME=Mozilla
  MOZ_APP_VERSION=$MOZILLA_VERSION
  ;;

esac

AC_SUBST(MOZ_BUILD_APP)
AC_SUBST(MOZ_PHOENIX)
AC_SUBST(MOZ_XULRUNNER)

AC_DEFINE_UNQUOTED(MOZ_BUILD_APP,$MOZ_BUILD_APP)

dnl ========================================================
dnl = 
dnl = Toolkit Options
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Toolkit Options)

    dnl ========================================================
    dnl = Select the default toolkit
    dnl ========================================================
	MOZ_ARG_ENABLE_STRING(default-toolkit,
	[  --enable-default-toolkit=TK
                          Select default toolkit
                          Platform specific defaults:
                            BeOS - cairo-beos
                            Mac OS X - cairo-cocoa
                            Neutrino/QNX - photon
                            OS/2 - cairo-os2
                            Win32/WinCE - cairo-windows
                            Gtk2 with DirectFB - cairo-gtk2-dfb
                            * - cairo-gtk2
                            * - cairo-qt],
    [ _DEFAULT_TOOLKIT=$enableval ],
    [ _DEFAULT_TOOLKIT=$_PLATFORM_DEFAULT_TOOLKIT])

    if test "$_DEFAULT_TOOLKIT" = "photon" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-windows" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-gtk2" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-gtk2-dfb" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-gtk2-x11" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-qt" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-beos" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-os2" \
        -o "$_DEFAULT_TOOLKIT" = "cairo-cocoa"
    then
        dnl nglayout only supports building with one toolkit,
        dnl so ignore everything after the first comma (",").
        MOZ_WIDGET_TOOLKIT=`echo "$_DEFAULT_TOOLKIT" | sed -e "s/,.*$//"`
    else
        AC_MSG_ERROR([You must specify a default toolkit (perhaps $_PLATFORM_DEFAULT_TOOLKIT).])
    fi

AC_DEFINE_UNQUOTED(MOZ_DEFAULT_TOOLKIT,"$MOZ_WIDGET_TOOLKIT")

dnl ========================================================
dnl = Enable the toolkit as needed                         =
dnl ========================================================

case "$MOZ_WIDGET_TOOLKIT" in
photon)
	MOZ_ENABLE_PHOTON=1
	AC_DEFINE(MOZ_WIDGET_PHOTON)
    ;;

cairo-windows)
    MOZ_WIDGET_TOOLKIT=windows
    MOZ_GFX_TOOLKIT=cairo
    ;;

cairo-gtk2|cairo-gtk2-x11)
    MOZ_WIDGET_TOOLKIT=gtk2
    MOZ_GFX_TOOLKIT=cairo
    MOZ_ENABLE_GTK2=1
    MOZ_ENABLE_XREMOTE=1

    AC_DEFINE(MOZ_X11)
    MOZ_X11=1
    USE_FC_FREETYPE=1

    TK_CFLAGS='$(MOZ_GTK2_CFLAGS)'
    TK_LIBS='$(MOZ_GTK2_LIBS)'
    AC_DEFINE(MOZ_WIDGET_GTK2)
    ;;

cairo-gtk2-dfb)
    MOZ_WIDGET_TOOLKIT=gtk2
    MOZ_GFX_TOOLKIT=cairo
    MOZ_ENABLE_GTK2=1

    AC_DEFINE(MOZ_DFB)
    MOZ_DFB=1

    TK_CFLAGS='$(MOZ_GTK2_CFLAGS)'
    TK_LIBS='$(MOZ_GTK2_LIBS)'
    AC_DEFINE(MOZ_WIDGET_GTK2)
    if test "$no_x" != "yes"; then
        AC_MSG_WARN([Disabling X when DirectFB is specified.])
        no_x=yes
    fi
    ;;

cairo-qt)
    MOZ_WIDGET_TOOLKIT=qt
    MOZ_GFX_TOOLKIT=cairo
    MOZ_ENABLE_QT=1
    MOZ_ENABLE_XREMOTE=1
    USE_ELF_DYNSTR_GC=
    NS_PRINTING=

    AC_DEFINE(MOZ_X11)
    MOZ_X11=1
    USE_FC_FREETYPE=1

    TK_CFLAGS='$(MOZ_QT_CFLAGS)'
    TK_LIBS='$(MOZ_QT_LIBS)'
    AC_DEFINE(MOZ_WIDGET_QT)
    ;;

cairo-beos)
    MOZ_WIDGET_TOOLKIT=beos
    MOZ_GFX_TOOLKIT=cairo
    USE_FC_FREETYPE=1
    TK_CFLAGS='$(MOZ_CAIRO_CFLAGS)'
    TK_LIBS='$(MOZ_CAIRO_LIBS)'
    ;;

cairo-os2)
    MOZ_WIDGET_TOOLKIT=os2
    MOZ_GFX_TOOLKIT=cairo
    USE_FC_FREETYPE=1
    TK_CFLAGS='$(MOZ_CAIRO_CFLAGS)'
    TK_LIBS='$(MOZ_CAIRO_LIBS)'
    ;;

cairo-cocoa)
    MOZ_WIDGET_TOOLKIT=cocoa
    AC_DEFINE(MOZ_WIDGET_COCOA)
    MOZ_ENABLE_COCOA=1
    MOZ_GFX_TOOLKIT=cairo
    MOZ_USER_DIR="Mozilla"
    AC_DEFINE(XP_MACOSX)
    AC_DEFINE(TARGET_CARBON)
    AC_DEFINE(TARGET_API_MAC_CARBON)
    TK_LIBS='-framework Carbon -framework CoreAudio -framework AudioToolbox -framework AudioUnit -framework AddressBook'
    TK_CFLAGS="-DNO_X11"
    LDFLAGS="$LDFLAGS -framework Cocoa"
    CFLAGS="$CFLAGS $TK_CFLAGS"
    CXXFLAGS="$CXXFLAGS $TK_CFLAGS"
    LIBXUL_LIBS='$(XPCOM_FROZEN_LDOPTS) $(LIBXUL_DIST)/bin/XUL -lobjc'
    MOZ_FS_LAYOUT=bundle
    ;;
esac

if test "$MOZ_ENABLE_XREMOTE"; then
    AC_DEFINE(MOZ_ENABLE_XREMOTE)
fi

if test "$COMPILE_ENVIRONMENT"; then
  if test "$MOZ_ENABLE_GTK2"; then
    if test "$MOZ_X11"; then
      GDK_PACKAGES=gdk-x11-2.0
    elif test "$MOZ_DFB"; then
      PKG_CHECK_MODULES(MOZ_DFB, directfb >= 1.1.0)
      GDK_PACKAGES=directfb
    fi

    PKG_CHECK_MODULES(MOZ_GTK2, gtk+-2.0 >= $GTK2_VERSION gtk+-unix-print-2.0 glib-2.0 gobject-2.0 $GDK_PACKAGES)
  fi

fi # COMPILE_ENVIRONMENT

AC_SUBST(MOZ_DEFAULT_TOOLKIT)
AC_SUBST(MOZ_FS_LAYOUT)

dnl ========================================================
dnl = startup-notification support module
dnl ========================================================

if test "$MOZ_ENABLE_GTK2"
then
    MOZ_ENABLE_STARTUP_NOTIFICATION=

    MOZ_ARG_ENABLE_BOOL(startup-notification,
    [  --enable-startup-notification       Enable startup-notification support (default: disabled) ],
        MOZ_ENABLE_STARTUP_NOTIFICATION=force,
        MOZ_ENABLE_STARTUP_NOTIFICATION=)
    if test "$MOZ_ENABLE_STARTUP_NOTIFICATION"
    then
        PKG_CHECK_MODULES(MOZ_STARTUP_NOTIFICATION,
                          libstartup-notification-1.0 >= $STARTUP_NOTIFICATION_VERSION,
        [MOZ_ENABLE_STARTUP_NOTIFICATION=1], [
            if test "$MOZ_ENABLE_STARTUP_NOTIFICATION" = "force"
            then
                AC_MSG_ERROR([* * * Could not find startup-notification >= $STARTUP_NOTIFICATION_VERSION])
            fi
            MOZ_ENABLE_STARTUP_NOTIFICATION=
        ])
    fi

    if test "$MOZ_ENABLE_STARTUP_NOTIFICATION"; then
        AC_DEFINE(MOZ_ENABLE_STARTUP_NOTIFICATION)
    fi

    TK_LIBS="$TK_LIBS $MOZ_STARTUP_NOTIFICATION_LIBS"
fi
AC_SUBST(MOZ_ENABLE_STARTUP_NOTIFICATION)
AC_SUBST(MOZ_STARTUP_NOTIFICATION_CFLAGS)
AC_SUBST(MOZ_STARTUP_NOTIFICATION_LIBS)

dnl ========================================================
dnl = QT support
dnl ========================================================
if test "$MOZ_ENABLE_QT"
then
    PKG_CHECK_MODULES(MOZ_QT, QtGui QtNetwork QtUiTools QtCore)
    AC_SUBST(MOZ_QT_CFLAGS)
    AC_SUBST(MOZ_QT_LIBS)

    MOZ_ARG_WITH_STRING(qtdir,
    [  --with-qtdir=\$dir       Specify Qt directory ],
    [ QTDIR=$withval])

    if test -z "$QTDIR"; then
      QTDIR="/usr"
    fi
    QTINCDIR="/include/qt"
    if test ! -d "$QTDIR$QTINCDIR"; then
       QTINCDIR="/include/X11/qt"
    fi
    if test ! -d "$QTDIR$QTINCDIR"; then
       QTINCDIR="/include"
    fi

    if test -x "$QTDIR/bin/moc-qt4"; then
      HOST_MOC="$QTDIR/bin/moc-qt4"
    else
      if test -x "$QTDIR/bin/moc"; then
        HOST_MOC="$QTDIR/bin/moc"
      else
        AC_CHECK_PROGS(HOST_MOC, moc, "")
      fi
    fi
    if test -z "$HOST_MOC"; then
      AC_MSG_ERROR([no acceptable moc preprocessor found])
    fi
    MOC=$HOST_MOC
fi

AC_SUBST(GTK_CONFIG)
AC_SUBST(TK_CFLAGS)
AC_SUBST(TK_LIBS)

AC_SUBST(MOZ_ENABLE_GTK2)
AC_SUBST(MOZ_ENABLE_PHOTON)
AC_SUBST(MOZ_ENABLE_COCOA)
AC_SUBST(MOZ_ENABLE_QT)
AC_SUBST(MOZ_ENABLE_XREMOTE)
AC_SUBST(MOZ_GTK2_CFLAGS)
AC_SUBST(MOZ_GTK2_LIBS)
AC_SUBST(MOZ_QT_CFLAGS)
AC_SUBST(MOZ_QT_LIBS)

AC_SUBST(MOC)

AC_SUBST(MOZ_DFB)
AC_SUBST(MOZ_X11)

dnl ========================================================
dnl =
dnl = Components & Features
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Components and Features)

dnl ========================================================
dnl = Enable obsolete Open JVM Interface (OJI) support on OS X
dnl ========================================================
case $target in
*-darwin*)
    MOZ_OJI=1
    AC_DEFINE(OJI)
    ;;
*)
    MOZ_OJI=
    ;;
esac

AC_SUBST(MOZ_OJI)

dnl ========================================================
dnl = Localization
dnl ========================================================
MOZ_ARG_ENABLE_STRING(ui-locale,
[  --enable-ui-locale=ab-CD
                          Select the user interface locale (default: en-US)],
    MOZ_UI_LOCALE=$enableval )
AC_SUBST(MOZ_UI_LOCALE)

dnl ========================================================
dnl = Trademarked Branding 
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(official-branding,
[  --enable-official-branding Enable Official mozilla.org Branding
                          Do not distribute builds with
                          --enable-official-branding unless you have
                          permission to use trademarks per
                          http://www.mozilla.org/foundation/trademarks/ .],
[
  if test -z "$MOZ_OFFICIAL_BRANDING_DIRECTORY"; then
    AC_MSG_ERROR([You must specify MOZ_OFFICIAL_BRANDING_DIRECTORY to use --enable-official-branding.])
  else
    MOZ_BRANDING_DIRECTORY=${MOZ_OFFICIAL_BRANDING_DIRECTORY}
    MOZ_OFFICIAL_BRANDING=1
  fi
], MOZ_OFFICIAL_BRANDING=)

AC_SUBST(MOZ_OFFICIAL_BRANDING)
if test -n "$MOZ_OFFICIAL_BRANDING"; then
  AC_DEFINE(MOZ_OFFICIAL_BRANDING)
fi

MOZ_ARG_WITH_STRING(branding,
[  --with-branding=dir    Use branding from the specified directory.],
    MOZ_BRANDING_DIRECTORY=$withval)

REAL_BRANDING_DIRECTORY="${MOZ_BRANDING_DIRECTORY}"
if test -z "$REAL_BRANDING_DIRECTORY"; then
  REAL_BRANDING_DIRECTORY=${MOZ_BUILD_APP}/branding/nightly
fi

if test -f "$topsrcdir/$REAL_BRANDING_DIRECTORY/configure.sh"; then
  . "$topsrcdir/$REAL_BRANDING_DIRECTORY/configure.sh"
fi

AC_SUBST(MOZ_BRANDING_DIRECTORY)

dnl ========================================================
dnl = Distribution ID
dnl ========================================================
MOZ_ARG_WITH_STRING(distribution-id,
[  --with-distribution-id=ID  Set distribution-specific id (default=org.mozilla)],
[ val=`echo $withval`
    MOZ_DISTRIBUTION_ID="$val"])

if test -z "$MOZ_DISTRIBUTION_ID"; then
   MOZ_DISTRIBUTION_ID="org.mozilla"
fi

AC_DEFINE_UNQUOTED(MOZ_DISTRIBUTION_ID,"$MOZ_DISTRIBUTION_ID")
AC_SUBST(MOZ_DISTRIBUTION_ID)


dnl ========================================================
dnl complex text support off by default
dnl ========================================================
MOZ_PANGO=1
MOZ_ARG_DISABLE_BOOL(pango,
[  --disable-pango Disable usage of Pango ],
    MOZ_PANGO=,
    MOZ_PANGO=1)


dnl ========================================================
dnl = Pango
dnl ========================================================
if test "$MOZ_ENABLE_GTK2"
then
    AC_SUBST(MOZ_PANGO)

    PKG_CHECK_MODULES(_PANGOCHK, pango >= $PANGO_VERSION)

    if test "$MOZ_PANGO"
    then
        PKG_CHECK_MODULES(MOZ_PANGO, pango >= $PANGO_VERSION pangoft2 >= $PANGO_VERSION)
        AC_SUBST(MOZ_PANGO_CFLAGS)
        AC_SUBST(MOZ_PANGO_LIBS)
        AC_DEFINE(MOZ_PANGO)
    else
        PKG_CHECK_MODULES(MOZ_PANGO, pango >= $PANGO_VERSION pangoft2 >= $PANGO_VERSION)
        AC_SUBST(MOZ_PANGO_CFLAGS)
        AC_SUBST(MOZ_PANGO_LIBS)

        PKG_CHECK_MODULES(FT2, freetype2 > 6.1.0 fontconfig)
        AC_SUBST(FT2_CFLAGS)
        AC_SUBST(FT2_LIBS)
    fi
fi

dnl ========================================================
dnl = PostScript print module
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(postscript,
[  --disable-postscript    Disable PostScript printing support ],
    MOZ_ENABLE_POSTSCRIPT=,
    MOZ_ENABLE_POSTSCRIPT=1 )

dnl ========================================================
dnl = GnomeVFS support module
dnl ========================================================

if test "$MOZ_X11"
then
    dnl build the gnomevfs extension by default only when the
    dnl GTK2 toolkit is in use.
    if test "$MOZ_ENABLE_GTK2"
    then
        MOZ_ENABLE_GNOMEVFS=1
        MOZ_ENABLE_GCONF=1
    fi

    MOZ_ARG_DISABLE_BOOL(gnomevfs,
    [  --disable-gnomevfs      Disable GnomeVFS support ],
        MOZ_ENABLE_GNOMEVFS=,
        MOZ_ENABLE_GNOMEVFS=force)

    if test "$MOZ_ENABLE_GNOMEVFS"
    then
        PKG_CHECK_MODULES(MOZ_GNOMEVFS, gnome-vfs-2.0 >= $GNOMEVFS_VERSION gnome-vfs-module-2.0 >= $GNOMEVFS_VERSION,[
            MOZ_GNOMEVFS_LIBS=`echo $MOZ_GNOMEVFS_LIBS | sed 's/-llinc\>//'`
            MOZ_ENABLE_GNOMEVFS=1
            AC_DEFINE(MOZ_ENABLE_GNOMEVFS)
        ],[
            if test "$MOZ_ENABLE_GNOMEVFS" = "force"
            then
                AC_MSG_ERROR([* * * Could not find gnome-vfs-module-2.0 >= $GNOMEVFS_VERSION])
            fi
            MOZ_ENABLE_GNOMEVFS=
        ])
    fi

    AC_SUBST(MOZ_ENABLE_GNOMEVFS)
    AC_SUBST(MOZ_GNOMEVFS_CFLAGS)
    AC_SUBST(MOZ_GNOMEVFS_LIBS)

    if test "$MOZ_ENABLE_GCONF"
    then
        PKG_CHECK_MODULES(MOZ_GCONF, gconf-2.0 >= $GCONF_VERSION,[
            MOZ_GCONF_LIBS=`echo $MOZ_GCONF_LIBS | sed 's/-llinc\>//'`
            MOZ_ENABLE_GCONF=1
        ],[
            MOZ_ENABLE_GCONF=
        ])
    fi

    if test "$MOZ_ENABLE_GCONF"; then
        AC_DEFINE(MOZ_ENABLE_GCONF)
    fi

    AC_SUBST(MOZ_ENABLE_GCONF)
    AC_SUBST(MOZ_GCONF_CFLAGS)
    AC_SUBST(MOZ_GCONF_LIBS)

    # The GNOME component is built if gtk2, gconf and gnome-vfs
    # are all available.

    if test "$MOZ_ENABLE_GTK2" -a "$MOZ_ENABLE_GCONF" -a \
            "$MOZ_ENABLE_GNOMEVFS"; then
      MOZ_ENABLE_GNOME_COMPONENT=1
    else
      MOZ_ENABLE_GNOME_COMPONENT=
    fi

    AC_SUBST(MOZ_ENABLE_GNOME_COMPONENT)
fi

dnl ========================================================
dnl = libgnomeui support module
dnl ========================================================

if test "$MOZ_ENABLE_GTK2"
then
    MOZ_ENABLE_GNOMEUI=1

    MOZ_ARG_DISABLE_BOOL(gnomeui,
    [  --disable-gnomeui       Disable libgnomeui support (default: auto, optional at runtime) ],
        MOZ_ENABLE_GNOMEUI=,
        MOZ_ENABLE_GNOMEUI=force)

    if test "$MOZ_ENABLE_GNOMEUI"
    then
        PKG_CHECK_MODULES(MOZ_GNOMEUI, libgnomeui-2.0 >= $GNOMEUI_VERSION,
        [
            MOZ_GNOMEUI_LIBS=`echo $MOZ_GNOMEUI_LIBS | sed 's/-llinc\>//'`
            MOZ_ENABLE_GNOMEUI=1
        ],[
            if test "$MOZ_ENABLE_GNOMEUI" = "force"
            then
                AC_MSG_ERROR([* * * Could not find libgnomeui-2.0 >= $GNOMEUI_VERSION])
            fi
            MOZ_ENABLE_GNOMEUI=
        ])
    fi

    if test "$MOZ_ENABLE_GNOMEUI"; then
        AC_DEFINE(MOZ_ENABLE_GNOMEUI)
    fi
fi
AC_SUBST(MOZ_ENABLE_GNOMEUI)
AC_SUBST(MOZ_GNOMEUI_CFLAGS)
AC_SUBST(MOZ_GNOMEUI_LIBS)

dnl ========================================================
dnl = dbus support
dnl ========================================================

if test "$MOZ_ENABLE_GTK2" || test "$MOZ_ENABLE_QT"
then
    MOZ_ENABLE_DBUS=1

    MOZ_ARG_DISABLE_BOOL(dbus,
    [  --disable-dbus       Disable dbus support ],
        MOZ_ENABLE_DBUS=,
        MOZ_ENABLE_DBUS=1)

    if test "$MOZ_ENABLE_DBUS"
    then
        PKG_CHECK_MODULES(MOZ_DBUS_GLIB, dbus-glib-1 >= $DBUS_VERSION)
        AC_DEFINE(MOZ_ENABLE_DBUS)
    fi
fi
AC_SUBST(MOZ_ENABLE_DBUS)
AC_SUBST(MOZ_DBUS_GLIB_CFLAGS)
AC_SUBST(MOZ_DBUS_GLIB_LIBS)

dnl ========================================================
dnl = libnotify support
dnl ========================================================

if test "$MOZ_ENABLE_GTK2"
then
    MOZ_ENABLE_LIBNOTIFY=1

    MOZ_ARG_DISABLE_BOOL(libnotify,
    [  --disable-libnotify       Disable libnotify support ],
    MOZ_ENABLE_LIBNOTIFY=,
    MOZ_ENABLE_LIBNOTIFY=1)

    if test "$MOZ_ENABLE_LIBNOTIFY"
    then
        AC_DEFINE(MOZ_ENABLE_LIBNOTIFY)
    fi
fi

if test -z "$SKIP_LIBRARY_CHECKS"
then
    if test "$MOZ_ENABLE_GTK2"
    then
        if test "$MOZ_ENABLE_LIBNOTIFY"
        then
            PKG_CHECK_MODULES(MOZ_LIBNOTIFY, libnotify >= $LIBNOTIFY_VERSION)
        fi
    fi
fi
AC_SUBST(MOZ_ENABLE_LIBNOTIFY)
AC_SUBST(MOZ_LIBNOTIFY_CFLAGS)
AC_SUBST(MOZ_LIBNOTIFY_LIBS)

dnl ========================================================
dnl = Build Personal Security Manager
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(crypto,
[  --disable-crypto        Disable crypto support (Personal Security Manager)],
    MOZ_PSM=,
    MOZ_PSM=1 )

dnl ========================================================
dnl = JS Debugger XPCOM component (js/jsd)
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(jsd,
[  --disable-jsd           Disable JavaScript debug library],
    MOZ_JSDEBUGGER=,
    MOZ_JSDEBUGGER=1)


dnl ========================================================
dnl = Disable IPC support for tabs and plugins
dnl ========================================================
case "${target}" in
*-apple-darwin*)
    MOZ_IPC=
    ;;
*-wince*)
    MOZ_IPC=
    ;;
esac

MOZ_ARG_DISABLE_BOOL(ipc,
[  --disable-ipc           Disable IPC supports for tabs and plugins],
    MOZ_IPC=,
    MOZ_IPC=1)

if test -n "$MOZ_IPC"; then
    AC_DEFINE(MOZ_IPC)
fi

AC_SUBST(MOZ_IPC)

dnl ========================================================
dnl = Enable IPDL's "expensive" unit tests
dnl ========================================================
MOZ_IPDL_TESTS=

MOZ_ARG_ENABLE_BOOL(ipdl-tests,
[  --enable-ipdl-tests     Enable expensive IPDL tests],
    MOZ_IPDL_TESTS=1,
    MOZ_IPDL_TESTS=)

if test -z "$MOZ_IPC" -a -n "$MOZ_IPDL_TESTS"; then
    AC_MSG_ERROR([--enable-ipdl-tests requires --enable-ipc])
fi

if test -n "$MOZ_IPDL_TESTS"; then
    AC_DEFINE(MOZ_IPDL_TESTS)
fi

AC_SUBST(MOZ_IPDL_TESTS)

dnl ========================================================
dnl = Disable plugin support
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(plugins,
[  --disable-plugins       Disable plugins support],
    MOZ_PLUGINS=,
    MOZ_PLUGINS=1)

dnl ========================================================
dnl = Disable building dbm
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(dbm,
[  --disable-dbm       Disable building dbm],
    NSS_DISABLE_DBM=1,
    NSS_DISABLE_DBM=)

dnl bi-directional support always on
IBMBIDI=1
AC_DEFINE(IBMBIDI)

dnl ========================================================
dnl view source support on by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(view-source,
[  --disable-view-source     Disable view source support],
    MOZ_VIEW_SOURCE=,
    MOZ_VIEW_SOURCE=1 )
if test "$MOZ_VIEW_SOURCE"; then
    AC_DEFINE(MOZ_VIEW_SOURCE)
fi


dnl ========================================================
dnl accessibility support on by default on all platforms 
dnl except OS X.
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(accessibility,
[  --disable-accessibility Disable accessibility support (off by default on OS X)],
    ACCESSIBILITY=,
    ACCESSIBILITY=1 )
if test "$ACCESSIBILITY"; then
    AC_DEFINE(ACCESSIBILITY)
fi

if test -n "$ACCESSIBILITY" -a "$COMPILE_ENVIRONMENT" = "1"; then
case "$target" in
*-mingw*|*-cygwin*|*-msvc*|*-mks*)
    if test "$ac_cv_header_atlbase_h" = "no"; then
        AC_MSG_ERROR([System header atlbase.h is not available. See http://developer.mozilla.org/en/docs/atlbase.h for details on fixing this problem.])
    fi
    if test "$ac_cv_header_oleacc_idl" = "no"; then
        AC_MSG_ERROR([System header oleacc.idl is not available. See http://developer.mozilla.org/en/docs/oleacc.idl for details on fixing this problem.])
    fi
    ;;
esac
fi

dnl ========================================================
dnl xpfe/components on by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xpfe-components,
[  --disable-xpfe-components
                          Disable xpfe components],
    MOZ_XPFE_COMPONENTS=,
    MOZ_XPFE_COMPONENTS=1 )

dnl ========================================================
dnl xpinstall support on by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xpinstall,
[  --disable-xpinstall     Disable xpinstall support],
    MOZ_XPINSTALL=,
    MOZ_XPINSTALL=1 )
if test "$MOZ_XPINSTALL"; then
    AC_DEFINE(MOZ_XPINSTALL)
fi

dnl ========================================================
dnl xpcom js loader support on by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(jsloader,
[  --disable-jsloader      Disable xpcom js loader support],
    MOZ_JSLOADER=,
    MOZ_JSLOADER=1 )
if test "$MOZ_JSLOADER"; then
    AC_DEFINE(MOZ_JSLOADER)
fi

dnl ========================================================
dnl Disable printing
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(printing,
[  --disable-printing  Disable printing support],
    NS_PRINTING=,
    NS_PRINTING=1 )

if test "$MOZ_WIDGET_TOOLKIT" = "qt"; then
    AC_MSG_WARN([Printing does not work with Qt at this time. Omitting printing support.])
    NS_PRINTING=
fi

if test "$NS_PRINTING"; then
    AC_DEFINE(NS_PRINTING)
    AC_DEFINE(NS_PRINT_PREVIEW)
fi

dnl ========================================================
dnl use native unicode converters
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(native-uconv,
[  --enable-native-uconv   Enable iconv support],
    MOZ_USE_NATIVE_UCONV=1,
    MOZ_USE_NATIVE_UCONV= )
if test "$MOZ_USE_NATIVE_UCONV"; then
    AC_DEFINE(MOZ_USE_NATIVE_UCONV)
fi
if test "$OS_ARCH" != "WINCE" -a "$OS_ARCH" != "WINNT" -a "$MOZ_USE_NATIVE_UCONV" -a "$ac_cv_func_iconv" != "yes"; then
    AC_MSG_ERROR([iconv() not found.  Cannot enable native uconv support.])
fi


dnl ========================================================
dnl Libeditor can be build as plaintext-only,
dnl or as a full html and text editing component.
dnl We build both by default.
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(plaintext-editor-only,
[  --enable-plaintext-editor-only
                          Allow only plaintext editing],
    MOZ_PLAINTEXT_EDITOR_ONLY=1,
    MOZ_PLAINTEXT_EDITOR_ONLY= )
dnl Note the #define is MOZILLA, not MOZ, for compat with the Mac build.
AC_SUBST(MOZ_PLAINTEXT_EDITOR_ONLY)

dnl ========================================================
dnl = Drop XPCOM Obsolete library
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xpcom-obsolete,
[  --disable-xpcom-obsolete           Disable XPCOM Obsolete Library],
    MOZ_NO_XPCOM_OBSOLETE=1,
    MOZ_NO_XPCOM_OBSOLETE=)

if test -n "$MOZ_NO_XPCOM_OBSOLETE"; then
    AC_DEFINE(MOZ_NO_XPCOM_OBSOLETE)
fi

dnl ========================================================
dnl = Disable Fast Load
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xpcom-fastload,
[  --disable-xpcom-fastload           Disable XPCOM fastload support],
    MOZ_NO_FAST_LOAD=1,
    MOZ_NO_FAST_LOAD=)

AC_SUBST(MOZ_NO_FAST_LOAD)

if test -n "$MOZ_NO_FAST_LOAD"; then
    AC_DEFINE(MOZ_NO_FAST_LOAD)
fi

dnl ========================================================
dnl = Disable Ogg Codecs
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(ogg,
[  --disable-ogg           Disable Ogg Codec support],
    MOZ_OGG=,
    MOZ_OGG=1)

AC_SUBST(MOZ_OGG)

if test -n "$MOZ_OGG"; then
    AC_DEFINE(MOZ_OGG)
    MOZ_SYDNEYAUDIO=1
    MOZ_MEDIA=1

    dnl Checks for __attribute__(aligned()) directive
    AC_CACHE_CHECK([__attribute__ ((aligned ())) support],
        [ac_cv_c_attribute_aligned],
        [ac_cv_c_attribute_aligned=0
         CFLAGS_save="${CFLAGS}"
         CFLAGS="${CFLAGS} -Werror"
         for ac_cv_c_attr_align_try in 64 32 16 8; do
           echo "trying $ac_cv_c_attr_align_try"
           AC_TRY_COMPILE([],
                          [static char c __attribute__ ((aligned(${ac_cv_c_attr_align_try}))) = 0; return c;],
                          [ac_cv_c_attribute_aligned="${ac_cv_c_attr_align_try}"])
           if test "$ac_cv_c_attribute_aligned" != 0; then
             break;
           fi
         done
           CFLAGS="${CFLAGS_save}"])
    if test "${ac_cv_c_attribute_aligned}" != "0"; then
      AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX],
                         [${ac_cv_c_attribute_aligned}],[Maximum supported data alignment])
    fi
fi

dnl ========================================================
dnl = Disable Wave decoder support
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(wave,
[  --disable-wave          Disable Wave decoder support],
    MOZ_WAVE=,
    MOZ_WAVE=1)

AC_SUBST(MOZ_WAVE)

if test -n "$MOZ_WAVE"; then
    AC_DEFINE(MOZ_WAVE)
    MOZ_SYDNEYAUDIO=1
    MOZ_MEDIA=1
fi

dnl ========================================================
dnl = Handle dependent SYDNEYAUDIO and MEDIA defines
dnl ========================================================

AC_SUBST(MOZ_SYDNEYAUDIO)

if test -n "$MOZ_SYDNEYAUDIO"; then
    AC_DEFINE(MOZ_SYDNEYAUDIO)
fi

AC_SUBST(MOZ_MEDIA)

if test -n "$MOZ_MEDIA"; then
    AC_DEFINE(MOZ_MEDIA)
fi

dnl ========================================================
dnl = Check alsa availability on Linux if using sydneyaudio
dnl ========================================================

dnl If using sydneyaudio with Linux, ensure that the alsa library is available
if test "$COMPILE_ENVIRONMENT"; then
if test -n "$MOZ_SYDNEYAUDIO"; then
   case "$target_os" in
linux*)
      AC_CHECK_LIB(asound, snd_pcm_open,,AC_MSG_ERROR([Ogg support on Linux requires the alsa library]))
      ;;
   esac
fi
fi

dnl ========================================================
dnl Splashscreen
dnl ========================================================
AC_ARG_ENABLE(splashscreen,
              [  --enable-splashscreen   display splashscreen while loading (default=no)],
              [enable_splash="yes"],[enable_splash=""])
if test "x$enable_splash" = "xyes"; then
  MOZ_SPLASHSCREEN=1
  AC_DEFINE(MOZ_SPLASHSCREEN)
fi
AC_SUBST(MOZ_SPLASHSCREEN)

dnl ========================================================
dnl Permissions System
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(permissions,
[  --disable-permissions   Disable permissions (popup and cookie blocking)],
    MOZ_PERMISSIONS=,
    MOZ_PERMISSIONS=1
)

dnl ========================================================
dnl NegotiateAuth
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(negotiateauth,
[  --disable-negotiateauth Disable GSS-API negotiation ],
    MOZ_AUTH_EXTENSION=,
    MOZ_AUTH_EXTENSION=1 )

dnl ========================================================
dnl XTF
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xtf,
[  --disable-xtf           Disable XTF (pluggable xml tags) support],
    MOZ_XTF=,
    MOZ_XTF=1 )
if test "$MOZ_XTF"; then
  AC_DEFINE(MOZ_XTF)
fi

dnl ========================================================
dnl Inspector APIs
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(inspector-apis,
[  --disable-inspector-apis Disable the DOM inspection APIs ],
    MOZ_NO_INSPECTOR_APIS=1,
    MOZ_NO_INSPECTOR_APIS= )

dnl ========================================================
dnl Pref extensions (autoconfig and system-pref)
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(pref-extensions,
[  --disable-pref-extensions
                          Disable pref extensions such as autoconfig and
                          system-pref],
  MOZ_PREF_EXTENSIONS=,
  MOZ_PREF_EXTENSIONS=1 )

dnl ========================================================
dnl = Universalchardet
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(universalchardet,
[  --disable-universalchardet
                          Disable universal encoding detection],
  MOZ_UNIVERSALCHARDET=,
  MOZ_UNIVERSALCHARDET=1 )

dnl ========================================================
dnl JavaXPCOM
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(javaxpcom,
[  --enable-javaxpcom
                          Enable Java-XPCOM bridge],
    MOZ_JAVAXPCOM=1,
    MOZ_JAVAXPCOM= )

if test -n "${MOZ_JAVAXPCOM}"; then
  case "$host_os" in
    cygwin*|msvc*|mks*)
      if test -n "$JAVA_HOME"; then
        JAVA_HOME=`cygpath -u \`cygpath -m -s "$JAVA_HOME"\``
      fi
      ;;
    *mingw*)
      if test -n "$JAVA_HOME"; then
        JAVA_HOME=`cd "$JAVA_HOME" && pwd`
      fi
      ;;
  esac

  if test -n "${JAVA_INCLUDE_PATH}"; then
    dnl Make sure jni.h exists in the given include path.
    if test ! -f "$JAVA_INCLUDE_PATH/jni.h"; then
      AC_MSG_ERROR([jni.h was not found in given include path $JAVA_INCLUDE_PATH.])
    fi
  else
    case "$target_os" in
      darwin*)
        dnl Default to java system location
        JAVA_INCLUDE_PATH=/System/Library/Frameworks/JavaVM.framework/Headers
        ;;
      *)
        dnl Try $JAVA_HOME
        JAVA_INCLUDE_PATH="$JAVA_HOME/include"
        ;;
    esac
    if test ! -f "$JAVA_INCLUDE_PATH/jni.h"; then
      AC_MSG_ERROR([The header jni.h was not found.  Set \$JAVA_HOME to your java sdk directory, use --with-java-bin-path={java-bin-dir}, or reconfigure with --disable-javaxpcom.])
    fi
  fi

  if test -n "${JAVA_BIN_PATH}"; then
    dnl Look for javac and jar in the specified path.
    JAVA_PATH="$JAVA_BIN_PATH"
  else
    dnl No path specified, so look for javac and jar in $JAVA_HOME & $PATH.
    JAVA_PATH="$JAVA_HOME/bin:$PATH"
  fi

  MOZ_PATH_PROG(JAVA, java, :, [$JAVA_PATH])
  MOZ_PATH_PROG(JAVAC, javac, :, [$JAVA_PATH])
  MOZ_PATH_PROG(JAR, jar, :, [$JAVA_PATH])
  if test -z "$JAVA" || test "$JAVA" = ":" || test -z "$JAVAC" || test "$JAVAC" = ":" || test -z "$JAR" || test "$JAR" = ":"; then
    AC_MSG_ERROR([The programs java, javac and jar were not found.  Set \$JAVA_HOME to your java sdk directory, use --with-java-bin-path={java-bin-dir}, or reconfigure with --disable-javaxpcom.])
  fi
fi

dnl ========================================================
dnl = Breakpad crash reporting (on by default on supported platforms)
dnl ========================================================

case $target in
i?86-*-mingw*)
  MOZ_CRASHREPORTER=1
  ;;
i?86-apple-darwin*|powerpc-apple-darwin*)
  MOZ_CRASHREPORTER=1
  ;;
i?86-*-linux*|x86_64-*-linux*|arm-*-linux*)
  MOZ_CRASHREPORTER=1
  ;;
*solaris*)
  MOZ_CRASHREPORTER=1
  ;;
esac

MOZ_ARG_DISABLE_BOOL(crashreporter,
[  --disable-crashreporter          Disable breakpad crash reporting],
    MOZ_CRASHREPORTER=,
    MOZ_CRASHREPORTER=1)

if test -n "$MOZ_CRASHREPORTER"; then
   AC_DEFINE(MOZ_CRASHREPORTER)

  if (test "$OS_ARCH" = "Linux" || test "$OS_ARCH" = "SunOS") && \
    test -z "$SKIP_LIBRARY_CHECKS"; then
    PKG_CHECK_MODULES(MOZ_GTHREAD, gthread-2.0)
    AC_SUBST(MOZ_GTHREAD_CFLAGS)
    AC_SUBST(MOZ_GTHREAD_LIBS)

    AC_CHECK_HEADERS([curl/curl.h], [], [AC_MSG_ERROR([Couldn't find curl/curl.h which is required for the crash reporter.  Use --disable-crashreporter to disable the crash reporter.])])
  fi
fi

MOZ_ARG_WITH_STRING(crashreporter-enable-percent,
[  --with-crashreporter-enable-percent=NN  Enable sending crash reports by default on NN% of users. (default=100)],
[ val=`echo $withval | sed 's/[^0-9]//g'`
    MOZ_CRASHREPORTER_ENABLE_PERCENT="$val"])

if test -z "$MOZ_CRASHREPORTER_ENABLE_PERCENT"; then
   MOZ_CRASHREPORTER_ENABLE_PERCENT=100
fi
AC_DEFINE_UNQUOTED(MOZ_CRASHREPORTER_ENABLE_PERCENT, $MOZ_CRASHREPORTER_ENABLE_PERCENT)

dnl ========================================================
dnl = Enable compilation of specific extension modules
dnl ========================================================

MOZ_ARG_ENABLE_STRING(extensions,
[  --enable-extensions     Enable extensions],
[ for option in `echo $enableval | sed 's/,/ /g'`; do
    if test "$option" = "yes" || test "$option" = "all"; then
        AC_MSG_ERROR([--enable-extensions=$option is no longer supported.])
    elif test "$option" = "no" || test "$option" = "none"; then
        MOZ_EXTENSIONS=""
    elif test "$option" = "default"; then
        MOZ_EXTENSIONS="$MOZ_EXTENSIONS $MOZ_EXTENSIONS_DEFAULT"
    elif test `echo "$option" | grep -c \^-` != 0; then
        option=`echo $option | sed 's/^-//'`
        MOZ_EXTENSIONS=`echo "$MOZ_EXTENSIONS" | sed "s/ ${option}//"`
    else
        MOZ_EXTENSIONS="$MOZ_EXTENSIONS $option"
    fi
done],
    MOZ_EXTENSIONS="$MOZ_EXTENSIONS_DEFAULT")

if test -z "$MOZ_ENABLE_GNOMEVFS" && test `echo "$MOZ_EXTENSIONS" | grep -c gnomevfs` -ne 0; then
    # Suppress warning on non-X11 platforms
    if test -n "$MOZ_X11"; then
        AC_MSG_WARN([Cannot build gnomevfs without required libraries. Removing gnomevfs from MOZ_EXTENSIONS.])
    fi
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|gnomevfs||'`
fi

dnl Do not build gnomevfs with libxul based apps
if test ! -z "$LIBXUL_SDK_DIR" && test `echo "$MOZ_EXTENSIONS" | grep -c gnomevfs` -ne 0; then
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|gnomevfs||'`
fi

if test -z "$MOZ_JSDEBUGGER" && test `echo "$MOZ_EXTENSIONS" | grep -c venkman` -ne 0; then
    AC_MSG_WARN([Cannot build venkman without JavaScript debug library. Removing venkman from MOZ_EXTENSIONS.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|venkman||'`
fi

dnl This might be temporary: build tridentprofile only on Windows
if test `echo "$MOZ_EXTENSIONS" | grep -c tridentprofile` -ne 0 && test "$OS_ARCH" != "WINNT"; then
    AC_MSG_WARN([tridentprofile extension works only on Windows at this time. Removing tridentprofile from MOZ_EXTENSIONS.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|tridentprofile||'`
fi

dnl cookie must be built before tridentprofile. put it at list's end.
if test `echo "$MOZ_EXTENSIONS" | grep -c tridentprofile` -ne 0; then
  MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|tridentprofile||'`
  MOZ_EXTENSIONS="$MOZ_EXTENSIONS tridentprofile"
fi

dnl xforms requires xtf and schema-validation
if test -z "$MOZ_XTF" && test `echo "$MOZ_EXTENSIONS" | grep -c xforms` -ne 0; then
    AC_MSG_WARN([Cannot build XForms without XTF support.  Removing XForms from MOZ_EXTENSIONS.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|xforms||g'`
fi
if test `echo "$MOZ_EXTENSIONS" | grep -c xforms` -ne 0 && test `echo "$MOZ_EXTENSIONS" | grep -c schema-validation` -eq 0; then
    AC_MSG_WARN([Cannot build XForms without schema validation.  Removing XForms from MOZ_EXTENSIONS.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|xforms||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c auth` -ne 0; then
    AC_MSG_WARN([auth is no longer an extension, use --disable-negotiateauth to disable.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|auth||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c 'cookie\|permissions'` -ne 0; then
    AC_MSG_WARN([cookie and permissions are no longer extensions, use --disable-permissions to disable.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|cookie||g; s|permissions||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c pref` -ne 0; then
    AC_MSG_WARN([pref is no longer an extension, use --disable-pref-extensions to disable.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|pref||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c universalchardet` -ne 0; then
    AC_MSG_WARN([universalchardet is no longer an extension, use --disable-universalchardet to disable.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|universalchardet||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c java` -ne 0; then
    AC_MSG_WARN([java is no longer an extension, use --enable-javaxpcom to enable.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|java||g'`
fi

if test `echo "$MOZ_EXTENSIONS" | grep -c spellcheck` -ne 0; then
    AC_MSG_WARN([spellcheck is no longer an extension.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|spellcheck||g'`
fi

if test -n "$MOZ_NO_XPCOM_OBSOLETE" && test `echo "$MOZ_EXTENSIONS" | grep -c sroaming` -ne 0; then
    AC_MSG_WARN([Cannot currently build sroaming without xpcom obsolete -- bug 249343. Removing sroaming from MOZ_EXTENSIONS.])
    MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's|sroaming||'`
fi

dnl Remove dupes
MOZ_EXTENSIONS=`${PERL} ${srcdir}/build/unix/uniq.pl ${MOZ_EXTENSIONS}`

dnl Ensure every extension exists, to avoid mostly-inscrutable error messages
dnl when trying to build a non-existent extension.
for extension in $MOZ_EXTENSIONS; do
    if test ! -d "${srcdir}/extensions/${extension}"; then
        AC_MSG_ERROR([Unrecognized extension provided to --enable-extensions: ${extension}.])
    fi
done


dnl ========================================================
dnl Image decoders
dnl ========================================================
case "$MOZ_WIDGET_TOOLKIT" in
beos|windows|os2|mac|cocoa)
    ;;
*)
    if test -z "$MOZ_ENABLE_GTK2" && test -z "$MOZ_ENABLE_QT"; then
       MOZ_IMG_DECODERS_DEFAULT=`echo $MOZ_IMG_DECODERS_DEFAULT | sed -e 's|icon||'`
    fi
    ;;
esac

MOZ_ARG_ENABLE_STRING(image-decoders,
[  --enable-image-decoders[={mod1,mod2,default,all,none}]
                          Enable specific image decoders],
[ for option in `echo $enableval | sed 's/,/ /g'`; do
    if test "$option" = "yes" || test "$option" = "all"; then
        MOZ_IMG_DECODERS="$MOZ_IMG_DECODERS $MOZ_IMG_DECODERS_DEFAULT"
    elif test "$option" = "no" || test "$option" = "none"; then
        MOZ_IMG_DECODERS=""
    elif test "$option" = "default"; then
        MOZ_IMG_DECODERS="$MOZ_IMG_DECODERS $MOZ_IMG_DECODERS_DEFAULT"
    elif test `echo "$option" | grep -c \^-` != 0; then
        option=`echo $option | sed 's/^-//'`
        MOZ_IMG_DECODERS=`echo "$MOZ_IMG_DECODERS" | sed "s/ ${option}//"`
    else
        MOZ_IMG_DECODERS="$MOZ_IMG_DECODERS $option"
    fi
done],
    MOZ_IMG_DECODERS="$MOZ_IMG_DECODERS_DEFAULT")

dnl Dupes are removed in the encoder section because it will also add decoders

dnl ========================================================
dnl Image encoders
dnl ========================================================
MOZ_ARG_ENABLE_STRING(image-encoders,
[  --enable-image-encoders[={mod1,mod2,default,all,none}]
                          Enable specific image encoders],
[ for option in `echo $enableval | sed 's/,/ /g'`; do
    if test "$option" = "yes" || test "$option" = "all"; then
        addencoder="$MOZ_IMG_ENCODERS_DEFAULT"
    elif test "$option" = "no" || test "$option" = "none"; then
        MOZ_IMG_ENCODERS=""
        addencoder=""
    elif test "$option" = "default"; then
        addencoder="$MOZ_IMG_ENCODERS_DEFAULT"
    elif test `echo "$option" | grep -c \^-` != 0; then
        option=`echo $option | sed 's/^-//'`
        addencoder=`echo "$MOZ_IMG_ENCODERS" | sed "s/ ${option}//"`
    else
        addencoder="$option"
    fi
    MOZ_IMG_ENCODERS="$MOZ_IMG_ENCODERS $addencoder"
done],
    MOZ_IMG_ENCODERS="$MOZ_IMG_ENCODERS_DEFAULT")

dnl Remove dupes
MOZ_IMG_DECODERS=`${PERL} ${srcdir}/build/unix/uniq.pl ${MOZ_IMG_DECODERS}`
MOZ_IMG_ENCODERS=`${PERL} ${srcdir}/build/unix/uniq.pl ${MOZ_IMG_ENCODERS}`

dnl ========================================================
dnl MathML on by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(mathml,
[  --disable-mathml        Disable MathML support],
    MOZ_MATHML=,
    MOZ_MATHML=1 )
if test "$MOZ_MATHML"; then
  AC_DEFINE(MOZ_MATHML)
fi

dnl ========================================================
dnl Canvas
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(canvas,
[  --disable-canvas          Disable html:canvas feature],
    MOZ_ENABLE_CANVAS=,
    MOZ_ENABLE_CANVAS=1 )
if test -n "$MOZ_ENABLE_CANVAS"; then
    AC_DEFINE(MOZ_ENABLE_CANVAS)
fi
AC_SUBST(MOZ_ENABLE_CANVAS)

MOZ_ARG_ENABLE_BOOL(canvas3d,
[  --enable-canvas3d        Enable canvas 3D context],
    MOZ_ENABLE_CANVAS3D=1,
    MOZ_ENABLE_CANVAS3D= )
if test -n "$MOZ_ENABLE_CANVAS3D"; then
    AC_DEFINE(MOZ_ENABLE_CANVAS3D)
fi
AC_SUBST(MOZ_ENABLE_CANVAS3D)

dnl ========================================================
dnl SVG
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(svg,
[  --disable-svg            Disable SVG support],
    MOZ_SVG=,
    MOZ_SVG=1 )
if test -n "$MOZ_SVG"; then
  AC_DEFINE(MOZ_SVG)
fi

dnl ========================================================
dnl SMIL
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(smil,
[  --enable-smil           Enable SMIL animation support],
    MOZ_SMIL=1,
    MOZ_SMIL= )
# Automatically disable SMIL if SVG is disabled
if test -z "$MOZ_SVG"; then
  MOZ_SMIL=
fi
if test -n "$MOZ_SMIL"; then
  AC_DEFINE(MOZ_SMIL)
fi

dnl ========================================================
dnl Build Freetype in the tree
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(tree-freetype,
[  --enable-tree-freetype         Enable Tree FreeType],
    MOZ_TREE_FREETYPE=1,
    MOZ_TREE_FREETYPE= )
if test -n "$MOZ_TREE_FREETYPE"; then
   AC_DEFINE(MOZ_TREE_FREETYPE)
   AC_SUBST(MOZ_TREE_FREETYPE)
   MOZ_ENABLE_CAIRO_FT=1       
   FT_FONT_FEATURE="#define CAIRO_HAS_FT_FONT 1"
   FT2_CFLAGS='-I$(topsrcdir)/modules/freetype2/include'
   CAIRO_FT_CFLAGS='-I$(topsrcdir)/modules/freetype2/include'
   FT2_LIBS='$(LIBXUL_DIST)/lib/freetype2.lib'
   CAIRO_FT_LIBS='$(LIBXUL_DIST)/lib/freetype2.lib'
   AC_DEFINE(HAVE_FT_BITMAP_SIZE_Y_PPEM)
   AC_DEFINE(HAVE_FT_GLYPHSLOT_EMBOLDEN)
   AC_DEFINE(HAVE_FT_LOAD_SFNT_TABLE)
   AC_SUBST(CAIRO_FT_CFLAGS)
fi


dnl ========================================================
dnl Installer
dnl ========================================================
case "$target_os" in
    aix*|solaris*|linux*|msvc*|mks*|cygwin*|mingw*|os2*|wince*)
        MOZ_INSTALLER=1
        ;;
esac

MOZ_ARG_DISABLE_BOOL(installer,
[  --disable-installer     Disable building of installer],
    MOZ_INSTALLER=,
    MOZ_INSTALLER=1 )
if test -n "$MOZ_INSTALLER" -a "$OS_ARCH" = "WINNT"; then
    # Disable installer for Windows builds that use the new toolkit if NSIS
    # isn't in the path.
    MOZ_PATH_PROGS(MAKENSIS, makensis)
    if test -z "$MAKENSIS" || test "$MAKENSIS" = ":"; then
        AC_MSG_ERROR([To build the installer makensis is required in your path. To build without the installer reconfigure using --disable-installer.])
    fi
    # The Windows build for NSIS requires the iconv command line utility to
    # convert the charset of the locale files.
    MOZ_PATH_PROGS(HOST_ICONV, $HOST_ICONV "iconv", "")
    if test -z "$HOST_ICONV"; then
        AC_MSG_ERROR([To build the installer iconv is required in your path. To build without the installer reconfigure using --disable-installer.])
    fi
fi

# Automatically disable installer if xpinstall isn't built
if test -z "$MOZ_XPINSTALL"; then
    MOZ_INSTALLER=
fi
AC_SUBST(MOZ_INSTALLER)

AC_MSG_CHECKING([for tar archiver])
AC_CHECK_PROGS(TAR, gnutar gtar tar, "")
if test -z "$TAR"; then
    AC_MSG_ERROR([no tar archiver found in \$PATH])
fi
AC_MSG_RESULT([$TAR])
AC_SUBST(TAR)

AC_MSG_CHECKING([for wget])
AC_CHECK_PROGS(WGET, wget, "")
AC_MSG_RESULT([$WGET])
AC_SUBST(WGET)

dnl ========================================================
dnl Updater
dnl ========================================================

MOZ_ARG_DISABLE_BOOL(updater,
[  --disable-updater       Disable building of updater],
    MOZ_UPDATER=,
    MOZ_UPDATER=1 )
AC_SUBST(MOZ_UPDATER)

# app update channel is 'default' when not supplied.
MOZ_ARG_ENABLE_STRING([update-channel],
[  --enable-update-channel=CHANNEL
                           Select application update channel (default=default)],
    MOZ_UPDATE_CHANNEL=`echo $enableval | tr A-Z a-z`)

if test -z "$MOZ_UPDATE_CHANNEL"; then
    MOZ_UPDATE_CHANNEL=default
fi
AC_DEFINE_UNQUOTED(MOZ_UPDATE_CHANNEL, $MOZ_UPDATE_CHANNEL)

# tools/update-packaging is not checked out by default.
MOZ_ARG_ENABLE_BOOL(update-packaging,
[  --enable-update-packaging
                           Enable tools/update-packaging],
    MOZ_UPDATE_PACKAGING=1,
    MOZ_UPDATE_PACKAGING= )
AC_SUBST(MOZ_UPDATE_PACKAGING)

dnl ========================================================
dnl ActiveX
dnl ========================================================

MOZ_ARG_DISABLE_BOOL(xpconnect-idispatch,
[  --disable-xpconnect-idispatch
                          Disable building of xpconnect support for IDispatch
                          (win32 only)],
    XPC_IDISPATCH_SUPPORT=,
    XPC_IDISPATCH_SUPPORT=1)
AC_SUBST(XPC_IDISPATCH_SUPPORT)

MOZ_ARG_DISABLE_BOOL(activex,
[  --disable-activex       Disable building of ActiveX control (win32 only)],
    MOZ_NO_ACTIVEX_SUPPORT=1,
    MOZ_NO_ACTIVEX_SUPPORT= )
AC_SUBST(MOZ_NO_ACTIVEX_SUPPORT)

MOZ_ARG_ENABLE_BOOL(activex-scripting,
[  --enable-activex-scripting
                          Enable building of ActiveX scripting support (win32)],
    MOZ_ACTIVEX_SCRIPTING_SUPPORT=1,
    MOZ_ACTIVEX_SCRIPTING_SUPPORT=)
AC_SUBST(MOZ_ACTIVEX_SCRIPTING_SUPPORT)

if test -n "$MOZ_NO_ACTIVEX_SUPPORT" -a -n "$MOZ_ACTIVEX_SCRIPTING_SUPPORT";
then
    AC_MSG_ERROR([Cannot enable ActiveX scripting support when ActiveX support is disabled.])
fi

if test "$COMPILE_ENVIRONMENT" = "1"; then
if test -n "$XPC_IDISPATCH_SUPPORT" -o -n "$MOZ_ACTIVEX_SCRIPTING_SUPPORT" -o -z "$MOZ_NO_ACTIVEX_SUPPORT"; then
case "$target" in
*-mingw*|*-cygwin*|*-msvc*|*-mks*)
    if test "$ac_cv_header_atlbase_h" = "no"; then
        AC_MSG_ERROR([System header atlbase.h is not available. See http://developer.mozilla.org/en/docs/atlbase.h for details on fixing this problem.])
    fi
    ;;
esac
fi
fi

dnl ========================================================
dnl leaky
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(leaky,
[  --enable-leaky          Build leaky memory tool],
    MOZ_LEAKY=1,
    MOZ_LEAKY=)


dnl ========================================================
dnl xpctools
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(xpctools,
[  --enable-xpctools       Build JS profiling tool],
    MOZ_XPCTOOLS=1,
    MOZ_XPCTOOLS= )


dnl ========================================================
dnl build the tests by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(tests,
[  --disable-tests         Do not build test libraries & programs],
    ENABLE_TESTS=,
    ENABLE_TESTS=1 )

dnl ========================================================
dnl parental controls (for Windows Vista)
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(parental-controls,
[  --disable-parental-controls
                           Do not build parental controls],
   MOZ_DISABLE_PARENTAL_CONTROLS=1,
   MOZ_DISABLE_PARENTAL_CONTROLS=)
if test -n "$MOZ_DISABLE_PARENTAL_CONTROLS"; then
    AC_DEFINE(MOZ_DISABLE_PARENTAL_CONTROLS)
fi

AC_SUBST(MOZ_DISABLE_PARENTAL_CONTROLS)

dnl ========================================================
dnl =
dnl = Module specific options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Individual module options)

dnl ========================================================
dnl = Enable Lea malloc in xpcom. OFF by default.
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(xpcom-lea,
[  --enable-xpcom-lea      Use Lea malloc in xpcom ],
    XPCOM_USE_LEA=1,
    XPCOM_USE_LEA= )
if test -n "$XPCOM_USE_LEA"; then
    AC_DEFINE(XPCOM_USE_LEA)
fi

dnl ========================================================
dnl = Enable places (new history/bookmarks)
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(places,
[  --enable-places        Enable 'places' bookmark/history implementation],
    MOZ_PLACES=1,
    MOZ_PLACES= )
if test -n "$MOZ_PLACES"; then
    AC_DEFINE(MOZ_PLACES)
    if test -z "$MOZ_MAIL_NEWS"; then
      MOZ_MORK=
    fi
    MOZ_MORKREADER=1
else
  if test "$MOZ_BUILD_APP" = "browser"; then
    AC_MSG_ERROR([Cannot build Firefox with --disable-places.])
  fi
fi

dnl ========================================================
dnl = Disable feed handling components
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(feeds,
[  --disable-feeds        Disable feed handling and processing components],
    MOZ_FEEDS=,
    MOZ_FEEDS=1 )
if test -n "$MOZ_FEEDS"; then
    AC_DEFINE(MOZ_FEEDS)
else
    if test "$MOZ_BUILD_APP" = "browser"; then
        AC_MSG_ERROR([Cannot build Firefox with --disable-feeds.])
    fi
fi

dnl ========================================================
dnl = Enable mozStorage
dnl ========================================================
dnl Implicitly enabled by default if building calendar or places
MOZ_ARG_ENABLE_BOOL(storage,
[  --enable-storage        Enable mozStorage module and related components],
    MOZ_STORAGE=1,
    MOZ_STORAGE= )
if test -n "$MOZ_STORAGE"; then
    AC_DEFINE(MOZ_STORAGE)
fi

dnl ========================================================
dnl Check for sqlite
dnl ========================================================

MOZ_NATIVE_SQLITE=
MOZ_ARG_ENABLE_BOOL(system-sqlite,
[  --enable-system-sqlite  Use system sqlite (located with pkgconfig)],
MOZ_NATIVE_SQLITE=1,
MOZ_NATIVE_SQLITE= )

if test -z "$MOZ_NATIVE_SQLITE"
then
    SQLITE_CFLAGS=
    SQLITE_LIBS='$(call EXPAND_LIBNAME_PATH,sqlite3,$(DIST)/lib)'
else
    PKG_CHECK_MODULES(SQLITE, sqlite3 >= $SQLITE_VERSION)
fi

AC_SUBST(MOZ_NATIVE_SQLITE)

dnl ========================================================
dnl = Enable help viewer (off by default)
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(help-viewer,
[  --enable-help-viewer        Enable help viewer],
    MOZ_HELP_VIEWER=1,
    MOZ_HELP_VIEWER= )
if test -n "$MOZ_HELP_VIEWER"; then
     AC_DEFINE(MOZ_HELP_VIEWER)
fi
AC_SUBST(MOZ_HELP_VIEWER)
if test "$MOZ_BUILD_APP" = "browser" -a -n "$MOZ_HELP_VIEWER"; then
    AC_MSG_ERROR([Cannot build Firefox with --enable-help-viewer.])
fi

dnl ========================================================
dnl = Enable safe browsing (anti-phishing)
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(safe-browsing,
[  --enable-safe-browsing        Enable safe browsing (anti-phishing) implementation],
    MOZ_SAFE_BROWSING=1,
    MOZ_SAFE_BROWSING= )
if test -n "$MOZ_SAFE_BROWSING"; then
    AC_DEFINE(MOZ_SAFE_BROWSING)
fi
AC_SUBST(MOZ_SAFE_BROWSING)

dnl ========================================================
dnl = Enable faststart component
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(faststart,
[  --enable-faststart            Enable the faststart component],
    MOZ_FASTSTART=1,
    MOZ_FASTSTART= )
if test -n "$MOZ_FASTSTART"; then
    AC_DEFINE(MOZ_FASTSTART)
fi
AC_SUBST(MOZ_FASTSTART)

dnl ========================================================
dnl = Enable url-classifier
dnl ========================================================
dnl Implicitly enabled by default if building with safe-browsing
if test -n "$MOZ_SAFE_BROWSING"; then
    MOZ_URL_CLASSIFIER=1
fi
MOZ_ARG_ENABLE_BOOL(url-classifier,
[  --enable-url-classifier        Enable url classifier module],
    MOZ_URL_CLASSIFIER=1,
    MOZ_URL_CLASSIFIER= )
if test -n "$MOZ_URL_CLASSIFIER"; then
    AC_DEFINE(MOZ_URL_CLASSIFIER)
fi
AC_SUBST(MOZ_URL_CLASSIFIER)

dnl ========================================================
dnl = Disable zipwriter
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(zipwriter,
[  --disable-zipwriter             Disable zipwriter component],
    MOZ_ZIPWRITER=,
    MOZ_ZIPWRITER=1 )
AC_SUBST(MOZ_ZIPWRITER)

dnl ========================================================
dnl = Disable libconic
dnl ========================================================
MOZ_ENABLE_LIBCONIC=1
MOZ_ARG_DISABLE_BOOL(libconic,
[  --disable-libconic              Disable libconic],
    MOZ_ENABLE_LIBCONIC=,
    MOZ_ENABLE_LIBCONIC=1 )

if test -n "$MOZ_ENABLE_LIBCONIC"; then
    PKG_CHECK_MODULES(LIBCONIC, conic,
                      MOZ_ENABLE_LIBCONIC=1,
                      MOZ_ENABLE_LIBCONIC=)
fi
if test "$MOZ_ENABLE_LIBCONIC"; then
    AC_DEFINE(MOZ_ENABLE_LIBCONIC)
fi

AC_SUBST(MOZ_ENABLE_LIBCONIC)
AC_SUBST(LIBCONIC_CFLAGS)
AC_SUBST(LIBCONIC_LIBS)
 
dnl ========================================================
dnl = Maemo checks
dnl ========================================================

MAEMO_SDK_TARGET_VER=-1

MOZ_ARG_WITH_STRING(maemo-version,
[  --with-maemo-version=MAEMO_SDK_TARGET_VER
                        Maemo SDK Version],
  MAEMO_SDK_TARGET_VER=$withval)

case "$MAEMO_SDK_TARGET_VER" in
5)
    MOZ_PLATFORM_MAEMO=5
    ;;

6)
    MOZ_PLATFORM_MAEMO=6
    ;;

-1)
    dnl We aren't compiling for Maemo, move on.
    ;;
*)
    AC_MSG_ERROR([Unknown Maemo Version.  Try setting --with-maemo-version to 5 or 6.])
    ;;
esac

if test $MOZ_PLATFORM_MAEMO; then
   AC_DEFINE_UNQUOTED([MOZ_PLATFORM_MAEMO], $MOZ_PLATFORM_MAEMO)

   if test -z "$MOZ_ENABLE_DBUS"; then
       AC_MSG_ERROR([DBus is required when building for Maemo])
   fi
   
   MOZ_GFX_OPTIMIZE_MOBILE=1
   MOZ_WEBGL_GLX=

   if test $MOZ_PLATFORM_MAEMO = 5; then
      dnl if we have Xcomposite we should also have Xdamage and Xfixes
      AC_CHECK_HEADERS([X11/extensions/Xdamage.h], [],
                       [AC_MSG_ERROR([Couldn't find X11/extensions/Xdamage.h which is required for composited plugins.])])
      AC_CHECK_LIB(Xcomposite, XCompositeRedirectWindow, [XCOMPOSITE_LIBS="-lXcomposite -lXdamage -lXfixes"],
                   [MISSING_X="$MISSING_X -lXcomposite"], $XLIBS)

      AC_SUBST(XCOMPOSITE_LIBS)

      PKG_CHECK_MODULES(LIBHILDONMIME,libhildonmime, _LIB_FOUND=1, _LIB_FOUND=)
      MOZ_PLATFORM_MAEMO_LIBS="$MOZ_PLATFORM_MAEMO_LIBS $LIBHILDONMIME_LIBS"
      MOZ_PLATFORM_MAEMO_CFLAGS="$MOZ_PLATFORM_MAEMO_CFLAGS $LIBHILDONMIME_CFLAGS"
      if test -z "$_LIB_FOUND"; then
         AC_MSG_ERROR([Hildon Mime is required when building for Maemo])
      fi


      PKG_CHECK_MODULES(LIBOSSO,libosso, _LIB_FOUND=1, _LIB_FOUND=)
      MOZ_PLATFORM_MAEMO_LIBS="$MOZ_PLATFORM_MAEMO_LIBS $LIBOSSO_LIBS"
      MOZ_PLATFORM_MAEMO_CFLAGS="$MOZ_PLATFORM_MAEMO_CFLAGS $LIBOSSO_CFLAGS"
      if test -z "$_LIB_FOUND"; then
         AC_MSG_ERROR([LibOSSO is required when building for Maemo])
      fi

      PKG_CHECK_MODULES(LIBHILDONFM,hildon-fm-2, _LIB_FOUND=1, _LIB_FOUND=)
      MOZ_PLATFORM_MAEMO_LIBS="$MOZ_PLATFORM_MAEMO_LIBS $LIBHILDONFM_LIBS"
      MOZ_PLATFORM_MAEMO_CFLAGS="$MOZ_PLATFORM_MAEMO_CFLAGS $LIBHILDONFM_CFLAGS"
      if test -z "$_LIB_FOUND"; then
         AC_MSG_ERROR([Hildon FM-2 is required when building for Maemo])
      fi

      PKG_CHECK_MODULES(LIBLOCATION,liblocation, _LIB_FOUND=1, _LIB_FOUND=)
      MOZ_PLATFORM_MAEMO_LIBS="$MOZ_PLATFORM_MAEMO_LIBS $LIBLOCATION_LIBS"
      MOZ_PLATFORM_MAEMO_CFLAGS="$MOZ_PLATFORM_MAEMO_CFLAGS $LIBLOCATION_CFLAGS"
      if test -z "$_LIB_FOUND"; then
         AC_MSG_ERROR([liblocation is required when building for Maemo])
      fi
   fi

   AC_SUBST(MOZ_PLATFORM_MAEMO_LIBS)
   AC_SUBST(MOZ_PLATFORM_MAEMO_CFLAGS)
fi

dnl ========================================================
dnl = faststripe theme
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(faststripe,
[  --enable-faststripe  Use faststripe theme],
    MOZ_THEME_FASTSTRIPE=1,
    MOZ_THEME_FASTSTRIPE= )
AC_SUBST(MOZ_THEME_FASTSTRIPE)

dnl ========================================================
dnl =
dnl = Feature options that require extra sources to be pulled
dnl =
dnl ========================================================
dnl MOZ_ARG_HEADER(Features that require extra sources)

dnl ========================================================
dnl =
dnl = Debugging Options
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Debugging and Optimizations)

dnl ========================================================
dnl = Disable building with debug info.
dnl = Debugging is OFF by default
dnl ========================================================
if test -z "$MOZ_DEBUG_FLAGS"
then
    case "$target" in
    *-irix*)
        if test "$GNU_CC"; then
            GCC_VERSION=`$CC -v 2>&1 | awk '/version/ { print $3 }'`
            case "$GCC_VERSION" in
            2.95.*)
                MOZ_DEBUG_FLAGS=""
                ;;
            *)
                MOZ_DEBUG_FLAGS="-g"
                ;;
            esac
        else
            MOZ_DEBUG_FLAGS="-g"
        fi
        ;;
    *)
    	MOZ_DEBUG_FLAGS="-g"
        ;;
    esac
fi

MOZ_ARG_ENABLE_STRING(debug,
[  --enable-debug[=DBG]    Enable building with developer debug info
                          (Using compiler flags DBG)],
[ if test "$enableval" != "no"; then
    MOZ_DEBUG=1
    if test -n "$enableval" && test "$enableval" != "yes"; then
        MOZ_DEBUG_FLAGS=`echo $enableval | sed -e 's|\\\ | |g'`
    fi
  else
    MOZ_DEBUG=
  fi ],
  MOZ_DEBUG=)

MOZ_DEBUG_ENABLE_DEFS="-DDEBUG -D_DEBUG"
 case "${target_os}" in
    beos*)
        MOZ_DEBUG_ENABLE_DEFS="$MOZ_DEBUG_ENABLE_DEFS -DDEBUG_${USER}"
        ;;
    msvc*|mks*|cygwin*|mingw*|os2*|wince*)
        MOZ_DEBUG_ENABLE_DEFS="$MOZ_DEBUG_ENABLE_DEFS -DDEBUG_`echo ${USERNAME} | sed -e 's| |_|g'`"
        ;;
    *) 
        MOZ_DEBUG_ENABLE_DEFS="$MOZ_DEBUG_ENABLE_DEFS -DDEBUG_`$WHOAMI`"
        ;;
  esac
MOZ_DEBUG_ENABLE_DEFS="$MOZ_DEBUG_ENABLE_DEFS -DTRACING"

MOZ_DEBUG_DISABLE_DEFS="-DNDEBUG -DTRIMMED"

if test -n "$MOZ_DEBUG"; then
    AC_MSG_CHECKING([for valid debug flags])
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $MOZ_DEBUG_FLAGS"
    AC_TRY_COMPILE([#include <stdio.h>], 
        [printf("Hello World\n");],
        _results=yes,
        _results=no)
    AC_MSG_RESULT([$_results])
    if test "$_results" = "no"; then
        AC_MSG_ERROR([These compiler flags are invalid: $MOZ_DEBUG_FLAGS])
    fi
    CFLAGS=$_SAVE_CFLAGS
fi

dnl ========================================================
dnl enable mobile optimizations
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(mobile-optimize,
[  --enable-mobile-optimize   Enable mobile optimizations],
    MOZ_GFX_OPTIMIZE_MOBILE=1)

AC_SUBST(MOZ_GFX_OPTIMIZE_MOBILE)

if test "$MOZ_GFX_OPTIMIZE_MOBILE"; then
    AC_DEFINE(MOZ_GFX_OPTIMIZE_MOBILE)
fi

dnl ========================================================
dnl = Enable code optimization. ON by default.
dnl ========================================================
if test -z "$MOZ_OPTIMIZE_FLAGS"; then
	MOZ_OPTIMIZE_FLAGS="-O"
fi

MOZ_ARG_ENABLE_STRING(optimize,
[  --disable-optimize      Disable compiler optimization
  --enable-optimize=[OPT] Specify compiler optimization flags [OPT=-O]],
[ if test "$enableval" != "no"; then
    MOZ_OPTIMIZE=1
    if test -n "$enableval" && test "$enableval" != "yes"; then
        MOZ_OPTIMIZE_FLAGS=`echo "$enableval" | sed -e 's|\\\ | |g'`
        MOZ_OPTIMIZE=2
    fi
else
    MOZ_OPTIMIZE=
fi ], MOZ_OPTIMIZE=1)

if test "$COMPILE_ENVIRONMENT"; then
if test -n "$MOZ_OPTIMIZE"; then
    AC_MSG_CHECKING([for valid optimization flags])
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $MOZ_OPTIMIZE_FLAGS"
    AC_TRY_COMPILE([#include <stdio.h>], 
        [printf("Hello World\n");],
        _results=yes,
        _results=no)
    AC_MSG_RESULT([$_results])
    if test "$_results" = "no"; then
        AC_MSG_ERROR([These compiler flags are invalid: $MOZ_OPTIMIZE_FLAGS])
    fi
    CFLAGS=$_SAVE_CFLAGS
fi
fi # COMPILE_ENVIRONMENT

AC_SUBST(MOZ_OPTIMIZE)
AC_SUBST(MOZ_OPTIMIZE_FLAGS)
AC_SUBST(MOZ_OPTIMIZE_LDFLAGS)
AC_SUBST(MOZ_OPTIMIZE_SIZE_TWEAK)

dnl ========================================================
dnl = Enable/disable debug for specific modules only
dnl =   module names beginning with ^ will be disabled 
dnl ========================================================
MOZ_ARG_ENABLE_STRING(debug-modules,
[  --enable-debug-modules  Enable/disable debug info for specific modules],
[ MOZ_DEBUG_MODULES=`echo $enableval| sed 's/,/ /g'` ] )

dnl ========================================================
dnl = Enable/disable generation of debugger info for specific modules only
dnl =    the special module name ALL_MODULES can be used to denote all modules
dnl =    module names beginning with ^ will be disabled
dnl ========================================================
MOZ_ARG_ENABLE_STRING(debugger-info-modules,
[  --enable-debugger-info-modules
                          Enable/disable debugger info for specific modules],
[ for i in `echo $enableval | sed 's/,/ /g'`; do
      dnl note that the list of module names is reversed as it is copied
      dnl this is important, as it will allow config.mk to interpret stuff like
      dnl "^ALL_MODULES xpcom" properly
      if test "$i" = "no"; then
        i="^ALL_MODULES"
      fi
      if test "$i" = "yes"; then
        i="ALL_MODULES"
      fi
      MOZ_DBGRINFO_MODULES="$i $MOZ_DBGRINFO_MODULES";
    done ])

dnl ========================================================
dnl Enable garbage collector
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(boehm,
[  --enable-boehm          Enable the Boehm Garbage Collector],
    GC_LEAK_DETECTOR=1,
    GC_LEAK_DETECTOR= )
if test -n "$GC_LEAK_DETECTOR"; then
    AC_DEFINE(GC_LEAK_DETECTOR)
fi

dnl ========================================================
dnl Disable runtime logging checks
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(logging,
[  --disable-logging       Disable logging facilities],
    NS_DISABLE_LOGGING=1,
    NS_DISABLE_LOGGING= )
if test "$NS_DISABLE_LOGGING"; then
    AC_DEFINE(NS_DISABLE_LOGGING)
else
    AC_DEFINE(MOZ_LOGGING)
fi

dnl ========================================================
dnl = dnl This will enable logging of addref, release, ctor, dtor.
dnl ========================================================
_ENABLE_LOGREFCNT=42
MOZ_ARG_ENABLE_BOOL(logrefcnt,
[  --enable-logrefcnt      Enable logging of refcounts (default=debug) ],
    _ENABLE_LOGREFCNT=1,
    _ENABLE_LOGREFCNT= )
if test "$_ENABLE_LOGREFCNT" = "1"; then
    AC_DEFINE(FORCE_BUILD_REFCNT_LOGGING)
elif test -z "$_ENABLE_LOGREFCNT"; then
    AC_DEFINE(NO_BUILD_REFCNT_LOGGING)
fi

dnl ========================================================
dnl = Enable trace malloc
dnl ========================================================
NS_TRACE_MALLOC=${MOZ_TRACE_MALLOC}
MOZ_ARG_ENABLE_BOOL(trace-malloc,
[  --enable-trace-malloc   Enable malloc tracing],
    NS_TRACE_MALLOC=1,
    NS_TRACE_MALLOC= )
if test "$NS_TRACE_MALLOC"; then
  # Please, Mr. Linker Man, don't take away our symbol names
  MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS=
  USE_ELF_DYNSTR_GC=
  AC_DEFINE(NS_TRACE_MALLOC)
fi
AC_SUBST(NS_TRACE_MALLOC)

dnl ========================================================
dnl = Enable jemalloc
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(jemalloc,
[  --enable-jemalloc       Replace memory allocator with jemalloc],
    MOZ_MEMORY=1,
    MOZ_MEMORY=)

if test "$NS_TRACE_MALLOC"; then
    MOZ_MEMORY=
fi

if test "$MOZ_MEMORY"; then

  dnl Don't try to run compiler tests on Windows  
  if test "$OS_ARCH" = "WINNT"; then
    if test -z "$HAVE_64BIT_OS"; then
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 2)
    else
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 3)
    fi
  else
    AC_CHECK_SIZEOF([int *], [4])
    case "${ac_cv_sizeof_int_p}" in
    4)
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 2)
      ;;
    8)
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 3)
      ;;
    *)
      AC_MSG_ERROR([Unexpected pointer size])
      ;;
    esac
  fi

  AC_DEFINE(MOZ_MEMORY)
  if test "x$MOZ_DEBUG" = "x1"; then
    AC_DEFINE(MOZ_MEMORY_DEBUG)
  fi
  dnl The generic feature tests that determine how to compute ncpus are long and
  dnl complicated.  Therefore, simply define special cpp variables for the
  dnl platforms we have special knowledge of.
  case "${target_os}" in
  darwin*)
    AC_DEFINE(MOZ_MEMORY_DARWIN)
    ;;
  *freebsd*)
    AC_DEFINE(MOZ_MEMORY_BSD)
    ;;
  *linux*)
    AC_DEFINE(MOZ_MEMORY_LINUX)
    ;;
  netbsd*)
    AC_DEFINE(MOZ_MEMORY_BSD)
    ;;
  solaris*)
    AC_DEFINE(MOZ_MEMORY_SOLARIS)
    ;;
  msvc*|mks*|cygwin*|mingw*)
    AC_DEFINE(MOZ_MEMORY_WINDOWS)
    dnl This is sort of awful. Will revisit if we add support for more versions
    if test "$CC_VERSION" != "14.00.50727.762" -a "$CC_VERSION" != "15.00.30729.01"; then
        AC_MSG_ERROR([Building jemalloc requires exactly Visual C++ 2005 SP1 or 2008 SP1 currently.])
    fi
    if test -z "$WIN32_CRT_SRC_DIR"; then
      if test -z "$VCINSTALLDIR" -o ! -d "$VCINSTALLDIR"; then
        AC_MSG_ERROR([When building jemalloc, set WIN32_CRT_SRC_DIR to the path to the Visual C++ CRT source (usually VCINSTALLDIR\crt\src, but VCINSTALLDIR is not set, so I can't autodetect it for you).])
      else
        WIN32_CRT_SRC_DIR="$VCINSTALLDIR\crt\src"
      fi
    fi

    if test ! -d "$WIN32_CRT_SRC_DIR"; then
      AC_MSG_ERROR([Invalid Win32 CRT source directory: ${WIN32_CRT_SRC_DIR}])
    fi
    WIN32_CRT_SRC_DIR=`cd "$WIN32_CRT_SRC_DIR" && pwd -W`
    _objdir_win=`pwd -W`
    WIN32_CUSTOM_CRT_DIR="$_objdir_win/memory/jemalloc/crtsrc/build/intel"
    MOZ_MEMORY_LDFLAGS="-MANIFEST:NO -LIBPATH:\"$WIN32_CUSTOM_CRT_DIR\" -NODEFAULTLIB:msvcrt -NODEFAULTLIB:msvcrtd -NODEFAULTLIB:msvcprt -NODEFAULTLIB:msvcprtd -DEFAULTLIB:mozcrt19 -DEFAULTLIB:mozcpp19"
    dnl Also pass this to NSPR/NSS
    DLLFLAGS="$DLLFLAGS $MOZ_MEMORY_LDFLAGS"
    export DLLFLAGS
    ;;
  *wince)
    AC_DEFINE(MOZ_MEMORY_WINCE)
    AC_DEFINE(MOZ_MEMORY_WINDOWS)
    if test -z "$WINCE_WINDOWS_MOBILE"; then
      AC_DEFINE(MOZ_MEMORY_WINCE6)
    fi
    ;;
  *)
    AC_MSG_ERROR([--enable-jemalloc not supported on ${target}])
    ;;
  esac
fi
AC_SUBST(MOZ_MEMORY)
AC_SUBST(MOZ_MEMORY_LDFLAGS)
AC_SUBST(WIN32_CRT_SRC_DIR)
dnl Need to set this for make because NSS doesn't have configure
AC_SUBST(DLLFLAGS)

dnl ========================================================
dnl = Use malloc wrapper lib
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(wrap-malloc,
[  --enable-wrap-malloc    Wrap malloc calls (gnu linker only)],
    _WRAP_MALLOC=1,
    _WRAP_MALLOC= )

if test -n "$_WRAP_MALLOC"; then
    if test "$GNU_CC"; then
    WRAP_MALLOC_CFLAGS="${LDFLAGS} -Wl,--wrap -Wl,malloc -Wl,--wrap -Wl,free -Wl,--wrap -Wl,realloc -Wl,--wrap -Wl,__builtin_new -Wl,--wrap -Wl,__builtin_vec_new -Wl,--wrap -Wl,__builtin_delete -Wl,--wrap -Wl,__builtin_vec_delete -Wl,--wrap -Wl,PR_Free -Wl,--wrap -Wl,PR_Malloc -Wl,--wrap -Wl,PR_Calloc -Wl,--wrap -Wl,PR_Realloc"
    MKSHLIB='$(CXX) $(DSO_LDOPTS) $(WRAP_MALLOC_CFLAGS) -o $@'
    fi
fi

dnl ========================================================
dnl = Location of malloc wrapper lib
dnl ========================================================
MOZ_ARG_WITH_STRING(wrap-malloc,
[  --with-wrap-malloc=DIR  Location of malloc wrapper library],
    WRAP_MALLOC_LIB=$withval)

dnl ========================================================
dnl = Use TraceVis
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(tracevis,
[  --enable-tracevis       Enable TraceVis tracing tool (default=no)],
    MOZ_TRACEVIS=1,
    MOZ_TRACEVIS= )
if test -n "$MOZ_TRACEVIS"; then
    AC_DEFINE(MOZ_TRACEVIS)
fi

dnl ========================================================
dnl = Use Valgrind
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(valgrind,
[  --enable-valgrind       Enable Valgrind integration hooks (default=no)],
    MOZ_VALGRIND=1,
    MOZ_VALGRIND= )
if test -n "$MOZ_VALGRIND"; then
    AC_CHECK_HEADER([valgrind/valgrind.h], [],
        AC_MSG_ERROR(
            [--enable-valgrind specified but Valgrind is not installed]))
    AC_DEFINE(MOZ_VALGRIND)
fi

dnl ========================================================
dnl = Use Electric Fence
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(efence,
[  --enable-efence         Link with Electric Fence],
    _ENABLE_EFENCE=1,
    _ENABLE_EFENCE= )
if test -n "$_ENABLE_EFENCE"; then
    AC_CHECK_LIB(efence,malloc)
fi

dnl ========================================================
dnl jprof
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(jprof,
[  --enable-jprof          Enable jprof profiling tool (needs mozilla/tools/jprof)],
    MOZ_JPROF=1,
    MOZ_JPROF= )
if test -n "$MOZ_JPROF"; then
    AC_DEFINE(MOZ_JPROF)
fi

dnl ========================================================
dnl shark
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(shark,
[  --enable-shark          Enable shark remote profiling (needs CHUD framework)],
    MOZ_SHARK=1,
    MOZ_SHARK= )
if test -n "$MOZ_SHARK"; then
    AC_DEFINE(MOZ_SHARK)
fi

dnl ========================================================
dnl callgrind
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(callgrind,
[  --enable-callgrind      Enable callgrind profiling],
    MOZ_CALLGRIND=1,
    MOZ_CALLGRIND= )
if test -n "$MOZ_CALLGRIND"; then
    AC_DEFINE(MOZ_CALLGRIND)
fi

dnl ========================================================
dnl vtune
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(vtune,
[  --enable-vtune          Enable vtune profiling],
    MOZ_VTUNE=1,
    MOZ_VTUNE= )
if test -n "$MOZ_VTUNE"; then
    AC_DEFINE(MOZ_VTUNE)
fi

dnl ========================================================
dnl Zealous JavaScript GC
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(gczeal,
[  --enable-gczeal          Enable zealous JavaScript GCing],
    JS_GC_ZEAL=1,
    JS_GC_ZEAL= )
if test -n "$JS_GC_ZEAL"; then
    AC_DEFINE(JS_GC_ZEAL)
fi

dnl ========================================================
dnl = Enable static checking using gcc-dehydra
dnl ========================================================

MOZ_ARG_WITH_STRING(static-checking,
[  --with-static-checking=path/to/gcc_dehydra.so
                            Enable static checking of code using GCC-dehydra],
    DEHYDRA_PATH=$withval,
    DEHYDRA_PATH= )

if test -n "$DEHYDRA_PATH"; then
    if test ! -f "$DEHYDRA_PATH"; then
        AC_MSG_ERROR([The dehydra plugin is not at the specified path.])
    fi
    AC_DEFINE(NS_STATIC_CHECKING)
fi
AC_SUBST(DEHYDRA_PATH)

dnl ========================================================
dnl = Enable stripping of libs & executables
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(strip,
[  --enable-strip          Enable stripping of libs & executables ],
    ENABLE_STRIP=1,
    ENABLE_STRIP= )

dnl ========================================================
dnl = Enable stripping of libs & executables when packaging
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(install-strip,
[  --enable-install-strip  Enable stripping of libs & executables when packaging ],
    PKG_SKIP_STRIP= ,
    PKG_SKIP_STRIP=1)

dnl ========================================================
dnl = --enable-elf-dynstr-gc
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(elf-dynstr-gc,
[  --enable-elf-dynstr-gc  Enable elf dynstr garbage collector (opt builds only)],
    USE_ELF_DYNSTR_GC=1,
    USE_ELF_DYNSTR_GC= )

dnl ========================================================
dnl = --enable-old-abi-compat-wrappers
dnl ========================================================
dnl on x86 linux, the current builds of some popular plugins (notably
dnl flashplayer and real) expect a few builtin symbols from libgcc
dnl which were available in some older versions of gcc.  However,
dnl they're _NOT_ available in newer versions of gcc (eg 3.1), so if
dnl we want those plugin to work with a gcc-3.1 built binary, we need
dnl to provide these symbols.  MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS defaults
dnl to true on x86 linux, and false everywhere else.
dnl

MOZ_ARG_ENABLE_BOOL(old-abi-compat-wrappers,
[  --enable-old-abi-compat-wrappers
                          Support old GCC ABI symbols to ease the pain 
                          of the linux compiler change],
    MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS=1,
    MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS= )
if test "$COMPILE_ENVIRONMENT"; then
if test "$MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS"; then
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS
    AC_CHECK_FUNCS(__builtin_vec_new __builtin_vec_delete __builtin_new __builtin_delete __pure_virtual)
    AC_LANG_RESTORE
    AC_DEFINE(MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS)
fi
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl = 
dnl = Profiling and Instrumenting
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Profiling and Instrumenting)

dnl ========================================================
dnl = Enable timeline service, which provides lightweight
dnl = instrumentation of mozilla for performance measurement.
dnl = Timeline is off by default.
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(timeline,
[  --enable-timeline       Enable timeline services ],
    MOZ_TIMELINE=1,
    MOZ_TIMELINE= )
if test -n "$MOZ_TIMELINE"; then
    AC_DEFINE(MOZ_TIMELINE)
fi

dnl ========================================================
dnl Turn on reflow counting
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(reflow-perf,
[  --enable-reflow-perf    Enable reflow performance tracing],
    MOZ_REFLOW_PERF=1,
    MOZ_REFLOW_PERF= )
if test -n "$MOZ_REFLOW_PERF"; then
    AC_DEFINE(MOZ_REFLOW_PERF)
fi

dnl ========================================================
dnl Enable performance metrics.
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(perf-metrics,
[  --enable-perf-metrics   Enable performance metrics],
    MOZ_PERF_METRICS=1,
    MOZ_PERF_METRICS= )
if test -n "$MOZ_PERF_METRICS"; then
    AC_DEFINE(MOZ_PERF_METRICS)
fi

dnl ========================================================
dnl Enable code size metrics.
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(codesighs,
[  --enable-codesighs      Enable code size analysis tools],
    _ENABLE_CODESIGHS=1,
    _ENABLE_CODESIGHS= )
if test -n "$_ENABLE_CODESIGHS"; then
    if test -d $srcdir/tools/codesighs; then 
        MOZ_MAPINFO=1
    else
        AC_MSG_ERROR([Codesighs directory $srcdir/tools/codesighs required.])
    fi
fi

dnl ========================================================
dnl = Add support for Eazel profiler
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(eazel-profiler-support,
[  --enable-eazel-profiler-support
                          Enable Corel/Eazel profiler support],
    ENABLE_EAZEL_PROFILER=1,
    ENABLE_EAZEL_PROFILER= )
if test -n "$ENABLE_EAZEL_PROFILER"; then
    AC_DEFINE(ENABLE_EAZEL_PROFILER)
    USE_ELF_DYNSTR_GC=
    MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS=
    EAZEL_PROFILER_CFLAGS="-g -O -gdwarf-2 -finstrument-functions -D__NO_STRING_INLINES  -D__NO_MATH_INLINES"
    EAZEL_PROFILER_LIBS="-lprofiler -lpthread"
fi

MOZ_ARG_ENABLE_STRING(profile-modules,
[  --enable-profile-modules
                          Enable/disable profiling for specific modules],
[ MOZ_PROFILE_MODULES=`echo $enableval| sed 's/,/ /g'` ] )

MOZ_ARG_ENABLE_BOOL(insure,
[  --enable-insure         Enable insure++ instrumentation (linux only)],
    _ENABLE_INSURE=1,
    _ENABLE_INSURE= )
if test -n "$_ENABLE_INSURE"; then
    MOZ_INSURE="insure"
    MOZ_INSURIFYING=1
    MOZ_INSURE_DIRS="."
    MOZ_INSURE_EXCLUDE_DIRS="config"
fi

MOZ_ARG_WITH_STRING(insure-dirs,
[  --with-insure-dirs=DIRS
                          Dirs to instrument with insure ],
    MOZ_INSURE_DIRS=$withval )

MOZ_ARG_WITH_STRING(insure-exclude-dirs,
[  --with-insure-exclude-dirs=DIRS
                          Dirs to not instrument with insure ],
    MOZ_INSURE_EXCLUDE_DIRS="config $withval" )

dnl ========================================================
dnl = Support for Quantify (Windows)
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(quantify,
[  --enable-quantify      Enable Quantify support (Windows only) ],
    MOZ_QUANTIFY=1,
    MOZ_QUANTIFY= )

dnl ========================================================
dnl = Support for demangling undefined symbols
dnl ========================================================
if test -z "$SKIP_LIBRARY_CHECKS"; then
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS
    AC_CHECK_FUNCS(__cxa_demangle, HAVE_DEMANGLE=1, HAVE_DEMANGLE=)
    AC_LANG_RESTORE
fi

# Demangle only for debug or trace-malloc builds
MOZ_DEMANGLE_SYMBOLS=
if test "$HAVE_DEMANGLE" -a "$HAVE_GCC3_ABI" && test "$MOZ_DEBUG" -o "$NS_TRACE_MALLOC"; then
    MOZ_DEMANGLE_SYMBOLS=1
    AC_DEFINE(MOZ_DEMANGLE_SYMBOLS)
fi
AC_SUBST(MOZ_DEMANGLE_SYMBOLS)

dnl ========================================================
dnl = Support for gcc stack unwinding (from gcc 3.3)
dnl ========================================================
if test "$HAVE_GCC3_ABI" && test -z "$SKIP_LIBRARY_CHECKS"; then
    AC_CHECK_HEADER(unwind.h, AC_CHECK_FUNCS(_Unwind_Backtrace))
fi

dnl ========================================================
dnl =
dnl = Misc. Options
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Misc. Options)

dnl ========================================================
dnl update xterm title
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(xterm-updates,
[  --enable-xterm-updates  Update XTERM titles with current command.],
    MOZ_UPDATE_XTERM=1,
    MOZ_UPDATE_XTERM= )

dnl =========================================================
dnl = Chrome format
dnl =========================================================
MOZ_ARG_ENABLE_STRING([chrome-format],
[  --enable-chrome-format=jar|flat|both|symlink
                          Select FORMAT of chrome files (default=jar)],
    MOZ_CHROME_FILE_FORMAT=`echo $enableval | tr A-Z a-z`)

if test -z "$MOZ_CHROME_FILE_FORMAT"; then
    MOZ_CHROME_FILE_FORMAT=jar
fi

if test "$MOZ_CHROME_FILE_FORMAT" != "jar" && 
    test "$MOZ_CHROME_FILE_FORMAT" != "flat" &&
    test "$MOZ_CHROME_FILE_FORMAT" != "symlink" &&
    test "$MOZ_CHROME_FILE_FORMAT" != "both"; then
    AC_MSG_ERROR([--enable-chrome-format must be set to either jar, flat, both, or symlink])
fi

dnl ========================================================
dnl = Define default location for MOZILLA_FIVE_HOME
dnl ========================================================
MOZ_ARG_WITH_STRING(default-mozilla-five-home,
[  --with-default-mozilla-five-home
                          Set the default value for MOZILLA_FIVE_HOME],
[ val=`echo $withval`
  AC_DEFINE_UNQUOTED(MOZ_DEFAULT_MOZILLA_FIVE_HOME,"$val") ])

dnl ========================================================
dnl = Location of the mozilla user directory (default is ~/.mozilla).],
dnl ========================================================
MOZ_ARG_WITH_STRING(user-appdir,
[  --with-user-appdir=DIR  Set user-specific appdir (default=.mozilla)],
[ val=`echo $withval`
if echo "$val" | grep "\/" >/dev/null; then
    AC_MSG_ERROR("Homedir must be single relative path.")
else 
    MOZ_USER_DIR="$val"
fi])

AC_DEFINE_UNQUOTED(MOZ_USER_DIR,"$MOZ_USER_DIR")

dnl ========================================================
dnl = Doxygen configuration
dnl ========================================================
dnl Use commas to specify multiple dirs to this arg
MOZ_DOC_INPUT_DIRS='./dist/include ./dist/idl'
MOZ_ARG_WITH_STRING(doc-input-dirs,
[  --with-doc-input-dirs=DIRS
                          Header/idl dirs to create docs from],
[ MOZ_DOC_INPUT_DIRS=`echo "$withval" | sed "s/,/ /g"` ] )
AC_SUBST(MOZ_DOC_INPUT_DIRS)

dnl Use commas to specify multiple dirs to this arg
MOZ_DOC_INCLUDE_DIRS='./dist/include ./dist/include/nspr'
MOZ_ARG_WITH_STRING(doc-include-dirs,
[  --with-doc-include-dirs=DIRS  
                          Include dirs to preprocess doc headers],
[ MOZ_DOC_INCLUDE_DIRS=`echo "$withval" | sed "s/,/ /g"` ] )
AC_SUBST(MOZ_DOC_INCLUDE_DIRS)

MOZ_DOC_OUTPUT_DIR='./dist/docs'
MOZ_ARG_WITH_STRING(doc-output-dir,
[  --with-doc-output-dir=DIR
                          Dir to generate docs into],
[ MOZ_DOC_OUTPUT_DIR=$withval ] )
AC_SUBST(MOZ_DOC_OUTPUT_DIR)

if test -z "$SKIP_COMPILER_CHECKS"; then
dnl ========================================================
dnl =
dnl = Compiler Options
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Compiler Options)

dnl ========================================================
dnl Check for gcc -pipe support
dnl ========================================================
AC_MSG_CHECKING([for gcc -pipe support])
if test -n "$GNU_CC" && test -n "$GNU_CXX" && test -n "$GNU_AS"; then
    echo '#include <stdio.h>' > dummy-hello.c
    echo 'int main() { printf("Hello World\n"); exit(0); }' >> dummy-hello.c
    ${CC} -S dummy-hello.c -o dummy-hello.s 2>&5
    cat dummy-hello.s 2> /dev/null | ${AS_BIN} -o dummy-hello.S - 2>&5
    if test $? = 0; then
        _res_as_stdin="yes"
    else
        _res_as_stdin="no"
    fi
    if test "$_res_as_stdin" = "yes"; then
        _SAVE_CFLAGS=$CFLAGS
        CFLAGS="$CFLAGS -pipe"
        AC_TRY_COMPILE( [ #include <stdio.h> ],
            [printf("Hello World\n");],
            [_res_gcc_pipe="yes"],
            [_res_gcc_pipe="no"] )
        CFLAGS=$_SAVE_CFLAGS
    fi
    if test "$_res_as_stdin" = "yes" && test "$_res_gcc_pipe" = "yes"; then
        _res="yes";
        CFLAGS="$CFLAGS -pipe"
        CXXFLAGS="$CXXFLAGS -pipe"
    else
        _res="no"
    fi
    rm -f dummy-hello.c dummy-hello.s dummy-hello.S dummy-hello a.out
    AC_MSG_RESULT([$_res])
else
    AC_MSG_RESULT([no])
fi

dnl pass -Wno-long-long to the compiler
MOZ_ARG_ENABLE_BOOL(long-long-warning,
[  --enable-long-long-warning 
                          Warn about use of non-ANSI long long type],
    _IGNORE_LONG_LONG_WARNINGS=,
    _IGNORE_LONG_LONG_WARNINGS=1)

if test "$_IGNORE_LONG_LONG_WARNINGS"; then
     _SAVE_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS ${_COMPILER_PREFIX}-Wno-long-long"
     AC_MSG_CHECKING([whether compiler supports -Wno-long-long])
     AC_TRY_COMPILE([], [return(0);], 
	[ _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} ${_COMPILER_PREFIX}-Wno-long-long"
	  _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} ${_COMPILER_PREFIX}-Wno-long-long"
	  result="yes" ], result="no")
     AC_MSG_RESULT([$result])
     CFLAGS="$_SAVE_CFLAGS"
fi

dnl ========================================================
dnl Profile guided optimization
dnl ========================================================
dnl Test for profiling options
dnl Under gcc 3.3, use -fprofile-arcs/-fbranch-probabilities
dnl Under gcc 3.4+, use -fprofile-generate/-fprofile-use

dnl Provide a switch to disable PGO even when called via profiledbuild.
MOZ_ARG_DISABLE_BOOL(profile-guided-optimization,
[  --disable-profile-guided-optimization
                           Don't build with PGO even if called via make profiledbuild],
MOZ_PROFILE_GUIDED_OPTIMIZE_DISABLE=1,
MOZ_PROFILE_GUIDED_OPTIMIZE_DISABLE=)

AC_SUBST(MOZ_PROFILE_GUIDED_OPTIMIZE_DISABLE)

_SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -fprofile-generate"

AC_MSG_CHECKING([whether C compiler supports -fprofile-generate])
AC_TRY_COMPILE([], [return 0;],
               [ PROFILE_GEN_CFLAGS="-fprofile-generate"
                 result="yes" ], result="no")
AC_MSG_RESULT([$result])

if test $result = "yes"; then
  PROFILE_GEN_LDFLAGS="-fprofile-generate"
  PROFILE_USE_CFLAGS="-fprofile-use"
  PROFILE_USE_LDFLAGS="-fprofile-use"
else
  CFLAGS="$_SAVE_CFLAGS -fprofile-arcs"
  AC_MSG_CHECKING([whether C compiler supports -fprofile-arcs])
  AC_TRY_COMPILE([], [return 0;],
                 [ PROFILE_GEN_CFLAGS="-fprofile-arcs"
                   result="yes" ], result="no")
  AC_MSG_RESULT([$result])
  if test $result = "yes"; then
    PROFILE_USE_CFLAGS="-fbranch-probabilities"
  fi
  # don't really care, this is an old GCC
  PROFILE_GEN_LDFLAGS=
  PROFILE_USE_LDFLAGS=
fi

CFLAGS="$_SAVE_CFLAGS"

if test -n "$INTEL_CC"; then
  PROFILE_GEN_CFLAGS="-prof-gen -prof-dir ."
  PROFILE_GEN_LDFLAGS=
  PROFILE_USE_CFLAGS="-prof-use -prof-dir ."
  PROFILE_USE_LDFLAGS=
fi

dnl Sun Studio on Solaris
if test "$SOLARIS_SUNPRO_CC"; then
  PROFILE_GEN_CFLAGS="-xprofile=collect:$_objdir/$enable_application"
  PROFILE_GEN_LDFLAGS="-xprofile=collect:$_objdir/$enable_application"
  if test "$CPU_ARCH" != "sparc"; then
    PROFILE_USE_CFLAGS="-xprofile=use:$_objdir/$enable_application"
    PROFILE_USE_LDFLAGS="-xprofile=use:$_objdir/$enable_application"
  else
    PROFILE_USE_CFLAGS="-xlinkopt=2 -xprofile=use:$_objdir/$enable_application"
    PROFILE_USE_LDFLAGS="-xlinkopt=2 -xprofile=use:$_objdir/$enable_application"
  fi
fi

AC_SUBST(PROFILE_GEN_CFLAGS)
AC_SUBST(PROFILE_GEN_LDFLAGS)
AC_SUBST(PROFILE_USE_CFLAGS)
AC_SUBST(PROFILE_USE_LDFLAGS)

AC_LANG_CPLUSPLUS

dnl ========================================================
dnl Test for -pedantic bustage
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(pedantic,
[  --disable-pedantic      Issue all warnings demanded by strict ANSI C ],
_PEDANTIC= )
if test "$_PEDANTIC"; then
    _SAVE_CXXFLAGS=$CXXFLAGS
    CXXFLAGS="$CXXFLAGS ${_WARNINGS_CXXFLAGS} ${_COMPILER_PREFIX}-pedantic"
    AC_MSG_CHECKING([whether C++ compiler has -pedantic long long bug])
    AC_TRY_COMPILE([$configure_static_assert_macros],
                   [CONFIGURE_STATIC_ASSERT(sizeof(long long) == 8)],
                   result="no", result="yes" )
    AC_MSG_RESULT([$result])
    CXXFLAGS="$_SAVE_CXXFLAGS"

    case "$result" in
    no)
        _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} ${_COMPILER_PREFIX}-pedantic"
        _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} ${_COMPILER_PREFIX}-pedantic"
        ;;
    yes)
        AC_MSG_ERROR([Your compiler appears to have a known bug where long long is miscompiled when using -pedantic.  Reconfigure using --disable-pedantic. ])
        ;;
    esac
fi

dnl ========================================================
dnl Test for correct temporary object destruction order
dnl ========================================================
dnl We want to make sure the compiler follows the C++ spec here as 
dnl xpcom and the string classes depend on it (bug 235381).
AC_MSG_CHECKING([for correct temporary object destruction order])
AC_TRY_RUN([ class A {
             public:  A(int& x) : mValue(x) {}
                      ~A() { mValue--; }
                      operator char**() { return 0; }
             private:  int& mValue;
             };
             void func(char **arg) {}
             int m=2;
             void test() {
                  func(A(m));
                  if (m==1) m = 0;
             }
             int main() {
                 test();
                 return(m);
             }
             ],
     result="yes", result="no", result="maybe")
AC_MSG_RESULT([$result])

if test "$result" = "no"; then
    AC_MSG_ERROR([Your compiler does not follow the C++ specification for temporary object destruction order.])
fi

dnl ========================================================
dnl Autoconf test for gcc 2.7.2.x (and maybe others?) so that we don't
dnl provide non-const forms of the operator== for comparing nsCOMPtrs to
dnl raw pointers in nsCOMPtr.h.  (VC++ has the same bug.)
dnl ========================================================
_SAVE_CXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS ${_WARNINGS_CXXFLAGS}"
AC_CACHE_CHECK(for correct overload resolution with const and templates,
    ac_nscap_nonconst_opeq_bug,
    [AC_TRY_COMPILE([
                      template <class T>
                      class Pointer
                        {
                        public:
                          T* myPtr;
                        };
                      
                      template <class T, class U>
                      int operator==(const Pointer<T>& rhs, U* lhs)
                        {
                          return rhs.myPtr == lhs;
                        }
                      
                      template <class T, class U>
                      int operator==(const Pointer<T>& rhs, const U* lhs)
                        {
                          return rhs.myPtr == lhs;
                        }
                    ],
                    [
                      Pointer<int> foo;
                      const int* bar;
                      return foo == bar;
                    ],
                    ac_nscap_nonconst_opeq_bug="no",
                    ac_nscap_nonconst_opeq_bug="yes")])
CXXFLAGS="$_SAVE_CXXFLAGS"

if test "$ac_nscap_nonconst_opeq_bug" = "yes" ; then
    AC_DEFINE(NSCAP_DONT_PROVIDE_NONCONST_OPEQ)
fi
fi # SKIP_COMPILER_CHECKS

dnl ========================================================
dnl C++ rtti
dnl Should be smarter and check that the compiler does indeed have rtti
dnl ========================================================

MOZ_ARG_ENABLE_BOOL(cpp-rtti,
[  --enable-cpp-rtti       Enable C++ RTTI ],
[ _MOZ_USE_RTTI=1 ],
[ _MOZ_USE_RTTI= ])

if test "$_MOZ_USE_RTTI"; then
   _MOZ_RTTI_FLAGS=$_MOZ_RTTI_FLAGS_ON
else
   _MOZ_RTTI_FLAGS=$_MOZ_RTTI_FLAGS_OFF
fi

AC_SUBST(_MOZ_RTTI_FLAGS_ON)

dnl ========================================================
dnl C++ exceptions (g++/egcs only - for now)
dnl Should be smarter and check that the compiler does indeed have exceptions
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(cpp-exceptions,
[  --enable-cpp-exceptions Enable C++ exceptions ],
[ _MOZ_CPP_EXCEPTIONS=1 ],
[ _MOZ_CPP_EXCEPTIONS= ])

if test "$_MOZ_CPP_EXCEPTIONS"; then
    _MOZ_EXCEPTIONS_FLAGS=$_MOZ_EXCEPTIONS_FLAGS_ON
else
    _MOZ_EXCEPTIONS_FLAGS=$_MOZ_EXCEPTIONS_FLAGS_OFF
fi

AC_SUBST(_MOZ_EXCEPTIONS_FLAGS_ON)

# Irix & OSF native compilers do not like exception declarations 
# when exceptions are disabled
if test -n "$MIPSPRO_CXX" -o -n "$COMPAQ_CXX" -o -n "$VACPP"; then
    AC_DEFINE(CPP_THROW_NEW, [])
else
    AC_DEFINE(CPP_THROW_NEW, [throw()])
fi
AC_LANG_C

dnl ========================================================
dnl =
dnl = Build depencency options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Build dependencies)

dnl ========================================================
dnl = Do not auto generate dependency info
dnl ========================================================
MOZ_AUTO_DEPS=1
MOZ_ARG_DISABLE_BOOL(auto-deps,
[  --disable-auto-deps     Do not automatically generate dependency info],
    MOZ_AUTO_DEPS=,
    MOZ_AUTO_DEPS=1)

if test -n "$MOZ_AUTO_DEPS"; then
dnl ========================================================
dnl = Use mkdepend instead of $CC -MD for dependency generation
dnl ========================================================
_cpp_md_flag=
MOZ_ARG_DISABLE_BOOL(md,
[  --disable-md            Do not use compiler-based dependencies ],
  [_cpp_md_flag=],
  [_cpp_md_flag=1],
  [dnl Default is to turn on -MD if using GNU-compatible compilers
   if test "$GNU_CC" -a "$GNU_CXX" -a "$OS_ARCH" != "WINNT" -a "$OS_ARCH" != "WINCE"; then
     _cpp_md_flag=1
   fi
  dnl Default is to use -xM if using Sun Studio on Solaris
   if test "$SOLARIS_SUNPRO_CC"; then
     _cpp_md_flag=1
   fi])
if test "$_cpp_md_flag"; then
  COMPILER_DEPEND=1
  if test "$OS_ARCH" = "OpenVMS"; then
    _DEPEND_CFLAGS='$(subst =, ,$(filter-out %/.pp,-MM=-MD=-MF=$(MDDEPDIR)/$(basename $(@F)).pp))'
  else
    _DEPEND_CFLAGS='$(filter-out %/.pp,-Wp,-MD,$(MDDEPDIR)/$(basename $(@F)).pp)'
  fi
  dnl Sun Studio on Solaris use -xM instead of -MD, see config/rules.mk
  if test "$SOLARIS_SUNPRO_CC"; then
    _DEPEND_CFLAGS=
  fi
else
  COMPILER_DEPEND=
  _USE_CPP_INCLUDE_FLAG=
  _DEFINES_CFLAGS='$(ACDEFINES) -D_MOZILLA_CONFIG_H_ -DMOZILLA_CLIENT'
  _DEFINES_CXXFLAGS='$(ACDEFINES) -D_MOZILLA_CONFIG_H_ -DMOZILLA_CLIENT'
fi
fi # MOZ_AUTO_DEPS
MDDEPDIR='.deps'
AC_SUBST(MOZ_AUTO_DEPS)
AC_SUBST(COMPILER_DEPEND)
AC_SUBST(MDDEPDIR)


dnl ========================================================
dnl =
dnl = Static Build Options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Static build options)

MOZ_ARG_ENABLE_BOOL(static,
[  --enable-static         Enable building of internal static libs],
    BUILD_STATIC_LIBS=1,
    BUILD_STATIC_LIBS=)

MOZ_ARG_ENABLE_BOOL(libxul,
[  --enable-libxul         Enable building of libxul],
    MOZ_ENABLE_LIBXUL=1,
    MOZ_ENABLE_LIBXUL=)

if test -n "$MOZ_STATIC_BUILD_UNSUPPORTED" -a -n "$BUILD_STATIC_LIBS"; then
	AC_MSG_ERROR([--enable-static is not supported for building $MOZ_APP_NAME. You probably want --enable-libxul.])
fi

if test -n "$MOZ_ENABLE_LIBXUL" -a -n "$BUILD_STATIC_LIBS"; then
	AC_MSG_ERROR([--enable-libxul is not compatible with --enable-static])
fi

if test -n "$MOZ_IPC" -a -z "$MOZ_ENABLE_LIBXUL"; then
    AC_MSG_ERROR([--enable-ipc requires --enable-libxul])
fi

AC_SUBST(LIBXUL_LIBS)

if test -n "$MOZ_ENABLE_LIBXUL"; then
    XPCOM_LIBS="$LIBXUL_LIBS"
    AC_DEFINE(MOZ_ENABLE_LIBXUL)
else
    if test -n "$BUILD_STATIC_LIBS"; then
        AC_DEFINE(MOZ_STATIC_BUILD)
    fi
    XPCOM_LIBS="$DYNAMIC_XPCOM_LIBS"
fi

dnl ========================================================
dnl =
dnl = Standalone module options
dnl = 
dnl ========================================================
MOZ_ARG_HEADER(Standalone module options (Not for building Mozilla))

dnl Check for GLib and libIDL.
dnl ========================================================
case "$target_os" in
msvc*|mks*|cygwin*|mingw*|wince*)
    SKIP_IDL_CHECK="yes"
    ;;
*)
    SKIP_IDL_CHECK="no"
    ;;
esac

if test -z "$COMPILE_ENVIRONMENT"; then
    SKIP_IDL_CHECK="yes"
fi

dnl = Allow users to disable libIDL checking for standalone modules
MOZ_ARG_WITHOUT_BOOL(libIDL,
[  --without-libIDL        Skip check for libIDL (standalone modules only)],
	SKIP_IDL_CHECK="yes")

if test "$SKIP_IDL_CHECK" = "no"
then
    _LIBIDL_FOUND=
    if test "$MACOS_SDK_DIR"; then 
      dnl xpidl, and therefore libIDL, is only needed on the build host.
      dnl Don't build it against the SDK, as that causes problems.
      _MACSAVE_CFLAGS="$CFLAGS"
      _MACSAVE_LIBS="$LIBS"
      _MACSAVE_LDFLAGS="$LDFLAGS"
      _MACSAVE_NEXT_ROOT="$NEXT_ROOT"
      changequote(,)
      CFLAGS=`echo $CFLAGS|sed -E -e "s%((-I|-isystem )${MACOS_SDK_DIR}/usr/(include|lib/gcc)[^ ]*)|-F${MACOS_SDK_DIR}(/System)?/Library/Frameworks[^ ]*|-nostdinc[^ ]*|-isysroot ${MACOS_SDK_DIR}%%g"`
      LIBS=`echo $LIBS|sed -e "s?-L${MACOS_SDK_DIR}/usr/lib[^ ]*??g"`
      LDFLAGS=`echo $LDFLAGS|sed -e "s?-Wl,-syslibroot,${MACOS_SDK_DIR}??g"`
      changequote([,])
      unset NEXT_ROOT
    fi

    if test "$MOZ_ENABLE_GTK2"; then
        PKG_CHECK_MODULES(LIBIDL, libIDL-2.0 >= 0.8.0 glib-2.0 gobject-2.0, _LIBIDL_FOUND=1,_LIBIDL_FOUND=)
    fi
    dnl if no gtk/libIDL1 or gtk2/libIDL2 combination was found, fall back
    dnl to either libIDL1 or libIDL2.
    if test -z "$_LIBIDL_FOUND"; then
        AM_PATH_LIBIDL($LIBIDL_VERSION,_LIBIDL_FOUND=1)
        if test -z "$_LIBIDL_FOUND"; then
            PKG_CHECK_MODULES(LIBIDL, libIDL-2.0 >= 0.8.0,_LIBIDL_FOUND=1)
        fi
    fi
    dnl
    dnl If we don't have a libIDL config program & not cross-compiling, 
    dnl     look for orbit-config instead.
    dnl
    if test -z "$_LIBIDL_FOUND" && test -z "$CROSS_COMPILE"; then
        MOZ_PATH_PROGS(ORBIT_CONFIG, $ORBIT_CONFIG orbit-config)
        if test -n "$ORBIT_CONFIG"; then
            AC_MSG_CHECKING([for ORBit libIDL usability])
        	_ORBIT_CFLAGS=`${ORBIT_CONFIG} client --cflags`
    	    _ORBIT_LIBS=`${ORBIT_CONFIG} client --libs`
            _ORBIT_INC_PATH=`${PERL} -e '{ for $f (@ARGV) { print "$f " if ($f =~ m/^-I/); } }' -- ${_ORBIT_CFLAGS}`
            _ORBIT_LIB_PATH=`${PERL} -e '{ for $f (@ARGV) { print "$f " if ($f =~ m/^-L/); } }' -- ${_ORBIT_LIBS}`
            LIBIDL_CFLAGS="$_ORBIT_INC_PATH"
            LIBIDL_LIBS="$_ORBIT_LIB_PATH -lIDL -lglib"
            LIBIDL_CONFIG=
            _SAVE_CFLAGS="$CFLAGS"
            _SAVE_LIBS="$LIBS"
            CFLAGS="$LIBIDL_CFLAGS $CFLAGS"
            LIBS="$LIBIDL_LIBS $LIBS"
            AC_TRY_RUN([
#include <stdlib.h>
#include <libIDL/IDL.h>
int main() {
  char *s;
  s=strdup(IDL_get_libver_string());
  if(s==NULL) {
    exit(1);
  }
  exit(0);
}
            ], [_LIBIDL_FOUND=1
                result="yes"],
               [LIBIDL_CFLAGS=
                LIBIDL_LIBS=
                result="no"],
               [_LIBIDL_FOUND=1
                result="maybe"] )
            AC_MSG_RESULT($result)
            CFLAGS="$_SAVE_CFLAGS"
            LIBS="$_SAVE_LIBS"
        fi
    fi
    if test -z "$_LIBIDL_FOUND"; then
        AC_MSG_ERROR([libIDL not found.
        libIDL $LIBIDL_VERSION or higher is required.])
    fi
    if test "$MACOS_SDK_DIR"; then
      CFLAGS="$_MACSAVE_CFLAGS"
      LIBS="$_MACSAVE_LIBS"
      LDFLAGS="$_MACSAVE_LDFLAGS"
      if test -n "$_MACSAVE_NEXT_ROOT" ; then
        export NEXT_ROOT="$_MACSAVE_NEXT_ROOT"
      fi
    fi
fi

if test -n "$CROSS_COMPILE"; then
     if test -z "$HOST_LIBIDL_CONFIG"; then
        HOST_LIBIDL_CONFIG="$LIBIDL_CONFIG"
    fi
    if test -n "$HOST_LIBIDL_CONFIG" && test "$HOST_LIBIDL_CONFIG" != "no"; then
        HOST_LIBIDL_CFLAGS=`${HOST_LIBIDL_CONFIG} --cflags`
        HOST_LIBIDL_LIBS=`${HOST_LIBIDL_CONFIG} --libs`
    else
        HOST_LIBIDL_CFLAGS="$LIBIDL_CFLAGS"
        HOST_LIBIDL_LIBS="$LIBIDL_LIBS"
    fi
fi

if test -z "$SKIP_PATH_CHECKS"; then
if test -z "${GLIB_CFLAGS}" || test -z "${GLIB_LIBS}" ; then
    if test "$MOZ_ENABLE_GTK2" || test "$USE_ELF_DYNSTR_GC" ; then
        PKG_CHECK_MODULES(GLIB, glib-2.0 >= 1.3.7 gobject-2.0)
    else
        AM_PATH_GLIB(${GLIB_VERSION})
    fi
fi
fi

if test -z "${GLIB_GMODULE_LIBS}" -a -n "${GLIB_CONFIG}"; then
    GLIB_GMODULE_LIBS=`$GLIB_CONFIG gmodule --libs`
fi

AC_SUBST(LIBIDL_CFLAGS)
AC_SUBST(LIBIDL_LIBS)
AC_SUBST(STATIC_LIBIDL)
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
AC_SUBST(GLIB_GMODULE_LIBS)
AC_SUBST(HOST_LIBIDL_CONFIG)
AC_SUBST(HOST_LIBIDL_CFLAGS)
AC_SUBST(HOST_LIBIDL_LIBS)

dnl ========================================================
dnl Check for cairo
dnl ========================================================
MOZ_CAIRO_CFLAGS='-I$(LIBXUL_DIST)/include/cairo'

MOZ_TREE_CAIRO=1
MOZ_ARG_ENABLE_BOOL(system-cairo,
[ --enable-system-cairo Use system cairo (located with pkgconfig)],
MOZ_TREE_CAIRO=,
MOZ_TREE_CAIRO=1 )

# Check for headers defining standard int types.
AC_CHECK_HEADERS(stdint.h inttypes.h sys/int_types.h)

if test "$MOZ_TREE_CAIRO"; then
    AC_DEFINE(MOZ_TREE_CAIRO)

    # For now we assume that we will have a uint64_t available through
    # one of the above headers or mozstdint.h.
    AC_DEFINE(HAVE_UINT64_T)

    # Define macros for cairo-features.h
    if test "$MOZ_X11"; then
        XLIB_SURFACE_FEATURE="#define CAIRO_HAS_XLIB_SURFACE 1"
        XLIB_XRENDER_SURFACE_FEATURE="#define CAIRO_HAS_XLIB_XRENDER_SURFACE 1"
        PS_SURFACE_FEATURE="#define CAIRO_HAS_PS_SURFACE 1"
        PDF_SURFACE_FEATURE="#define CAIRO_HAS_PDF_SURFACE 1"
        FT_FONT_FEATURE="#define CAIRO_HAS_FT_FONT 1"
        MOZ_ENABLE_CAIRO_FT=1
        CAIRO_FT_CFLAGS="$FT2_CFLAGS"
    fi
    if test "$MOZ_WIDGET_TOOLKIT" = "qt"; then
        QPAINTER_SURFACE_FEATURE="#define CAIRO_HAS_QPAINTER_SURFACE 1"
    fi
    if test "$MOZ_WIDGET_TOOLKIT" = "mac" -o "$MOZ_WIDGET_TOOLKIT" = "cocoa"; then
        QUARTZ_SURFACE_FEATURE="#define CAIRO_HAS_QUARTZ_SURFACE 1"
        QUARTZ_IMAGE_SURFACE_FEATURE="#define CAIRO_HAS_QUARTZ_IMAGE_SURFACE 1"
        QUARTZ_FONT_FEATURE="#define CAIRO_HAS_QUARTZ_FONT 1"
    fi
    if test "$MOZ_WIDGET_TOOLKIT" = "windows"; then
        WIN32_SURFACE_FEATURE="#define CAIRO_HAS_WIN32_SURFACE 1"
        if test -z "$WINCE"; then
            WIN32_FONT_FEATURE="#define CAIRO_HAS_WIN32_FONT 1"
        else
            WIN32_FONT_FEATURE=
        fi

        AC_TRY_COMPILE([#include <ddraw.h>], [int foo = DDLOCK_WAITNOTBUSY;], HAS_DDRAW=1, HAS_DDRAW=)
        if test -z "$HAS_DDRAW"; then
            AC_MSG_WARN([DirectDraw ddraw.h header not found or it's missing DDLOCK_WAITNOTBUSY, disabling DirectDraw surface.  If you have an older SDK (such as the CE5 SDK), try copying in ddraw.lib and ddraw.h from the WM6 SDK.])
            DDRAW_SURFACE_FEATURE=
        else
            DDRAW_SURFACE_FEATURE="#define CAIRO_HAS_DDRAW_SURFACE 1"
        fi

        if test -z "$OGLES_SDK_DIR"; then
            OGLES_SURFACE_FEATURE=
        else
            AC_TRY_COMPILE([
              #include <EGL/egl.h>
              #include <EGL/eglext.h>
              #include <GLES2/gl2.h>
              #include <GLES2/gl2ext.h>
            ], [ EGLDisplay _cairo_ddraw_egl_dpy = EGL_NO_DISPLAY;], HAS_OGLES=1, HAS_OGLES=)
            if test -z "$HAS_OGLES"; then
              AC_MSG_WARN([OpenGL ES2 headers not found, disabling OpenGL acceleration surfaces.])
              OGLES_SURFACE_FEATURE=
            else
              OGLES_SURFACE_FEATURE="#define CAIRO_DDRAW_USE_GL 1"
            fi
        fi

        PDF_SURFACE_FEATURE="#define CAIRO_HAS_PDF_SURFACE 1"
    fi
    if test "$MOZ_WIDGET_TOOLKIT" = "os2"; then
        OS2_SURFACE_FEATURE="#define CAIRO_HAS_OS2_SURFACE 1"
        FT_FONT_FEATURE="#define CAIRO_HAS_FT_FONT 1"
        PDF_SURFACE_FEATURE="#define CAIRO_HAS_PDF_SURFACE 1"
        MOZ_ENABLE_CAIRO_FT=1
        CAIRO_FT_CFLAGS="-I${MZFTCFGFT2}/include"
        CAIRO_FT_LIBS="-L${MZFTCFGFT2}/lib -lmozft -lmzfntcfg"
    fi
    if test "$MOZ_WIDGET_TOOLKIT" = "beos"; then
        PKG_CHECK_MODULES(CAIRO_FT, fontconfig freetype2)
        BEOS_SURFACE_FEATURE="#define CAIRO_HAS_BEOS_SURFACE 1"
        FT_FONT_FEATURE="#define CAIRO_HAS_FT_FONT 1"
        MOZ_ENABLE_CAIRO_FT=1
    fi
    if test "$USE_FC_FREETYPE"; then
        FC_FONT_FEATURE="#define CAIRO_HAS_FC_FONT 1"
    fi
    AC_SUBST(MOZ_ENABLE_CAIRO_FT)
    AC_SUBST(CAIRO_FT_CFLAGS)
    AC_SUBST(HAS_OGLES)

    if test "$MOZ_DEBUG"; then
      SANITY_CHECKING_FEATURE="#define CAIRO_DO_SANITY_CHECKING 1"
    else
      SANITY_CHECKING_FEATURE="#undef CAIRO_DO_SANITY_CHECKING"
    fi

    PNG_FUNCTIONS_FEATURE="#define CAIRO_HAS_PNG_FUNCTIONS 1"

    AC_SUBST(PS_SURFACE_FEATURE)
    AC_SUBST(PDF_SURFACE_FEATURE)
    AC_SUBST(SVG_SURFACE_FEATURE)
    AC_SUBST(XLIB_SURFACE_FEATURE)
    AC_SUBST(XLIB_XRENDER_SURFACE_FEATURE)
    AC_SUBST(QUARTZ_SURFACE_FEATURE)
    AC_SUBST(QUARTZ_IMAGE_SURFACE_FEATURE)
    AC_SUBST(XCB_SURFACE_FEATURE)
    AC_SUBST(WIN32_SURFACE_FEATURE)
    AC_SUBST(DDRAW_SURFACE_FEATURE)
    AC_SUBST(OGLES_SURFACE_FEATURE)    
    AC_SUBST(OS2_SURFACE_FEATURE)
    AC_SUBST(BEOS_SURFACE_FEATURE)
    AC_SUBST(DIRECTFB_SURFACE_FEATURE)
    AC_SUBST(FT_FONT_FEATURE)
    AC_SUBST(FC_FONT_FEATURE)
    AC_SUBST(WIN32_FONT_FEATURE)
    AC_SUBST(QUARTZ_FONT_FEATURE)
    AC_SUBST(PNG_FUNCTIONS_FEATURE)
    AC_SUBST(QPAINTER_SURFACE_FEATURE)

    if test "$_WIN32_MSVC"; then
        MOZ_CAIRO_LIBS='$(DEPTH)/gfx/cairo/cairo/src/mozcairo.lib $(DEPTH)/gfx/cairo/libpixman/src/mozlibpixman.lib'
    else
        MOZ_CAIRO_LIBS='$(DEPTH)/gfx/cairo/cairo/src/$(LIB_PREFIX)mozcairo.$(LIB_SUFFIX) $(DEPTH)/gfx/cairo/libpixman/src/$(LIB_PREFIX)mozlibpixman.$(LIB_SUFFIX)'" $CAIRO_FT_LIBS"

        if test "$MOZ_X11"; then
            MOZ_CAIRO_LIBS="$MOZ_CAIRO_LIBS $XLDFLAGS -lXrender -lfreetype -lfontconfig"
        fi
    fi

    CAIRO_FEATURES_H=gfx/cairo/cairo/src/cairo-features.h
    mv -f $CAIRO_FEATURES_H "$CAIRO_FEATURES_H".orig 2> /dev/null

else
   PKG_CHECK_MODULES(CAIRO, cairo >= $CAIRO_VERSION pixman-1 freetype2 fontconfig)
   MOZ_CAIRO_CFLAGS=$CAIRO_CFLAGS
   MOZ_CAIRO_LIBS=$CAIRO_LIBS
   if test "$MOZ_X11"; then
        PKG_CHECK_MODULES(CAIRO_XRENDER, cairo-xlib-xrender >= $CAIRO_VERSION)
        MOZ_CAIRO_LIBS="$MOZ_CAIRO_LIBS $XLDFLAGS $CAIRO_XRENDER_LIBS"
        MOZ_CAIRO_CFLAGS="$MOZ_CAIRO_CFLAGS $CAIRO_XRENDER_CFLAGS"
   fi
fi

AC_SUBST(MOZ_TREE_CAIRO)
AC_SUBST(MOZ_CAIRO_CFLAGS)
AC_SUBST(MOZ_CAIRO_LIBS)

dnl qcms
dnl ========================================================

QCMS_LIBS='$(DEPTH)/gfx/qcms/$(LIB_PREFIX)mozqcms.$(LIB_SUFFIX)'
AC_SUBST(QCMS_LIBS)

dnl ========================================================
dnl disable xul
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(xul,
[  --disable-xul           Disable XUL],
    MOZ_XUL= )
if test "$MOZ_XUL"; then
  AC_DEFINE(MOZ_XUL)
else
  dnl remove extensions that require XUL
  MOZ_EXTENSIONS=`echo $MOZ_EXTENSIONS | sed -e 's/inspector//' -e 's/venkman//' -e 's/irc//' -e 's/tasks//'`
fi

AC_SUBST(MOZ_XUL)

dnl ========================================================
dnl disable profile locking
dnl   do no use this in applications that can have more than
dnl   one process accessing the profile directory.
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(profilelocking,
[  --disable-profilelocking           Disable profile locking],
    MOZ_PROFILELOCKING=,
    MOZ_PROFILELOCKING=1 )
if test "$MOZ_PROFILELOCKING"; then
  AC_DEFINE(MOZ_PROFILELOCKING)
fi

dnl ========================================================
dnl disable rdf services
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(rdf,
[  --disable-rdf           Disable RDF],
    MOZ_RDF= )
if test "$MOZ_RDF"; then
  AC_DEFINE(MOZ_RDF)
fi

AC_SUBST(MOZ_RDF)

dnl ========================================================
dnl necko configuration options
dnl ========================================================

dnl
dnl option to disable various necko protocols
dnl
MOZ_ARG_ENABLE_STRING(necko-protocols,
[  --enable-necko-protocols[={http,ftp,default,all,none}]
                          Enable/disable specific protocol handlers],
[ for option in `echo $enableval | sed 's/,/ /g'`; do
    if test "$option" = "yes" || test "$option" = "all"; then
        NECKO_PROTOCOLS="$NECKO_PROTOCOLS $NECKO_PROTOCOLS_DEFAULT"
    elif test "$option" = "no" || test "$option" = "none"; then
        NECKO_PROTOCOLS=""
    elif test "$option" = "default"; then
        NECKO_PROTOCOLS="$NECKO_PROTOCOLS $NECKO_PROTOCOLS_DEFAULT"
    elif test `echo "$option" | grep -c \^-` != 0; then
        option=`echo $option | sed 's/^-//'`
        NECKO_PROTOCOLS=`echo "$NECKO_PROTOCOLS" | sed "s/ ${option}//"`
    else
        NECKO_PROTOCOLS="$NECKO_PROTOCOLS $option"
    fi
done],
    NECKO_PROTOCOLS="$NECKO_PROTOCOLS_DEFAULT")
dnl Remove dupes
NECKO_PROTOCOLS=`${PERL} ${srcdir}/build/unix/uniq.pl ${NECKO_PROTOCOLS}`
AC_SUBST(NECKO_PROTOCOLS)
for p in $NECKO_PROTOCOLS; do
    AC_DEFINE_UNQUOTED(NECKO_PROTOCOL_$p)
done

dnl
dnl option to disable necko's disk cache
dnl
MOZ_ARG_DISABLE_BOOL(necko-disk-cache,
[  --disable-necko-disk-cache
                          Disable necko disk cache],
    NECKO_DISK_CACHE=,
    NECKO_DISK_CACHE=1)
AC_SUBST(NECKO_DISK_CACHE)
if test "$NECKO_DISK_CACHE"; then
    AC_DEFINE(NECKO_DISK_CACHE)
fi

dnl
dnl option to disable necko's wifi scanner
dnl
MOZ_ARG_DISABLE_BOOL(necko-wifi,
[  --disable-necko-wifi   Disable necko wifi scanner],
    NECKO_WIFI=,
    NECKO_WIFI=1
)

if test "$OS_ARCH" = "OS2"; then
  dnl OS/2 implementation of Necko-WiFi support will be added in bug 506566
  NECKO_WIFI=
fi
if test "$NECKO_WIFI" -a \
        "$OS_ARCH" != "Linux" -a \
        "$OS_ARCH" != "Darwin" -a \
        "$OS_ARCH" != "WINNT" -a \
        "$OS_ARCH" != "WINCE"; then
  AC_MSG_ERROR([Necko WiFi scanning not supported on your platform, use --disable-necko-wifi])
fi

if test -z "$SKIP_LIBRARY_CHECKS" -a "$NECKO_WIFI" -a "$OS_ARCH" = "Linux"
then
  AC_CHECK_HEADER([iwlib.h])
  if test "$ac_cv_header_iwlib_h" != "yes"; then
    AC_MSG_ERROR([Can't find header iwlib.h for Necko WiFi scanning (might be in package libiw-dev (Ubuntu) or wireless-tools-devel (Fedora)); use --disable-necko-wifi to disable])
  fi
fi

if test "$NECKO_WIFI"; then
  AC_DEFINE(NECKO_WIFI)
fi
AC_SUBST(NECKO_WIFI)

dnl
dnl option to disable cookies
dnl
MOZ_ARG_DISABLE_BOOL(cookies,
[  --disable-cookies       Disable cookie support],
    NECKO_COOKIES=,
    NECKO_COOKIES=1)
AC_SUBST(NECKO_COOKIES)
if test "$NECKO_COOKIES"; then
    AC_DEFINE(NECKO_COOKIES)
fi

dnl
dnl Build jsctypes on the platforms we can.
dnl
AC_SUBST(BUILD_CTYPES)
if test "$OS_TARGET" != "WINCE" -o `echo $OS_TEST | grep -ic arm` != 1; then
  BUILD_CTYPES=1
  AC_DEFINE(BUILD_CTYPES)
fi

dnl NECKO_ configuration options are not global
_NON_GLOBAL_ACDEFINES="$_NON_GLOBAL_ACDEFINES NECKO_"

dnl Only build Mork if it's required
AC_SUBST(MOZ_MORK)
if test "$MOZ_MORK"; then
  AC_DEFINE(MOZ_MORK)
fi

dnl Build the lightweight Mork reader if required
AC_SUBST(MOZ_MORKREADER)
if test "$MOZ_MORKREADER"; then
  AC_DEFINE(MOZ_MORKREADER)
fi

dnl ========================================================
if test "$MOZ_DEBUG" || test "$NS_TRACE_MALLOC"; then
    MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS=
fi

dnl ========================================================
dnl =
dnl = Maintainer debug option (no --enable equivalent)
dnl =
dnl ========================================================

AC_SUBST(AR)
AC_SUBST(AR_FLAGS)
AC_SUBST(AR_LIST)
AC_SUBST(AR_EXTRACT)
AC_SUBST(AR_DELETE)
AC_SUBST(AS)
AC_SUBST(ASFLAGS)
AC_SUBST(AS_DASH_C_FLAG)
AC_SUBST(LD)
AC_SUBST(RC)
AC_SUBST(RCFLAGS)
AC_SUBST(WINDRES)
AC_SUBST(USE_SHORT_LIBNAME)
AC_SUBST(IMPLIB)
AC_SUBST(FILTER)
AC_SUBST(BIN_FLAGS)
AC_SUBST(NS_USE_NATIVE)
AC_SUBST(MOZ_WIDGET_TOOLKIT)
AC_SUBST(MOZ_GFX_TOOLKIT)
AC_SUBST(MOZ_UPDATE_XTERM)
AC_SUBST(MINIMO)
AC_SUBST(MOZ_PLATFORM_MAEMO)
AC_SUBST(MOZ_AUTH_EXTENSION)
AC_SUBST(MOZ_MATHML)
AC_SUBST(MOZ_PERMISSIONS)
AC_SUBST(MOZ_XTF)
AC_SUBST(MOZ_NO_INSPECTOR_APIS)
AC_SUBST(MOZ_PREF_EXTENSIONS)
AC_SUBST(MOZ_SVG)
AC_SUBST(MOZ_SMIL)
AC_SUBST(MOZ_XSLT_STANDALONE)
AC_SUBST(MOZ_JS_LIBS)
AC_SUBST(MOZ_PSM)
AC_SUBST(MOZ_DEBUG)
AC_SUBST(MOZ_DEBUG_MODULES)
AC_SUBST(MOZ_PROFILE_MODULES)
AC_SUBST(MOZ_DEBUG_ENABLE_DEFS)
AC_SUBST(MOZ_DEBUG_DISABLE_DEFS)
AC_SUBST(MOZ_DEBUG_FLAGS)
AC_SUBST(MOZ_DEBUG_LDFLAGS)
AC_SUBST(WARNINGS_AS_ERRORS)
AC_SUBST(MOZ_DBGRINFO_MODULES)
AC_SUBST(MOZ_EXTENSIONS)
AC_SUBST(MOZ_IMG_DECODERS)
AC_SUBST(MOZ_IMG_ENCODERS)
AC_SUBST(MOZ_JSDEBUGGER)
AC_SUBST(MOZ_NO_XPCOM_OBSOLETE)
AC_SUBST(MOZ_PLUGINS)
AC_SUBST(ENABLE_EAZEL_PROFILER)
AC_SUBST(EAZEL_PROFILER_CFLAGS)
AC_SUBST(EAZEL_PROFILER_LIBS)
AC_SUBST(MOZ_PERF_METRICS)
AC_SUBST(GC_LEAK_DETECTOR)
AC_SUBST(MOZ_LOG_REFCNT)
AC_SUBST(MOZ_LEAKY)
AC_SUBST(MOZ_JPROF)
AC_SUBST(MOZ_SHARK)
AC_SUBST(MOZ_CALLGRIND)
AC_SUBST(MOZ_VTUNE)
AC_SUBST(MOZ_XPCTOOLS)
AC_SUBST(MOZ_JSLOADER)
AC_SUBST(MOZ_USE_NATIVE_UCONV)
AC_SUBST(MOZ_INSURE)
AC_SUBST(MOZ_INSURE_DIRS)
AC_SUBST(MOZ_INSURE_EXCLUDE_DIRS)
AC_SUBST(MOZ_QUANTIFY)
AC_SUBST(MOZ_INSURIFYING)
AC_SUBST(LIBICONV)
AC_SUBST(MOZ_PLACES)
AC_SUBST(MOZ_PLACES_BOOKMARKS)
AC_SUBST(MOZ_STORAGE)
AC_SUBST(MOZ_FEEDS)
AC_SUBST(NS_PRINTING)

AC_SUBST(MOZ_JAVAXPCOM)
AC_SUBST(JAVA_INCLUDE_PATH)
AC_SUBST(JAVA)
AC_SUBST(JAVAC)
AC_SUBST(JAR)

AC_SUBST(MOZ_PROFILELOCKING)

AC_SUBST(HAVE_XIE)
AC_SUBST(MOZ_XIE_LIBS)
AC_SUBST(MOZ_ENABLE_POSTSCRIPT)

AC_SUBST(XPCOM_USE_LEA)
AC_SUBST(BUILD_STATIC_LIBS)
AC_SUBST(MOZ_ENABLE_LIBXUL)
AC_SUBST(ENABLE_TESTS)
AC_SUBST(IBMBIDI)
AC_SUBST(MOZ_UNIVERSALCHARDET)
AC_SUBST(ACCESSIBILITY)
AC_SUBST(MOZ_XPINSTALL)
AC_SUBST(MOZ_VIEW_SOURCE)
AC_SUBST(MOZ_SPELLCHECK)
AC_SUBST(MOZ_XPFE_COMPONENTS)
AC_SUBST(MOZ_USER_DIR)
AC_SUBST(MOZ_CRASHREPORTER)

AC_SUBST(ENABLE_STRIP)
AC_SUBST(PKG_SKIP_STRIP)
AC_SUBST(USE_ELF_DYNSTR_GC)
AC_SUBST(INCREMENTAL_LINKER)
AC_SUBST(MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS)
AC_SUBST(MOZ_COMPONENT_NSPR_LIBS)
AC_SUBST(MOZ_XPCOM_OBSOLETE_LIBS)

AC_SUBST(MOZ_FIX_LINK_PATHS)
AC_SUBST(XPCOM_LIBS)
AC_SUBST(XPCOM_FROZEN_LDOPTS)
AC_SUBST(XPCOM_GLUE_LDOPTS)
AC_SUBST(XPCOM_STANDALONE_GLUE_LDOPTS)

AC_SUBST(USE_DEPENDENT_LIBS)

AC_SUBST(MOZ_BUILD_ROOT)
AC_SUBST(MOZ_OS2_TOOLS)
AC_SUBST(MOZ_OS2_USE_DECLSPEC)

AC_SUBST(MOZ_POST_DSO_LIB_COMMAND)
AC_SUBST(MOZ_POST_PROGRAM_COMMAND)
AC_SUBST(MOZ_TIMELINE)
AC_SUBST(OGLES_SDK_DIR)

AC_SUBST(MOZ_APP_NAME)
AC_SUBST(MOZ_APP_DISPLAYNAME)
AC_SUBST(MOZ_APP_VERSION)
AC_SUBST(MOZ_APP_UA_EXTRA)
AC_SUBST(FIREFOX_VERSION)

AC_SUBST(MOZ_PKG_SPECIAL)

AC_SUBST(MOZILLA_OFFICIAL)

dnl win32 options
AC_SUBST(MOZ_DEBUG_SYMBOLS)
AC_SUBST(MOZ_MAPINFO)
AC_SUBST(MOZ_BROWSE_INFO)
AC_SUBST(MOZ_TOOLS_DIR)
AC_SUBST(CYGWIN_WRAPPER)
AC_SUBST(AS_PERL)
AC_SUBST(WIN32_REDIST_DIR)
AC_SUBST(PYTHON)

AC_SUBST(WINCE)
AC_SUBST(WINCE_SDK_DIR)
AC_SUBST(WINCE_WINDOWS_MOBILE)

dnl Echo the CFLAGS to remove extra whitespace.
CFLAGS=`echo \
	$_WARNINGS_CFLAGS \
	$CFLAGS`

CXXFLAGS=`echo \
	$_MOZ_RTTI_FLAGS \
	$_MOZ_EXCEPTIONS_FLAGS \
	$_WARNINGS_CXXFLAGS \
	$CXXFLAGS`

COMPILE_CFLAGS=`echo \
    $_DEFINES_CFLAGS \
	$_DEPEND_CFLAGS \
    $COMPILE_CFLAGS`

COMPILE_CXXFLAGS=`echo \
    $_DEFINES_CXXFLAGS \
	$_DEPEND_CFLAGS \
    $COMPILE_CXXFLAGS`

AC_SUBST(SYSTEM_MAKEDEPEND)
AC_SUBST(SYSTEM_LIBXUL)
AC_SUBST(SYSTEM_JPEG)
AC_SUBST(SYSTEM_PNG)
AC_SUBST(SYSTEM_ZLIB)
AC_SUBST(SYSTEM_BZ2)

AC_SUBST(JPEG_CFLAGS)
AC_SUBST(JPEG_LIBS)
AC_SUBST(ZLIB_CFLAGS)
AC_SUBST(ZLIB_LIBS)
AC_SUBST(BZ2_CFLAGS)
AC_SUBST(BZ2_LIBS)
AC_SUBST(PNG_CFLAGS)
AC_SUBST(PNG_LIBS)

AC_SUBST(MOZ_JPEG_CFLAGS)
AC_SUBST(MOZ_JPEG_LIBS)
AC_SUBST(MOZ_ZLIB_CFLAGS)
AC_SUBST(MOZ_ZLIB_LIBS)
AC_SUBST(MOZ_BZ2_CFLAGS)
AC_SUBST(MOZ_BZ2_LIBS)
AC_SUBST(MOZ_PNG_CFLAGS)
AC_SUBST(MOZ_PNG_LIBS)

AC_SUBST(NSPR_CFLAGS)
AC_SUBST(NSPR_LIBS)
AC_SUBST(MOZ_NATIVE_NSPR)

AC_SUBST(NSS_CFLAGS)
AC_SUBST(NSS_LIBS)
AC_SUBST(NSS_DEP_LIBS)
AC_SUBST(MOZ_NATIVE_NSS)
AC_SUBST(NSS_DISABLE_DBM)

AC_SUBST(CFLAGS)
AC_SUBST(CXXFLAGS)
AC_SUBST(CPPFLAGS)
AC_SUBST(COMPILE_CFLAGS)
AC_SUBST(COMPILE_CXXFLAGS)
AC_SUBST(LDFLAGS)
AC_SUBST(LIBS)
AC_SUBST(CROSS_COMPILE)
AC_SUBST(WCHAR_CFLAGS)

AC_SUBST(HOST_CC)
AC_SUBST(HOST_CXX)
AC_SUBST(HOST_CFLAGS)
AC_SUBST(HOST_CXXFLAGS)
AC_SUBST(HOST_OPTIMIZE_FLAGS)
AC_SUBST(HOST_AR)
AC_SUBST(HOST_AR_FLAGS)
AC_SUBST(HOST_LD)
AC_SUBST(HOST_RANLIB)
AC_SUBST(HOST_NSPR_MDCPUCFG)
AC_SUBST(HOST_BIN_SUFFIX)
AC_SUBST(HOST_OS_ARCH)

AC_SUBST(TARGET_CPU)
AC_SUBST(TARGET_VENDOR)
AC_SUBST(TARGET_OS)
AC_SUBST(TARGET_NSPR_MDCPUCFG)
AC_SUBST(TARGET_MD_ARCH)
AC_SUBST(TARGET_XPCOM_ABI)
AC_SUBST(OS_TARGET)
AC_SUBST(OS_ARCH)
AC_SUBST(OS_RELEASE)
AC_SUBST(OS_TEST)

AC_SUBST(MOZ_DISABLE_JAR_PACKAGING)
AC_SUBST(MOZ_CHROME_FILE_FORMAT)

AC_SUBST(WRAP_MALLOC_CFLAGS)
AC_SUBST(WRAP_MALLOC_LIB)
AC_SUBST(MKSHLIB)
AC_SUBST(MKCSHLIB)
AC_SUBST(MKSHLIB_FORCE_ALL)
AC_SUBST(MKSHLIB_UNFORCE_ALL)
AC_SUBST(DSO_CFLAGS)
AC_SUBST(DSO_PIC_CFLAGS)
AC_SUBST(DSO_LDOPTS)
AC_SUBST(LIB_PREFIX)
AC_SUBST(DLL_PREFIX)
AC_SUBST(DLL_SUFFIX)
AC_DEFINE_UNQUOTED(MOZ_DLL_SUFFIX, "$DLL_SUFFIX")
AC_SUBST(LIB_SUFFIX)
AC_SUBST(OBJ_SUFFIX)
AC_SUBST(BIN_SUFFIX)
AC_SUBST(ASM_SUFFIX)
AC_SUBST(IMPORT_LIB_SUFFIX)
AC_SUBST(USE_N32)
AC_SUBST(CC_VERSION)
AC_SUBST(CXX_VERSION)
AC_SUBST(MSMANIFEST_TOOL)

if test "$USING_HCC"; then
   CC='${topsrcdir}/build/hcc'
   CC="$CC '$_OLDCC'"
   CXX='${topsrcdir}/build/hcpp'
   CXX="$CXX '$_OLDCXX'"
   AC_SUBST(CC)
   AC_SUBST(CXX)
fi

dnl Check for missing components
if test "$COMPILE_ENVIRONMENT"; then
if test "$MOZ_X11"; then
    dnl ====================================================
    dnl = Check if X headers exist
    dnl ====================================================
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $XCFLAGS"
    AC_TRY_COMPILE([
        #include <stdio.h>
        #include <stdlib.h>
        #include <X11/Xlib.h>
        #include <X11/Intrinsic.h>
    ],
    [
        Display *dpy = 0;
        if ((dpy = XOpenDisplay(NULL)) == NULL) {
            fprintf(stderr, ": can't open %s\n", XDisplayName(NULL));
            exit(1);
        }
    ], [], 
    [ AC_MSG_ERROR([Could not compile basic X program.]) ])
    CFLAGS="$_SAVE_CFLAGS"

    if test ! -z "$MISSING_X"; then
        AC_MSG_ERROR([ Could not find the following X libraries: $MISSING_X ]);
    fi

fi # MOZ_X11
fi # COMPILE_ENVIRONMENT

if test "$USE_FC_FREETYPE"; then
    if test "$COMPILE_ENVIRONMENT"; then
    	_SAVE_CPPFLAGS="$CPPFLAGS"
    	CPPFLAGS="$CPPFLAGS $FT2_CFLAGS $XCFLAGS"
        AC_CHECK_HEADERS(fontconfig/fcfreetype.h, , 
            [AC_MSG_ERROR(Can't find header fontconfig/fcfreetype.h.)])
    	CPPFLAGS="$_SAVE_CPPFLAGS"
    else
        AC_DEFINE(HAVE_FONTCONFIG_FCFREETYPE_H)
    fi
fi

dnl Set various defines and substitutions
dnl ========================================================

if test "$OS_ARCH" = "BeOS"; then
  AC_DEFINE(XP_BEOS)
  MOZ_MOVEMAIL=1
elif test "$OS_ARCH" = "Darwin"; then
  AC_DEFINE(XP_UNIX)
  AC_DEFINE(UNIX_ASYNC_DNS)
  MOZ_MOVEMAIL=1
elif test "$OS_ARCH" = "OpenVMS"; then
  AC_DEFINE(XP_UNIX)
elif test "$OS_ARCH" != "WINNT" -a "$OS_ARCH" != "OS2" -a "$OS_ARCH" != "WINCE"; then
  AC_DEFINE(XP_UNIX)
  AC_DEFINE(UNIX_ASYNC_DNS)
  MOZ_MOVEMAIL=1
fi
AC_SUBST(MOZ_MOVEMAIL)

if test "$MOZ_DEBUG"; then
    AC_DEFINE(MOZ_REFLOW_PERF)
    AC_DEFINE(MOZ_REFLOW_PERF_DSP)
fi

if test "$ACCESSIBILITY" -a "$MOZ_ENABLE_GTK2" ; then
    AC_DEFINE(MOZ_ACCESSIBILITY_ATK)
    ATK_FULL_VERSION=`$PKG_CONFIG --modversion atk`
    ATK_MAJOR_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $1 }'`
    ATK_MINOR_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $2 }'`
    ATK_REV_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $3 }'`
    AC_DEFINE_UNQUOTED(ATK_MAJOR_VERSION, $ATK_MAJOR_VERSION)
    AC_DEFINE_UNQUOTED(ATK_MINOR_VERSION, $ATK_MINOR_VERSION)
    AC_DEFINE_UNQUOTED(ATK_REV_VERSION, $ATK_REV_VERSION)
fi

dnl ========================================================
dnl Use cygwin wrapper for win32 builds, except MSYS/MinGW
dnl ========================================================
case "$host_os" in
mingw*)
    WIN_TOP_SRC=`cd $srcdir; pwd -W`
    ;;
cygwin*|msvc*|mks*)
    HOST_CC="\$(CYGWIN_WRAPPER) $HOST_CC"
    HOST_CXX="\$(CYGWIN_WRAPPER) $HOST_CXX"
    CC="\$(CYGWIN_WRAPPER) $CC"
    CXX="\$(CYGWIN_WRAPPER) $CXX"
    CPP="\$(CYGWIN_WRAPPER) $CPP"
    LD="\$(CYGWIN_WRAPPER) $LD"
    AS="\$(CYGWIN_WRAPPER) $AS"
    RC="\$(CYGWIN_WRAPPER) $RC"
    MIDL="\$(CYGWIN_WRAPPER) $MIDL"
    CYGDRIVE_MOUNT=`mount -p | awk '{ if (/^\//) { print $1; exit } }'`
    WIN_TOP_SRC=`cygpath -a -w $srcdir | sed -e 's|\\\\|/|g'`
    ;;
esac

AC_SUBST(CYGDRIVE_MOUNT)
AC_SUBST(WIN_TOP_SRC)

AC_SUBST(MOZILLA_VERSION)

AC_SUBST(ac_configure_args)

dnl Spit out some output
dnl ========================================================

dnl The following defines are used by xpcom
_NON_GLOBAL_ACDEFINES="$_NON_GLOBAL_ACDEFINES
CPP_THROW_NEW
HAVE_CPP_2BYTE_WCHAR_T
HAVE_CPP_ACCESS_CHANGING_USING
HAVE_CPP_AMBIGUITY_RESOLVING_USING
HAVE_CPP_BOOL
HAVE_CPP_CHAR16_T
HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR
HAVE_CPP_EXPLICIT
HAVE_CPP_MODERN_SPECIALIZE_TEMPLATE_SYNTAX
HAVE_CPP_NAMESPACE_STD
HAVE_CPP_NEW_CASTS
HAVE_CPP_PARTIAL_SPECIALIZATION
HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
HAVE_CPP_TYPENAME
HAVE_CPP_UNAMBIGUOUS_STD_NOTEQUAL
HAVE_STATVFS
NEED_CPP_UNUSED_IMPLEMENTATIONS
NEW_H
HAVE_GETPAGESIZE
HAVE_ICONV
HAVE_ICONV_WITH_CONST_INPUT
HAVE_MBRTOWC
HAVE_SYS_MOUNT_H
HAVE_SYS_VFS_H
HAVE_WCRTOMB
"

AC_CONFIG_HEADER(
netwerk/necko-config.h
xpcom/xpcom-config.h
xpcom/xpcom-private.h
)

# Save the defines header file before autoconf removes it.
# (Do not add AC_DEFINE calls after this line.)
  _CONFIG_TMP=confdefs-tmp.h
  _CONFIG_DEFS_H=mozilla-config.h

  cat > $_CONFIG_TMP <<\EOF
/* List of defines generated by configure. Included with preprocessor flag,
 * -include, to avoid long list of -D defines on the compile command-line.
 * Do not edit.
 */

#ifndef _MOZILLA_CONFIG_H_
#define _MOZILLA_CONFIG_H_
EOF

_EGREP_PATTERN='^#define ('
if test -n "$_NON_GLOBAL_ACDEFINES"; then
    for f in $_NON_GLOBAL_ACDEFINES; do
        _EGREP_PATTERN="${_EGREP_PATTERN}$f|"
    done
fi
_EGREP_PATTERN="${_EGREP_PATTERN}dummy_never_defined)"
 
  sort confdefs.h | egrep -v "$_EGREP_PATTERN" >> $_CONFIG_TMP

  cat >> $_CONFIG_TMP <<\EOF

#endif /* _MOZILLA_CONFIG_H_ */

EOF

  # Only write mozilla-config.h when something changes (or it doesn't exist)
  if cmp -s $_CONFIG_TMP $_CONFIG_DEFS_H; then
    rm $_CONFIG_TMP
  else
    AC_MSG_RESULT("creating $_CONFIG_DEFS_H")
    mv -f $_CONFIG_TMP $_CONFIG_DEFS_H

    echo ==== $_CONFIG_DEFS_H =================================
    cat $_CONFIG_DEFS_H
  fi

dnl Probably shouldn't call this manually but we always want the output of DEFS
rm -f confdefs.h.save
mv confdefs.h confdefs.h.save
egrep -v "$_EGREP_PATTERN" confdefs.h.save > confdefs.h
AC_OUTPUT_MAKE_DEFS()
MOZ_DEFINES=$DEFS
AC_SUBST(MOZ_DEFINES)
rm -f confdefs.h
mv confdefs.h.save confdefs.h

dnl Load the list of Makefiles to generate.
dnl   To add new Makefiles, edit allmakefiles.sh.
dnl   allmakefiles.sh sets the variable, MAKEFILES.
. ${srcdir}/allmakefiles.sh
dnl 
dnl Run a perl script to quickly create the makefiles.
dnl If it succeeds, it outputs a shell command to set CONFIG_FILES
dnl   for the files it cannot handle correctly. This way, config.status
dnl   will handle these files.
dnl If it fails, nothing is set and config.status will run as usual.
dnl
dnl This does not change the $MAKEFILES variable.
dnl
dnl OpenVMS gets a line overflow on the long eval command, so use a temp file.
dnl
if test -z "${AS_PERL}"; then
echo $MAKEFILES | ${PERL} $srcdir/build/autoconf/acoutput-fast.pl > conftest.sh
else
echo $MAKEFILES | ${PERL} $srcdir/build/autoconf/acoutput-fast.pl -nowrap --cygwin-srcdir=$srcdir > conftest.sh
fi
. ./conftest.sh
rm conftest.sh

echo $MAKEFILES > unallmakefiles

mv -f config/autoconf.mk config/autoconf.mk.orig 2> /dev/null

AC_OUTPUT($MAKEFILES)

dnl Prevent the regeneration of cairo-features.h forcing rebuilds of gfx stuff
if test "$CAIRO_FEATURES_H"; then
  if cmp -s $CAIRO_FEATURES_H "$CAIRO_FEATURES_H".orig; then
    echo "$CAIRO_FEATURES_H is unchanged"
    mv -f "$CAIRO_FEATURES_H".orig "$CAIRO_FEATURES_H" 2> /dev/null
  else
    rm -f "$CAIRO_FEATURES_H".orig 2> /dev/null
  fi
fi

dnl ========================================================
dnl = Setup a nice relatively clean build environment for
dnl = sub-configures.
dnl ========================================================
CC="$_SUBDIR_CC" 
CXX="$_SUBDIR_CXX" 
CFLAGS="$_SUBDIR_CFLAGS" 
CPPFLAGS="$_SUBDIR_CPPFLAGS"
CXXFLAGS="$_SUBDIR_CXXFLAGS"
LDFLAGS="$_SUBDIR_LDFLAGS"
HOST_CC="$_SUBDIR_HOST_CC" 
HOST_CFLAGS="$_SUBDIR_HOST_CFLAGS"
HOST_LDFLAGS="$_SUBDIR_HOST_LDFLAGS"
RC=

unset MAKEFILES
unset CONFIG_FILES

# No need to run subconfigures when building with LIBXUL_SDK_DIR
if test "$COMPILE_ENVIRONMENT" -a -z "$LIBXUL_SDK_DIR"; then

if test -z "$MOZ_NATIVE_NSPR"; then
    ac_configure_args="$_SUBDIR_CONFIG_ARGS --with-dist-prefix=$MOZ_BUILD_ROOT/dist --with-mozilla"
    if test -z "$MOZ_DEBUG"; then
        ac_configure_args="$ac_configure_args --disable-debug"
    fi
    if test "$MOZ_OPTIMIZE" = "1"; then
        ac_configure_args="$ac_configure_args --enable-optimize"
    fi
    if test "$OS_ARCH" = "WINNT" && test "$NS_TRACE_MALLOC"; then
       ac_configure_args="$ac_configure_args --enable-debug --disable-optimize"
    fi
    if test -n "$HAVE_64BIT_OS"; then
        ac_configure_args="$ac_configure_args --enable-64bit"
    fi
    if test -n "$USE_ARM_KUSER"; then
        ac_configure_args="$ac_configure_args --with-arm-kuser"
    fi
    AC_OUTPUT_SUBDIRS(nsprpub)
    ac_configure_args="$_SUBDIR_CONFIG_ARGS"
fi

if test -z "$MOZ_NATIVE_NSPR"; then
    # Hack to deal with the fact that we use NSPR_CFLAGS everywhere
    AC_MSG_WARN([Recreating autoconf.mk with updated nspr-config output])
    if test "$OS_ARCH" != "WINNT" && test "$OS_ARCH" != "WINCE"; then
       NSPR_LIBS=`./nsprpub/config/nspr-config --prefix=$LIBXUL_DIST --exec-prefix=$MOZ_BUILD_ROOT/dist --libdir=$LIBXUL_DIST/lib --libs`
       $PERL -pi.bak -e "s '^NSPR_LIBS\\s*=.*'NSPR_LIBS = $NSPR_LIBS'" config/autoconf.mk
       NSPR_CFLAGS=`./nsprpub/config/nspr-config --prefix=$LIBXUL_DIST --exec-prefix=$MOZ_BUILD_ROOT/dist --includedir=$LIBXUL_DIST/include/nspr --cflags`
       $PERL -pi.bak -e "s '^NSPR_CFLAGS\\s*=.*'NSPR_CFLAGS = $NSPR_CFLAGS'" config/autoconf.mk
    fi
    rm -f config/autoconf.mk.bak
fi

# Run the SpiderMonkey 'configure' script.
dist=$MOZ_BUILD_ROOT/dist
ac_configure_args="$_SUBDIR_CONFIG_ARGS"
ac_configure_args="$ac_configure_args --enable-threadsafe"
if test -z "$MOZ_NATIVE_NSPR"; then
    ac_configure_args="$ac_configure_args --with-nspr-cflags='$NSPR_CFLAGS'"
    ac_configure_args="$ac_configure_args --with-nspr-libs='$NSPR_LIBS'"
fi
ac_configure_args="$ac_configure_args --with-dist-dir=../../dist"
ac_configure_args="$ac_configure_args --includedir=$dist/include"
ac_configure_args="$ac_configure_args --bindir=$dist/bin"
ac_configure_args="$ac_configure_args --libdir=$dist/lib"
ac_configure_args="$ac_configure_args --with-sync-build-files=$_topsrcdir"
if test "$MOZ_MEMORY"; then
   ac_configure_args="$ac_configure_args --enable-jemalloc"
   if test -n "$MOZ_MEMORY_LDFLAGS"; then
     export MOZ_MEMORY_LDFLAGS
   fi
fi
AC_OUTPUT_SUBDIRS(js/src)
ac_configure_args="$_SUBDIR_CONFIG_ARGS"

# Build jsctypes on the platforms we can.
if test "$BUILD_CTYPES"; then
  # Run the libffi 'configure' script on platforms that it supports.
  if test -z "$_MSC_VER"; then
    ac_configure_args="--disable-shared --enable-static --disable-raw-api"
    if test "$MOZ_DEBUG"; then
      ac_configure_args="$ac_configure_args --enable-debug"
    fi
    if test -n "$DSO_PIC_CFLAGS"; then
      ac_configure_args="$ac_configure_args --with-pic"
    fi
    if test -n "$CROSS_COMPILE"; then
      ac_configure_args="$ac_configure_args --build=$build --host=$target"
    fi
    if test "$SOLARIS_SUNPRO_CC"; then
      # Always use gcc for libffi on Solaris
      old_cache_file=$cache_file
      cache_file=js/ctypes/libffi/config.cache
      ac_configure_args="$ac_configure_args CC=gcc"
      AC_OUTPUT_SUBDIRS(js/ctypes/libffi)
      cache_file=$old_cache_file
    else
      AC_OUTPUT_SUBDIRS(js/ctypes/libffi)
    fi
    ac_configure_args="$_SUBDIR_CONFIG_ARGS"
  fi
fi

fi # COMPILE_ENVIRONMENT && !LIBXUL_SDK_DIR

dnl Prevent the regeneration of autoconf.mk forcing rebuilds of the world
dnl Needs to be at the end to respect possible changes from NSPR configure
if cmp -s config/autoconf.mk config/autoconf.mk.orig; then
  echo "config/autoconf.mk is unchanged"
  mv -f config/autoconf.mk.orig config/autoconf.mk 2> /dev/null
else
  rm -f config/autoconf.mk.orig 2> /dev/null
fi