configure - qt-s60 in Qt

#!/bin/sh
#############################################################################
##
## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
## All rights reserved.
## Contact: Nokia Corporation (qt-info@nokia.com)
##
## This file is the build configuration utility of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:LGPL$
## No Commercial Usage
## This file contains pre-release code and may not be distributed.
## You may use this file in accordance with the terms and conditions
## contained in the Technology Preview License Agreement accompanying
## this package.
##
## GNU Lesser General Public License Usage
## Alternatively, this file may be used under the terms of the GNU Lesser
## General Public License version 2.1 as published by the Free Software
## Foundation and appearing in the file LICENSE.LGPL included in the
## packaging of this file.  Please review the following information to
## ensure the GNU Lesser General Public License version 2.1 requirements
## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
##
## In addition, as a special exception, Nokia gives you certain additional
## rights.  These rights are described in the Nokia Qt LGPL Exception
## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
##
## If you have questions regarding the use of this file, please contact
## Nokia at qt-info@nokia.com.
##
##
##
##
##
##
##
##
## $QT_END_LICENSE$
##
#############################################################################

#-------------------------------------------------------------------------------
# script initialization
#-------------------------------------------------------------------------------

# the name of this script
relconf=`basename $0`
# the directory of this script is the "source tree"
relpath=`dirname $0`
relpath=`(cd "$relpath"; /bin/pwd)`
# the current directory is the "build tree" or "object tree"
outpath=`/bin/pwd`

#license file location
LICENSE_FILE="$QT_LICENSE_FILE"
[ -z "$LICENSE_FILE" ] && LICENSE_FILE="$HOME/.qt-license"
if [ -f "$LICENSE_FILE" ]; then
    tr -d '\r' <"$LICENSE_FILE" >"${LICENSE_FILE}.tmp"
    diff "${LICENSE_FILE}.tmp" "${LICENSE_FILE}" >/dev/null 2>&1 || LICENSE_FILE="${LICENSE_FILE}.tmp"
fi

# later cache the command line in config.status
OPT_CMDLINE=`echo $@ | sed "s,-v ,,g; s,-v$,,g"`

# initialize global variables
QMAKE_SWITCHES=
QMAKE_VARS=
QMAKE_CONFIG=
QTCONFIG_CONFIG=
QT_CONFIG=
SUPPORTED=
QMAKE_VARS_FILE=.qmake.vars

:> "$QMAKE_VARS_FILE"

#-------------------------------------------------------------------------------
# utility functions
#-------------------------------------------------------------------------------

shellEscape()
{
    echo "$@" | sed 's/ /\ /g'
}

# Adds a new qmake variable to the cache
# Usage: QMakeVar mode varname contents
#   where mode is one of: set, add, del
QMakeVar()
{
    case "$1" in
	set)
	    eq="="
	    ;;
	add)
	    eq="+="
	    ;;
	del)
	    eq="-="
	    ;;
	*)
	    echo >&2 "BUG: wrong command to QMakeVar: $1"
	    ;;
    esac

    echo "$2" "$eq" "$3" >> "$QMAKE_VARS_FILE"
}

# Helper function for getQMakeConf. It parses include statements in
# qmake.conf and prints out the expanded file
getQMakeConf1()
{
    while read line; do case "$line" in
        include*)
	    inc_file=`echo "$line" | sed -n -e "/^include.*(.*)/s/include.*(\(.*\)).*$/\1/p"`
	    current_dir=`dirname "$1"`
	    conf_file="$current_dir/$inc_file"
	    if [ ! -f  "$conf_file" ]; then
                echo "WARNING: Unable to find file $conf_file" >&2
                continue
            fi
            getQMakeConf1 "$conf_file"
        ;;
        *)
            echo "$line"
        ;;
    esac; done < "$1"
}


# relies on $QMAKESPEC being set correctly. parses include statements in
# qmake.conf and prints out the expanded file
getQMakeConf()
{
    tmpSPEC="$QMAKESPEC"
    if [ -n "$1" ]; then
        tmpSPEC="$1"
    fi
    getQMakeConf1 "$tmpSPEC/qmake.conf"
}

# relies on $TEST_COMPILER being set correctly
compilerSupportsFlag()
{
    cat >conftest.cpp <<EOF
int main() { return 0; }
EOF
    "$TEST_COMPILER" "$@" -o conftest.o conftest.cpp
    ret=$?
    rm -f conftest.cpp conftest.o
    return $ret
}

# relies on $TEST_COMPILER being set correctly
linkerSupportsFlag()
{
    lflags=-Wl
    for flag
    do
	safe_flag=`shellEscape "$flag"`
	lflags=$lflags,$safe_flag
    done
    compilerSupportsFlag "$lflags" >/dev/null 2>&1
}

#-------------------------------------------------------------------------------
# operating system detection
#-------------------------------------------------------------------------------

# need that throughout the script
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

# detect the "echo without newline" style. usage: echo $ECHO_N "<string>$ECHO_C"
if echo '\c' | grep '\c' >/dev/null; then
    ECHO_N=-n
else
    ECHO_C='\c'
fi

#-------------------------------------------------------------------------------
# window system detection
#-------------------------------------------------------------------------------

PLATFORM_X11=no
PLATFORM_MAC=no
PLATFORM_QWS=maybe
PLATFORM_QPA=maybe
BUILD_ON_MAC=no;
[ -d /System/Library/Frameworks/Carbon.framework ] && BUILD_ON_MAC=yes

if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ] && [ $BUILD_ON_MAC = "yes" ]; then
    # Qt/Mac
    # ~ the Carbon SDK exists
    # ~ src/gui/base/qapplication_mac.cpp is present
    # ~ this is the internal edition and Qt/Mac sources exist
    PLATFORM_MAC=maybe
elif [ -f "$relpath"/src/gui/kernel/qapplication_qws.cpp ]; then
    # Qt Embedded
    # ~ src/gui/base/qapplication_qws.cpp is present
    # ~ this is the free or commercial edition
    # ~ this is the internal edition and Qt Embedded is explicitly enabled
    if [ -f "$relpath"/src/gui/kernel/qapplication_mac.mm ]; then
        # This is a depot build, or an all-platforms package
        PLATFORM_QWS=maybe
    else
        # This must be the embedded package, since the Qt/Mac source files are not present
	PLATFORM_QWS=yes
    fi
fi

#-----------------------------------------------------------------------------
# Qt version detection
#-----------------------------------------------------------------------------
QT_VERSION=`grep '^# *define *QT_VERSION_STR' "$relpath"/src/corelib/global/qglobal.h`
QT_MAJOR_VERSION=
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
if [ -n "$QT_VERSION" ]; then
   QT_VERSION=`echo $QT_VERSION | sed 's,^# *define *QT_VERSION_STR *"*\([^ ]*\)"$,\1,'`
   MAJOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
   if [ -n "$MAJOR" ]; then
     MINOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
      PATCH=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
      QT_MAJOR_VERSION="$MAJOR"
      [ -z "$MINOR" ] || QT_MINOR_VERSION="$MINOR"
      [ -z "$PATCH" ] || QT_PATCH_VERSION="$PATCH"
   fi
fi
if [ -z "$QT_MAJOR_VERSION" ]; then
   echo "Cannot process version from qglobal.h: $QT_VERSION"
   echo "Cannot proceed."
   exit 1
fi

QT_PACKAGEDATE=`grep '^# *define *QT_PACKAGEDATE_STR' "$relpath"/src/corelib/global/qglobal.h | sed -e 's,^# *define *QT_PACKAGEDATE_STR *"\([^ ]*\)"$,\1,' -e s,-,,g`
if [ -z "$QT_PACKAGEDATE" ]; then
   echo "Unable to determine package date from qglobal.h: '$QT_PACKAGEDATE'"
   echo "Cannot proceed"
   exit 1
fi

#-------------------------------------------------------------------------------
# check the license
#-------------------------------------------------------------------------------
COMMERCIAL_USER=ask
CFG_DEV=no
CFG_NOKIA=no
CFG_EMBEDDED=no
CFG_RTOS_ENABLED=yes
EditionString=Commercial

earlyArgParse()
{
    # parse the arguments, setting things to "yes" or "no"
    while [ "$#" -gt 0 ]; do
        CURRENT_OPT="$1"
        UNKNOWN_ARG=no
        case "$1" in
        #Autoconf style options
        --enable-*)
            VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
            VAL=yes
            ;;
        --disable-*)
            VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
            VAL=no
            ;;
        --*=*)
            VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
            VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
            ;;
        --no-*)
            VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
            VAL=no
            ;;
        -embedded)
            VAR=embedded
            # this option may or may not be followed by an argument
            if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
                VAL=auto
            else
                shift;
                VAL=$1
            fi
            ;;
        -embedded-lite|-qpa)
            VAR=qpa
            # this option may or may not be followed by an argument
            if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
                VAL=auto
            else
                shift;
                VAL=$1
            fi
            ;;
        -nacl)
            shift;
            VAR=nacl
            VAL=$1
            ;;

        -h|help|--help|-help)
            if [ "$VAL" = "yes" ]; then
                OPT_HELP="$VAL"
                COMMERCIAL_USER="no" #doesn't matter we will display the help
            else
                UNKNOWN_OPT=yes
                COMMERCIAL_USER="no" #doesn't matter we will display the help
            fi
            ;;
        --*)
            VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
            VAL=yes
            ;;
        -*)
            VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
            VAL="unknown"
            ;;
        *)
            UNKNOWN_ARG=yes
            ;;
        esac
        if [ "$UNKNOWN_ARG" = "yes" ]; then
            shift
            continue
        fi
        shift

        UNKNOWN_OPT=no
        case "$VAR" in
        embedded)
            CFG_EMBEDDED="$VAL"
            if [ "$PLATFORM_QWS" != "no" ]; then
                if [ "$PLATFORM_QWS" = "maybe" ]; then
                    PLATFORM_X11=no
                    PLATFORM_MAC=no
                    PLATFORM_QWS=yes
                    PLATFORM_QPA=no
                fi
            else
                echo "No license exists to enable Qt for Embedded Linux. Disabling."
                CFG_EMBEDDED=no
            fi
            ;;
        qpa)
            CFG_EMBEDDED="no"
            if [ "$PLATFORM_QPA" != "no" ]; then
                if [ "$PLATFORM_QPA" = "maybe" ]; then
                    PLATFORM_X11=no
                    PLATFORM_MAC=no
                    PLATFORM_QWS=no
                    PLATFORM_QPA=yes
                fi
            else
                echo "No license exists to enable Qt QPA. Disabling."
                CFG_EMBEDDED=no
            fi
            ;;
        nacl)
            echo "Using NaCl at $VAL."
            PLATFORM_X11=no
            PLATFORM_MAC=no
            PLATFORM_QWS=no
            CFG_NACL_PATH=$VAL
            CFG_EMBEDDED=nacl
            ;;

        developer-build)
            CFG_DEV="yes"
            ;;
        nokia-developer)
            CFG_DEV="yes"
            CFG_NOKIA="yes"
            COMMERCIAL_USER="no"
            ;;
        commercial)
            COMMERCIAL_USER="yes"
            ;;
        opensource)
            COMMERCIAL_USER="no"
            ;;
        *)
            UNKNOWN_OPT=yes
            ;;
        esac
    done
}

earlyArgParse "$@"

if [ "$COMMERCIAL_USER" = "ask" ]; then
    while true; do
        echo "Which edition of Qt do you want to use ?"
        echo
        echo "Type 'c' if you want to use the Commercial Edition."
        echo "Type 'o' if you want to use the Open Source Edition."
        echo
        read commercial
        echo
        if [ "$commercial" = "c" ]; then
            COMMERCIAL_USER="yes"
            break
        elif [ "$commercial" = "o" ]; then
            COMMERCIAL_USER="no"
            break
        fi
    done
fi

if [ "$CFG_NOKIA" = "yes" ]; then
    Licensee="Nokia"
    Edition="NokiaInternalBuild"
    EditionString="Nokia Internal Build"
    QT_EDITION="QT_EDITION_OPENSOURCE"
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
elif [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then
    # Commercial preview release
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    Licensee="Preview"
    Edition="Preview"
    QT_EDITION="QT_EDITION_DESKTOP"
    LicenseType="Technology Preview"
elif [ $COMMERCIAL_USER = "yes" ]; then
    # one of commercial editions
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    [ "$PLATFORM_QPA" = "maybe" ] && PLATFORM_QPA=no
    [ "$PLATFORM_QWS" = "maybe" ] && PLATFORM_QWS=no

    # read in the license file
    if [ -f "$LICENSE_FILE" ]; then
        . "$LICENSE_FILE" >/dev/null 2>&1
        if [ -z "$LicenseKeyExt" ]; then
            echo
            echo "You are using an old license file."
            echo
            echo "Please install the license file supplied by Nokia,"
            echo "or install the Qt Open Source Edition if you intend to"
            echo "develop free software."
            exit 1
        fi
	if [ -z "$Licensee" ]; then
	    echo
	    echo "Invalid license key. Please check the license key."
	    exit 1
	fi
    else
        if [ -z "$LicenseKeyExt" ]; then
            echo
            echo $ECHO_N "Please enter your license key: $ECHO_C"
            read LicenseKeyExt
            Licensee="Unknown user"
        fi
    fi

    # Key verification
    echo "$LicenseKeyExt" | grep ".....*-....*-....*-....*-.....*-.....*-...." >/dev/null 2>&1 \
        && LicenseValid="yes" \
        || LicenseValid="no"
    if [ "$LicenseValid" != "yes" ]; then
        echo
        echo "Invalid license key. Please check the license key."
        exit 1
    fi
    ProductCode=`echo $LicenseKeyExt | cut -f 1 -d - | cut -b 1`
    PlatformCode=`echo $LicenseKeyExt | cut -f 2 -d -`
    LicenseTypeCode=`echo $LicenseKeyExt | cut -f 3 -d -`
    LicenseFeatureCode=`echo $LicenseKeyExt | cut -f 4 -d - | cut -b 1`

    # determine which edition we are licensed to use
    case "$LicenseTypeCode" in
    F4M)
        LicenseType="Commercial"
        case $ProductCode in
        F)
            Edition="Universal"
            QT_EDITION="QT_EDITION_UNIVERSAL"
            ;;
        B)
            Edition="FullFramework"
            EditionString="Full Framework"
            QT_EDITION="QT_EDITION_DESKTOP"
            ;;
        L)
            Edition="GUIFramework"
            EditionString="GUI Framework"
            QT_EDITION="QT_EDITION_DESKTOPLIGHT"
            ;;
        esac
        ;;
    Z4M|R4M|Q4M)
        LicenseType="Evaluation"
        QMakeVar add DEFINES QT_EVAL
        case $ProductCode in
         B)
            Edition="Evaluation"
            QT_EDITION="QT_EDITION_EVALUATION"
            ;;
        esac
        ;;
    esac
    if [ -z "$LicenseType" -o -z "$Edition" -o -z "$QT_EDITION" ]; then
        echo
        echo "Invalid license key. Please check the license key."
        exit 1
    fi

    # verify that we are licensed to use Qt on this platform
    LICENSE_EXTENSION=
    case "$PlatformCode" in
	*L)
	    CFG_RTOS_ENABLED=yes
	    PlatformCode=`echo "$PlatformCode" | sed 'h;y/8NPQRTZ/UCWX9M7/;x;G;s/\(.\)....\(.\)./\1\2/'`
	    ;;
	*)
	    CFG_RTOS_ENABLED=no
	    PlatformCode=`echo "$PlatformCode" | sed 's/.$//'`
	    ;;
    esac
    ### EMBEDDED_QPA logic missing ###
    case "$PlatformCode,$PLATFORM_MAC,$PLATFORM_QWS" in
        X9,* | XC,* | XU,* | XW,* | XM,*)
            # Qt All-OS
            LICENSE_EXTENSION="-ALLOS"
            ;;
        8M,* | KM,* | S9,* | SC,* | SM,* | SU,* | SW,* | X9,* | XC,* | XU,* | XW,*)
            # Qt for Embedded Linux
            LICENSE_EXTENSION="-EMBEDDED"
            ;;
        6M,*,no | N7,*,no | N9,*,no | NX,*,no)
            # Embedded no-deploy
            LICENSE_EXTENSION="-EMBEDDED"
            ;;
        FM,*,no | LM,yes,* | ZM,no,no)
            # Desktop
            LICENSE_EXTENSION="-DESKTOP"
            ;;
        *)
            Platform=Linux/X11
            [ "$PLATFORM_MAC" = "yes" ] && Platform='Mac OS X'
            [ "$PLATFORM_QWS" = "yes" ] && Platform='Embedded Linux'
            echo
            echo "You are not licensed for the $Platform platform."
            echo
            echo "Please contact qt-info@nokia.com to upgrade your license to"
            echo "include the $Platform platform, or install the Qt Open Source Edition"
            echo "if you intend to develop free software."
            exit 1
            ;;
    esac

    if test -r "$relpath/.LICENSE"; then
	# Generic, non-final license
	LICENSE_EXTENSION=""
	line=`sed 'y/a-z/A-Z/;q' "$relpath"/.LICENSE`
	case "$line" in
	    *BETA*)
		Edition=Beta
		;;
	    *TECHNOLOGY?PREVIEW*)
		Edition=Preview
		;;
	    *EVALUATION*)
		Edition=Evaluation
		;;
	    *)
		echo >&2 "Invalid license files; cannot continue"
		exit 1
		;;
	esac
	Licensee="$Edition"
	EditionString="$Edition"
	QT_EDITION="QT_EDITION_DESKTOP"
    fi

    case "$LicenseFeatureCode" in
    B|G|L|Y)
        # US
        case "$LicenseType" in
        Commercial)
            cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}-US" "$outpath/LICENSE"
            ;;
        Evaluation)
            cp -f "$relpath/.LICENSE-EVALUATION-US" "$outpath/LICENSE"
            ;;
        esac
        ;;
    2|4|5|F)
        # non-US
        case "$LicenseType" in
        Commercial)
            cp -f "$relpath/.LICENSE${LICENSE_EXTENSION}" "$outpath/LICENSE"
            ;;
        Evaluation)
            cp -f "$relpath/.LICENSE-EVALUATION" "$outpath/LICENSE"
            ;;
        esac
        ;;
    *)
        echo
        echo "Invalid license key. Please check the license key."
        exit 1
        ;;
    esac
    case "$LicenseFeatureCode" in
	4|B|F|Y)
	    CFG_RTOS_ENABLED=yes
	    ;;
	2|5|G|L)
	    CFG_RTOS_ENABLED=no
	    ;;
    esac
    if [ '!' -f "$outpath/LICENSE" ]; then
        echo "The LICENSE, LICENSE.GPL3 LICENSE.LGPL file shipped with"
        echo "this software has disappeared."
        echo
        echo "Sorry, you are not licensed to use this software."
        echo "Try re-installing."
        echo
        exit 1
    fi
elif [ $COMMERCIAL_USER = "no" ]; then
    # Open Source edition - may only be used under the terms of the GPL or LGPL.
    [ "$PLATFORM_MAC" = "maybe" ] && PLATFORM_MAC=yes
    Licensee="Open Source"
    Edition="OpenSource"
    EditionString="Open Source"
    QT_EDITION="QT_EDITION_OPENSOURCE"
fi

#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------

SYSTEM_VARIABLES="RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS"
for varname in $SYSTEM_VARIABLES; do
    qmakevarname="${varname}"
    # use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS
    if [ "${varname}" = "LDFLAGS" ]; then
        qmakevarname="LFLAGS"
    elif [ "${varname}" = "LD" ]; then
        qmakevarname="LINK"
    fi
    cmd=`echo \
'if [ -n "\$'${varname}'" ]; then
    QMakeVar set QMAKE_'${qmakevarname}' "\$'${varname}'"
fi'`
    eval "$cmd"
done
# Use CC/CXX to run config.tests
mkdir -p "$outpath/config.tests"
rm -f "$outpath/config.tests/.qmake.cache"
cp "$QMAKE_VARS_FILE" "$outpath/config.tests/.qmake.cache"

QMakeVar add styles "cde mac motif plastique cleanlooks windows"
QMakeVar add decorations "default windows styled"
QMakeVar add mouse-drivers "pc"
if [ "$UNAME_SYSTEM" = "Linux" ] ; then
    QMakeVar add gfx-drivers "linuxfb"
    QMakeVar add mouse-drivers "linuxtp"
fi
QMakeVar add kbd-drivers "tty"

if [ "$CFG_DEV" = "yes" ]; then
    QMakeVar add kbd-drivers "um"
fi

# QTDIR may be set and point to an old or system-wide Qt installation
unset QTDIR

# the minimum version of libdbus-1 that we require:
MIN_DBUS_1_VERSION=0.93

# initalize internal variables
CFG_CONFIGURE_EXIT_ON_ERROR=yes
CFG_PROFILE=no
CFG_EXCEPTIONS=unspecified
CFG_GUI=auto # (yes|no|auto)
CFG_SCRIPT=auto # (yes|no|auto)
CFG_SCRIPTTOOLS=auto # (yes|no|auto)
CFG_XMLPATTERNS=auto # (yes|no|auto)
CFG_INCREMENTAL=auto
CFG_QCONFIG=full
CFG_DEBUG=auto
CFG_MYSQL_CONFIG=
CFG_DEBUG_RELEASE=no
CFG_SHARED=yes
CFG_SM=auto
CFG_XSHAPE=auto
CFG_XSYNC=auto
CFG_XVIDEO=auto
CFG_XINERAMA=runtime
CFG_XFIXES=runtime
CFG_ZLIB=auto
CFG_SYMBIAN_DEFFILES=auto
CFG_S60=auto
CFG_SQLITE=qt
CFG_GIF=auto
CFG_TIFF=auto
CFG_LIBTIFF=auto
CFG_PNG=yes
CFG_LIBPNG=auto
CFG_JPEG=auto
CFG_LIBJPEG=auto
CFG_MNG=auto
CFG_LIBMNG=auto
CFG_XCURSOR=runtime
CFG_XRANDR=runtime
CFG_XRENDER=auto
CFG_MITSHM=auto
CFG_OPENGL=auto
CFG_OPENVG=no
CFG_OPENVG_LC_INCLUDES=no
CFG_OPENVG_SHIVA=no
CFG_OPENVG_ON_OPENGL=no
CFG_EGL=no
CFG_EGL_GLES_INCLUDES=no
CFG_SSE=auto
CFG_FONTCONFIG=auto
CFG_QWS_FREETYPE=auto
CFG_LIBFREETYPE=auto
CFG_SQL_AVAILABLE=
QT_DEFAULT_BUILD_PARTS="libs tools examples demos docs translations"
CFG_BUILD_PARTS=""
CFG_NOBUILD_PARTS=""
CFG_RELEASE_QMAKE=no
CFG_PHONON=auto
CFG_PHONON_BACKEND=yes
CFG_MULTIMEDIA=auto
CFG_AUDIO_BACKEND=auto
CFG_SVG=auto
CFG_DECLARATIVE=auto
CFG_DECLARATIVE_DEBUG=yes
CFG_WEBKIT=auto # (yes|no|auto|debug)
CFG_JAVASCRIPTCORE_JIT=auto

CFG_GFX_AVAILABLE="linuxfb transformed qvfb vnc multiscreen directfb"
CFG_GFX_ON="linuxfb multiscreen"
CFG_GFX_PLUGIN_AVAILABLE=
CFG_GFX_PLUGIN=
CFG_GFX_OFF=
CFG_KBD_AVAILABLE="tty linuxinput qvfb"
CFG_KBD_ON="tty"    #default, see QMakeVar above
CFG_MOUSE_AVAILABLE="pc linuxtp linuxinput tslib qvfb"
CFG_MOUSE_ON="pc linuxtp"   #default, see QMakeVar above

if [ -f "$relpath/src/gui/embedded/qscreenqnx_qws.cpp" ]; then
    CFG_KBD_AVAILABLE="${CFG_KBD_AVAILABLE} qnx"
    CFG_MOUSE_AVAILABLE="${CFG_MOUSE_AVAILABLE} qnx"
    CFG_GFX_AVAILABLE="${CFG_GFX_AVAILABLE} qnx"
fi

CFG_ARCH=
CFG_HOST_ARCH=
CFG_KBD_PLUGIN_AVAILABLE=
CFG_KBD_PLUGIN=
CFG_KBD_OFF=
CFG_MOUSE_PLUGIN_AVAILABLE=
CFG_MOUSE_PLUGIN=
CFG_MOUSE_OFF=
CFG_USE_GNUMAKE=no
CFG_IM=yes
CFG_DECORATION_AVAILABLE="styled windows default"
CFG_DECORATION_ON="${CFG_DECORATION_AVAILABLE}" # all on by default
CFG_DECORATION_PLUGIN_AVAILABLE=
CFG_DECORATION_PLUGIN=
CFG_XINPUT=runtime
CFG_XKB=auto
CFG_NIS=auto
CFG_CUPS=auto
CFG_ICONV=auto
CFG_DBUS=auto
CFG_GLIB=auto
CFG_GSTREAMER=auto
CFG_QGTKSTYLE=auto
CFG_QS60STYLE=auto
CFG_LARGEFILE=auto
CFG_OPENSSL=auto
CFG_PTMALLOC=no
CFG_STL=auto
CFG_PRECOMPILE=auto
CFG_SEPARATE_DEBUG_INFO=no
CFG_SEPARATE_DEBUG_INFO_NOCOPY=no
CFG_REDUCE_EXPORTS=auto
CFG_MMX=auto
CFG_3DNOW=auto
CFG_SSE=auto
CFG_SSE2=auto
CFG_SSE3=auto
CFG_SSSE3=auto
CFG_SSE4_1=auto
CFG_SSE4_2=auto
CFG_AVX=auto
CFG_REDUCE_RELOCATIONS=no
CFG_IPV6=auto
CFG_NAS=no
CFG_QWS_DEPTHS=all
CFG_USER_BUILD_KEY=
CFG_ACCESSIBILITY=auto
CFG_QT3SUPPORT=yes
CFG_ENDIAN=auto
CFG_HOST_ENDIAN=auto
CFG_DOUBLEFORMAT=auto
CFG_ARMFPA=auto
CFG_IWMMXT=no
CFG_NEON=auto
CFG_CLOCK_GETTIME=auto
CFG_CLOCK_MONOTONIC=auto
CFG_MREMAP=auto
CFG_GETADDRINFO=auto
CFG_IPV6IFNAME=auto
CFG_GETIFADDRS=auto
CFG_INOTIFY=auto
CFG_RPATH=yes
CFG_FRAMEWORK=auto
CFG_MAC_ARCHS=
MAC_CONFIG_TEST_COMMANDLINE=  # used to make the configure tests run with the correct arch's and SDK settings
CFG_MAC_DWARF2=auto
CFG_MAC_XARCH=auto
CFG_MAC_CARBON=no
CFG_MAC_COCOA=yes
COMMANDLINE_MAC_CARBON=no
CFG_SXE=no
CFG_PREFIX_INSTALL=yes
CFG_SDK=
D_FLAGS=
I_FLAGS=
L_FLAGS=
RPATH_FLAGS=
l_FLAGS=
QCONFIG_FLAGS=
XPLATFORM=              # This seems to be the QMAKESPEC, like "linux-g++" or "symbian-gcce"
XPLATFORM_MINGW=no      # Whether target platform is MinGW (win32-g++*)
XPLATFORM_SYMBIAN=no    # Whether target platform is SYMBIAN (*symbian*)
XPLATFORM_SYMBIAN_SBSV2=no # Whether target platform is SYMBIAN_SBSV2 (symbian-sbsv2)
PLATFORM=$QMAKESPEC
QT_CROSS_COMPILE=no
OPT_CONFIRM_LICENSE=no
OPT_SHADOW=maybe
OPT_FAST=auto
OPT_VERBOSE=no
OPT_HELP=
CFG_SILENT=no
CFG_GRAPHICS_SYSTEM=default
CFG_RUNTIME_SYSTEM=
CFG_ALSA=auto
CFG_PULSEAUDIO=auto
CFG_COREWLAN=auto
CFG_ICD=auto
CFG_NOPROCESS=no

# initalize variables used for installation
QT_INSTALL_PREFIX=
QT_INSTALL_DOCS=
QT_INSTALL_HEADERS=
QT_INSTALL_LIBS=
QT_INSTALL_BINS=
QT_INSTALL_PLUGINS=
QT_INSTALL_IMPORTS=
QT_INSTALL_DATA=
QT_INSTALL_TRANSLATIONS=
QT_INSTALL_SETTINGS=
QT_INSTALL_EXAMPLES=
QT_INSTALL_DEMOS=
QT_HOST_PREFIX=

#flags for SQL drivers
QT_CFLAGS_PSQL=
QT_LFLAGS_PSQL=
QT_CFLAGS_MYSQL=
QT_LFLAGS_MYSQL=
QT_LFLAGS_MYSQL_R=
QT_CFLAGS_SQLITE=
QT_LFLAGS_SQLITE=
QT_LFLAGS_ODBC="-lodbc"
QT_LFLAGS_TDS=

# flags for libdbus-1
QT_CFLAGS_DBUS=
QT_LIBS_DBUS=

# flags for Glib (X11 only)
QT_CFLAGS_GLIB=
QT_LIBS_GLIB=

# flags for GStreamer (X11 only)
QT_CFLAGS_GSTREAMER=
QT_LIBS_GSTREAMER=

#flag for Symbian fpu settings
QT_CFLAGS_FPU=

# flags for libconnsettings0 (used for Maemo ICD bearer management plugin)
QT_CFLAGS_CONNSETTINGS=
QT_LIBS_CONNSETTINGS=

#-------------------------------------------------------------------------------
# check SQL drivers, mouse drivers and decorations available in this package
#-------------------------------------------------------------------------------

# opensource version removes some drivers, so force them to be off
CFG_SQL_tds=no
CFG_SQL_oci=no
CFG_SQL_db2=no

CFG_SQL_AVAILABLE=
if [ -d "$relpath/src/plugins/sqldrivers" ]; then
  for a in "$relpath/src/plugins/sqldrivers/"*; do
     if [ -d "$a" ]; then
	 base_a=`basename "$a"`
  	 CFG_SQL_AVAILABLE="${CFG_SQL_AVAILABLE} ${base_a}"
	 eval "CFG_SQL_${base_a}=auto"
     fi
  done
fi

CFG_DECORATION_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/decorations" ]; then
  for a in "$relpath/src/plugins/decorations/"*; do
     if [ -d "$a" ]; then
	 base_a=`basename "$a"`
  	 CFG_DECORATION_PLUGIN_AVAILABLE="${CFG_DECORATION_PLUGIN_AVAILABLE} ${base_a}"
     fi
  done
fi

CFG_KBD_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/kbddrivers" ]; then
  for a in "$relpath/src/plugins/kbddrivers/"*; do
     if [ -d "$a" ]; then
	 base_a=`basename "$a"`
  	 CFG_KBD_PLUGIN_AVAILABLE="${CFG_KBD_PLUGIN_AVAILABLE} ${base_a}"
     fi
  done
fi

CFG_MOUSE_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/mousedrivers" ]; then
  for a in "$relpath/src/plugins/mousedrivers/"*; do
     if [ -d "$a" ]; then
	 base_a=`basename "$a"`
  	 CFG_MOUSE_PLUGIN_AVAILABLE="${CFG_MOUSE_PLUGIN_AVAILABLE} ${base_a}"
     fi
  done
fi

CFG_GFX_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/gfxdrivers" ]; then
  for a in "$relpath/src/plugins/gfxdrivers/"*; do
     if [ -d "$a" ]; then
	 base_a=`basename "$a"`
  	 CFG_GFX_PLUGIN_AVAILABLE="${CFG_GFX_PLUGIN_AVAILABLE} ${base_a}"
     fi
  done
  CFG_GFX_OFF="$CFG_GFX_AVAILABLE" # assume all off
fi

#-------------------------------------------------------------------------------
# Set Default NaCl options
#-------------------------------------------------------------------------------
if [ "$CFG_EMBEDDED" = "nacl" ]; then
    echo "Setting NaCl options:"
    echo "-static"
    CFG_SHARED=no
    echo "-qpa nacl"
    PLATFORM_QPA=yes
    echo "-fast"
    OPT_FAST=yes
    echo "-release"
    CFG_DEBUG=no
    echo "-qconfig minimal-system-dependencies"
    CFG_QCONFIG=minimal-system-dependencies

    if [ `uname` = "Linux" ]; then
        I_FLAGS="$I_FLAGS -I${CFG_NACL_PATH}/toolchain/linux_x86/sdk/nacl-sdk/include"
        L_FLAGS="$L_FLAGS -I${CFG_NACL_PATH}/toolchain/linux_x86/sdk/nacl-sdk/lib"
    else
        I_FLAGS="$I_FLAGS -I${CFG_NACL_PATH}/toolchain/mac_x86/sdk/nacl-sdk/include"
        L_FLAGS="$L_FLAGS -I${CFG_NACL_PATH}/toolchain/mac_x86/sdk/nacl-sdk/lib"
    fi

    echo "-no-multimedia -no-webkit -no-phonon -no-nultimedia -no-mediaservices -no-xmlpatterns -no-script -no-sql-sqlite -nomake tests"
    CFG_MULTIMEDIA=no
    CFG_WEBKIT=no
    CFG_PHONON=no
    CFG_MULTIMEDIA=no
    CFG_MEDIASERVICES=no
    CFG_XMLPATTERNS=no
    CFG_SCRIPT=no
    CFG_SQLITE=no
    CFG_SQL_sqlite=no
    CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS tests"
    QT_CONFIG="$QT_CONFIG nacl"
fi

#-------------------------------------------------------------------------------
# parse command line arguments
#-------------------------------------------------------------------------------

# parse the arguments, setting things to "yes" or "no"
while [ "$#" -gt 0 ]; do
    CURRENT_OPT="$1"
    UNKNOWN_ARG=no
    case "$1" in
    #Autoconf style options
    --enable-*)
        VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
        VAL=yes
        ;;
    --disable-*)
        VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
        VAL=no
        ;;
    --*=*)
        VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
        VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
        ;;
    --no-*)
        VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
        VAL=no
        ;;
    --*)
        VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
        VAL=yes
        ;;
    #Qt plugin options
    -no-*-*|-plugin-*-*|-qt-*-*)
        VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
        VAL=`echo $1 | sed "s,^-\([^-]*\).*,\1,"`
        ;;
    #WebKit options
    -webkit)
        VAR="webkit"
        VAL="yes"
        ;;
    -webkit-debug)
        VAR="webkit"
        VAL="debug"
        ;;
    -no-webkit)
        VAR="webkit"
        VAL="no"
        ;;
    #Qt style no options
    -no-*)
        VAR=`echo $1 | sed "s,^-no-\(.*\),\1,"`
        VAL=no
        ;;
    #Qt style yes options
        -incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-egl|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-carbon|-universal|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-audio-backend|-svg|-declarative|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config|-s60|-usedeffiles)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        VAL=yes
        ;;
    #Qt style options that pass an argument
    -qconfig)
        if [ "$PLATFORM_QWS" != "yes" -a "$PLATFORM_QPA" != "yes" ]; then
            echo
            echo "WARNING: -qconfig is only tested and supported on Qt for Embedded Linux."
            echo
        fi
        CFG_QCONFIG="$VAL"
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        shift
        VAL=$1
        ;;
    -prefix|-docdir|-headerdir|-plugindir|-importdir|-datadir|-libdir|-bindir|-translationdir|-sysconfdir|-examplesdir|-demosdir|-depths|-make|-nomake|-platform|-xplatform|-buildkey|-sdk|-arch|-host-arch|-mysql_config)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        shift
        VAL="$1"
        ;;
    #Qt style complex options in one command
    -enable-*|-disable-*)
        VAR=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
        VAL=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
        ;;
    #Qt Builtin/System style options
    -no-*|-system-*|-qt-*)
        VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
        VAL=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
        ;;
    #Options that cannot be generalized
    -k|-continue)
        VAR=fatal_error
        VAL=no
        ;;
    -embedded)
        VAR=embedded
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=auto
        else
            shift;
            VAL=$1
        fi
	;;
    -embedded-lite|-qpa)
        VAR=qpa
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=auto
        else
            shift;
            VAL=$1
        fi
	;;
    -nacl)
        VAR=nacl
        shift;
    ;;
    -opengl)
        VAR=opengl
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=yes
        else
            shift;
            VAL=$1
        fi
	;;
    -openvg)
        VAR=openvg
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=yes
        else
            shift;
            VAL=$1
        fi
	;;
    -hostprefix)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=$outpath
        else
            shift;
            VAL=$1
        fi
        ;;
    -host-*-endian)
        VAR=host_endian
        VAL=`echo $1 | sed "s,^-.*-\(.*\)-.*,\1,"`
        ;;
    -*-endian)
        VAR=endian
        VAL=`echo $1 | sed "s,^-\(.*\)-.*,\1,"`
        ;;
    -qtnamespace)
        VAR="qtnamespace"
        shift
        VAL="$1"
        ;;
    -graphicssystem)
	VAR="graphicssystem"
	shift
	VAL=$1
	;;
    -runtimegraphicssystem)
	VAR="runtimegraphicssystem"
	shift
	VAL=$1
	;;
    -qtlibinfix)
        VAR="qtlibinfix"
        shift
        VAL="$1"
        ;;
    -D?*|-D)
        VAR="add_define"
        if [ "$1" = "-D" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-D,,'`
        fi
        ;;
    -fpu)
        VAR="fpu"
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=no
        else
            shift
            VAL=$1
        fi
        ;;
    -I?*|-I)
        VAR="add_ipath"
        if [ "$1" = "-I" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-I,,'`
        fi
        ;;
    -L?*|-L)
        VAR="add_lpath"
        if [ "$1" = "-L" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-L,,'`
        fi
        ;;
    -R?*|-R)
        VAR="add_rpath"
        if [ "$1" = "-R" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-R,,'`
        fi
        ;;
    -l?*)
        VAR="add_link"
        VAL=`echo $1 | sed 's,-l,,'`
        ;;
    -F?*|-F)
        VAR="add_fpath"
        if [ "$1" = "-F" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-F,,'`
        fi
        ;;
    -fw?*|-fw)
        VAR="add_framework"
        if [ "$1" = "-fw" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-fw,,'`
        fi
        ;;
    -*)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        VAL="unknown"
        ;;
    *)
        UNKNOWN_ARG=yes
        ;;
    esac
    if [ "$UNKNOWN_ARG" = "yes" ]; then
        echo "$1: unknown argument"
        OPT_HELP=yes
        ERROR=yes
        shift
        continue
     fi
    shift

    UNKNOWN_OPT=no
    case "$VAR" in
    qt3support)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_QT3SUPPORT="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    accessibility)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ACCESSIBILITY="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    license)
	LICENSE_FILE="$VAL"
	;;
    gnumake)
        CFG_USE_GNUMAKE="$VAL"
        ;;
    mysql_config)
	CFG_MYSQL_CONFIG="$VAL"
	;;
    prefix)
        QT_INSTALL_PREFIX="$VAL"
        ;;
    hostprefix)
	QT_HOST_PREFIX="$VAL"
	;;
    force-pkg-config)
        QT_FORCE_PKGCONFIG=yes
        ;;
    docdir)
        QT_INSTALL_DOCS="$VAL"
        ;;
    headerdir)
        QT_INSTALL_HEADERS="$VAL"
        ;;
    plugindir)
        QT_INSTALL_PLUGINS="$VAL"
        ;;
    importdir)
        QT_INSTALL_IMPORTS="$VAL"
        ;;
    datadir)
        QT_INSTALL_DATA="$VAL"
        ;;
    libdir)
        QT_INSTALL_LIBS="$VAL"
        ;;
    qtnamespace)
        QT_NAMESPACE="$VAL"
        ;;
    qtlibinfix)
        QT_LIBINFIX="$VAL"
        ;;
    translationdir)
        QT_INSTALL_TRANSLATIONS="$VAL"
        ;;
    sysconfdir|settingsdir)
        QT_INSTALL_SETTINGS="$VAL"
        ;;
    examplesdir)
        QT_INSTALL_EXAMPLES="$VAL"
        ;;
    demosdir)
        QT_INSTALL_DEMOS="$VAL"
        ;;
    qconfig)
        CFG_QCONFIG="$VAL"
        ;;
    bindir)
        QT_INSTALL_BINS="$VAL"
        ;;
    buildkey)
        CFG_USER_BUILD_KEY="$VAL"
        ;;
    sxe)
	CFG_SXE="$VAL"
        ;;
    embedded)
        CFG_EMBEDDED="$VAL"
        if [ "$PLATFORM_QWS" != "no" ]; then
            if [ "$PLATFORM_QWS" = "maybe" ]; then
                PLATFORM_X11=no
                PLATFORM_MAC=no
                PLATFORM_QWS=yes
                PLATFORM_QPA=no
            fi
        else
            echo "No license exists to enable Qt for Embedded Linux. Disabling."
            CFG_EMBEDDED=no
        fi
        ;;
    embedded-lite|qpa)
        CFG_EMBEDDED="no"
        if [ "$PLATFORM_QPA" != "no" ]; then
            if [ "$PLATFORM_QPA" = "maybe" ]; then
                PLATFORM_X11=no
                PLATFORM_MAC=no
                PLATFORM_QWS=no
                PLATFORM_QPA=yes
            fi
        else
            echo "No license exists to enable Qt QPA. Disabling."
            CFG_EMBEDDED=no
        fi
        ;;
    nacl)
        ;;
    sse)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SSE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
	;;
    endian)
        if [ "$VAL" = "little" ]; then
            CFG_ENDIAN="Q_LITTLE_ENDIAN"
        elif [ "$VAL" = "big" ]; then
            CFG_ENDIAN="Q_BIG_ENDIAN"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    host_endian)
        if [ "$VAL" = "little" ]; then
            CFG_HOST_ENDIAN="Q_LITTLE_ENDIAN"
        elif [ "$VAL" = "big" ]; then
            CFG_HOST_ENDIAN="Q_BIG_ENDIAN"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    armfpa)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ARMFPA="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    depths)
        CFG_QWS_DEPTHS="$VAL"
        ;;
    opengl)
        if  [ "$VAL" = "auto" ] || [ "$VAL" = "desktop" ] ||
            [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] ||
            [ "$VAL" = "es1" ] || [ "$VAL" = "es2" ]; then
            CFG_OPENGL="$VAL"
            if  [ "$VAL" = "es1" ] || [ "$VAL" = "es2" ]; then
                CFG_EGL="yes"
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    openvg)
        if [ "$VAL" = "auto" ] || [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_OPENVG="$VAL"
            CFG_EGL="auto"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    graphicssystem)
        if [ "$PLATFORM_QWS" = "yes" ]; then
            echo "Error: Graphics System plugins are not supported on QWS."
            echo "   On QWS, the graphics system API is part of the QScreen plugin architecture "
            echo "   rather than existing as a separate plugin."
            echo ""
            UNKNOWN_OPT=yes
        else
            if  [ "$VAL" = "opengl" ]; then
                CFG_GRAPHICS_SYSTEM="opengl"
            elif [ "$VAL" = "openvg" ]; then
                CFG_GRAPHICS_SYSTEM="openvg"
            elif [ "$VAL" = "raster" ]; then
                CFG_GRAPHICS_SYSTEM="raster"
            elif [ "$VAL" = "runtime" ]; then
                CFG_GRAPHICS_SYSTEM="runtime"
            else
                UNKNOWN_OPT=yes
            fi
        fi
	;;
    runtimegraphicssystem)
        if  [ "$VAL" != "runtime" ]; then
            CFG_RUNTIME_SYSTEM="$VAL"
        fi
	;;

    qvfb) # left for commandline compatibility, not documented
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            if [ "$VAL" = "yes" ]; then
		QMakeVar add gfx-drivers qvfb
		QMakeVar add kbd-drivers qvfb
		QMakeVar add mouse-drivers qvfb
                CFG_GFX_ON="$CFG_GFX_ON qvfb"
                CFG_KBD_ON="$CFG_KBD_ON qvfb"
                CFG_MOUSE_ON="$CFG_MOUSE_ON qvfb"
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    nomake)
	CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS $VAL"
        ;;
    make)
	CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
        ;;
    x11)
        if [ "$PLATFORM_MAC" = "yes" ]; then
            PLATFORM_MAC=no
        elif [ "$PLATFORM_QWS" = "yes" ]; then
            PLATFORM_QWS=no
        elif [ "$PLATFORM_QPA" = "yes" ]; then
            PLATFORM_QPA=no
        fi
        if [ "$CFG_FRAMEWORK" = "auto" ]; then
            CFG_FRAMEWORK=no
        fi
        PLATFORM_X11=yes
        ;;
    sdk)
        if [ "$PLATFORM_MAC" = "yes" ]; then
            CFG_SDK="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
	;;
     dwarf2)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_MAC_DWARF2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
	;;
    arch)
        # if this is a Mac then "windows" probably means
        # we are cross-compiling for MinGW
        if [ "$PLATFORM_MAC" = "yes" ] && [ "$VAL" != "windows" ]; then
            CFG_MAC_ARCHS="$CFG_MAC_ARCHS $VAL"
        else
            CFG_ARCH=$VAL
        fi
        ;;
    host-arch)
        CFG_HOST_ARCH=$VAL
        ;;
    universal)
        if [ "$PLATFORM_MAC" = "yes" ] && [ "$VAL" = "yes" ]; then
            CFG_MAC_ARCHS="$CFG_MAC_ARCHS x86 ppc"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    cocoa)
#       do nothing - Cocoa is the default.
        ;;
    carbon)
        if [ "$PLATFORM_MAC" = "yes" ] && [ "$VAL" = "yes" ]; then
            CFG_MAC_CARBON="$VAL"
            COMMANDLINE_MAC_CARBON="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;

    framework)
        if [ "$PLATFORM_MAC" = "yes" ]; then
            CFG_FRAMEWORK="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    profile)
        if [ "$VAL" = "yes" ]; then
            CFG_PROFILE=yes
	    QMakeVar add QMAKE_CFLAGS -pg
	    QMakeVar add QMAKE_CXXFLAGS -pg
	    QMakeVar add QMAKE_LFLAGS -pg
            QMAKE_VARS="$QMAKE_VARS CONFIG+=nostrip"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    exceptions|g++-exceptions)
        if [ "$VAL" = "no" ]; then
            CFG_EXCEPTIONS=no
        elif [ "$VAL" = "yes" ]; then
            CFG_EXCEPTIONS=yes
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    platform)
        PLATFORM="$VAL"
        # keep compatibility with old platform names
        case $PLATFORM in
        aix-64)
            PLATFORM=aix-xlc-64
            ;;
        hpux-o64)
            PLATFORM=hpux-acc-o64
            ;;
        hpux-n64)
            PLATFORM=hpux-acc-64
            ;;
        hpux-acc-n64)
            PLATFORM=hpux-acc-64
            ;;
        irix-n32)
            PLATFORM=irix-cc
            ;;
        irix-64)
            PLATFORM=irix-cc-64
            ;;
        irix-cc-n64)
            PLATFORM=irix-cc-64
            ;;
        reliant-64)
            PLATFORM=reliant-cds-64
            ;;
        solaris-64)
            PLATFORM=solaris-cc-64
            ;;
        openunix-cc)
            PLATFORM=unixware-cc
            ;;
        openunix-g++)
            PLATFORM=unixware-g++
            ;;
        unixware7-cc)
            PLATFORM=unixware-cc
            ;;
        unixware7-g++)
            PLATFORM=unixware-g++
            ;;
        macx-g++-64)
            PLATFORM=macx-g++
	    NATIVE_64_ARCH=
            case `uname -p` in
            i386) NATIVE_64_ARCH="x86_64" ;;
            powerpc) NATIVE_64_ARCH="ppc64" ;;
            *)   echo "WARNING: Can't detect CPU architecture for macx-g++-64" ;;
            esac
	    if [ ! -z "$NATIVE_64_ARCH" ]; then
		QTCONFIG_CONFIG="$QTCONFIG_CONFIG $NATIVE_64_ARCH"
		CFG_MAC_ARCHS="$CFG_MAC_ARCHS $NATIVE_64_ARCH"
            fi
            ;;
        esac
        ;;
    xplatform)
        XPLATFORM="$VAL"
        case `basename "$XPLATFORM"` in win32-g++*) XPLATFORM_MINGW=yes;; esac
        case "$XPLATFORM" in *symbian*) XPLATFORM_SYMBIAN=yes;; esac
        case "$XPLATFORM" in symbian-sbsv2) XPLATFORM_SYMBIAN_SBSV2=yes;; esac
        ;;
    debug-and-release)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_DEBUG_RELEASE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    optimized-qmake)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_RELEASE_QMAKE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    release)
        if [ "$VAL" = "yes" ]; then
            CFG_DEBUG=no
        elif [ "$VAL" = "no" ]; then
            CFG_DEBUG=yes
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    prefix-install)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
	    CFG_PREFIX_INSTALL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
	;;
    debug)
        CFG_DEBUG="$VAL"
        ;;
    developer-build|commercial|opensource|nokia-developer)
        # These switches have been dealt with already
        ;;
    static)
        if [ "$VAL" = "yes" ]; then
            CFG_SHARED=no
        elif [ "$VAL" = "no" ]; then
            CFG_SHARED=yes
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    incremental)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_INCREMENTAL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    fatal_error)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_CONFIGURE_EXIT_ON_ERROR="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    feature-*)
            FEATURE=`echo $VAR | sed "s,^[^-]*-\([^-]*\),\1," | tr 'abcdefghijklmnopqrstuvwxyz-' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'`
            if [ "$VAL" = "no" ]; then
                QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_$FEATURE"
            elif [ "$VAL" = "yes" ] || [ "$VAL" = "unknown" ]; then
                QCONFIG_FLAGS="$QCONFIG_FLAGS QT_$FEATURE"
            else
                UNKNOWN_OPT=yes
            fi
        ;;
    shared)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SHARED="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gif)
        if [ "$VAL" = "no" ]; then
            CFG_GIF="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sm)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SM="$VAL"
        else
            UNKNOWN_OPT=yes
        fi

        ;;
    xinerama)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
            CFG_XINERAMA="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xshape)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XSHAPE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xvideo)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XVIDEO="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xsync)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XSYNC="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xinput)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
            CFG_XINPUT="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    egl)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_EGL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    stl)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_STL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    pch)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PRECOMPILE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    separate-debug-info)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SEPARATE_DEBUG_INFO="$VAL"
        elif [ "$VAL" = "nocopy" ] ; then
            CFG_SEPARATE_DEBUG_INFO="yes"
            CFG_SEPARATE_DEBUG_INFO_NOCOPY="yes"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    reduce-exports)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_REDUCE_EXPORTS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    mmx)
        if [ "$VAL" = "no" ]; then
            CFG_MMX="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    3dnow)
        if [ "$VAL" = "no" ]; then
            CFG_3DNOW="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sse)
        if [ "$VAL" = "no" ]; then
            CFG_SSE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sse2)
        if [ "$VAL" = "no" ]; then
            CFG_SSE2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sse3)
        if [ "$VAL" = "no" ]; then
            CFG_SSE3="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    ssse3)
        if [ "$VAL" = "no" ]; then
            CFG_SSSE3="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sse4.1)
        if [ "$VAL" = "no" ]; then
            CFG_SSE4_1="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sse4.2)
        if [ "$VAL" = "no" ]; then
            CFG_SSE4_2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    avx)
        if [ "$VAL" = "no" ]; then
            CFG_AVX="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    iwmmxt)
	CFG_IWMMXT="yes"
	;;
    neon)
        if [ "$VAL" = "no" ]; then
            CFG_NEON="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    reduce-relocations)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_REDUCE_RELOCATIONS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    freetype)
        [ "$VAL" = "qt" ] && VAL=yes
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_QWS_FREETYPE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    zlib)
        [ "$VAL" = "qt" ] && VAL=yes
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_ZLIB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        # No longer supported:
        #[ "$VAL" = "no" ] && CFG_LIBPNG=no
        ;;
    s60)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_S60="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    usedeffiles)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SYMBIAN_DEFFILES="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sqlite)
        if [ "$VAL" = "system" ]; then
            CFG_SQLITE=system
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    libpng)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_LIBPNG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    libjpeg)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_LIBJPEG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    libmng)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_LIBMNG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    libtiff)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_LIBTIFF="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    nas-sound)
        if [ "$VAL" = "system" ] || [ "$VAL" = "no" ]; then
            CFG_NAS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xcursor)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
            CFG_XCURSOR="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xfixes)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
            CFG_XFIXES="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xrandr)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "runtime" ]; then
            CFG_XRANDR="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xrender)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XRENDER="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    mitshm)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_MITSHM="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    fontconfig)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_FONTCONFIG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xkb)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XKB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    cups)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_CUPS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    iconv)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ICONV="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    glib)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_GLIB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gstreamer)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_GSTREAMER="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gtkstyle)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_QGTKSTYLE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    style-s60)
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ]; then
            CFG_QS60STYLE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gui)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_GUI="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_GUI="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    qdbus|dbus)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "linked" ]; then
            CFG_DBUS="$VAL"
	elif [ "$VAL" = "runtime" ]; then
	    CFG_DBUS="yes"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    dbus-linked)
        if [ "$VAL" = "yes" ]; then
	    CFG_DBUS="linked"
	else
            UNKNOWN_OPT=yes
        fi
        ;;
    nis)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_NIS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    largefile)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_LARGEFILE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    openssl)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_OPENSSL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    openssl-linked)
        if [ "$VAL" = "yes" ]; then
            CFG_OPENSSL="linked"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    ptmalloc)
        if [ "$VAL" = "yes" ]; then
            CFG_PTMALLOC="yes"
        else
            UNKNOWN_OPT=yes
        fi
        ;;

    xmlpatterns)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_XMLPATTERNS="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_XMLPATTERNS="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    script)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_SCRIPT="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_SCRIPT="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    scripttools)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_SCRIPTTOOLS="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_SCRIPTTOOLS="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    svg)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_SVG="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_SVG="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    declarative)
        if [ "$VAL" = "yes" ]; then
            CFG_DECLARATIVE="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_DECLARATIVE="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
	;;
    declarative-debug)
        if [ "$VAL" = "yes" ]; then
            CFG_DECLARATIVE_DEBUG="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_DECLARATIVE_DEBUG="no"
            else
                UNKNOWN_OPT=yes
            fi
        fi
        ;;
    webkit)
        [ "$VAL" = "auto" ] && VAL="yes"
        CFG_WEBKIT="$VAL"
        ;;
    javascript-jit)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ] || [ "$VAL" = "no" ]; then 
            CFG_JAVASCRIPTCORE_JIT="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    confirm-license)
        if [ "$VAL" = "yes" ]; then
            OPT_CONFIRM_LICENSE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    h|help)
        if [ "$VAL" = "yes" ]; then
            OPT_HELP="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sql-*|gfx-*|decoration-*|kbd-*|mouse-*)
        # if Qt style options were used, $VAL can be "no", "qt", or "plugin"
        # if autoconf style options were used, $VAL can be "yes" or "no"
        [ "$VAL" = "yes" ] && VAL=qt
        # now $VAL should be "no", "qt", or "plugin"... double-check
        if [ "$VAL" != "no" ] && [ "$VAL" != "qt" ] && [ "$VAL" != "plugin" ]; then
            UNKNOWN_OPT=yes
        fi
        # now $VAL is "no", "qt", or "plugin"
        OPT="$VAL"
        VAL=`echo $VAR | sed "s,^[^-]*-\([^-]*\).*,\1,"`
        VAR=`echo $VAR | sed "s,^\([^-]*\).*,\1,"`

        # Grab the available values
        case "$VAR" in
        sql)
            avail="$CFG_SQL_AVAILABLE"
            ;;
        gfx)
            avail="$CFG_GFX_AVAILABLE"
	    if [ "$OPT" = "plugin" ]; then
		avail="$CFG_GFX_PLUGIN_AVAILABLE"
	    fi
            ;;
        decoration)
            avail="$CFG_DECORATION_AVAILABLE"
	    if [ "$OPT" = "plugin" ]; then
		avail="$CFG_DECORATION_PLUGIN_AVAILABLE"
	    fi
            ;;
        kbd)
            avail="$CFG_KBD_AVAILABLE"
	    if [ "$OPT" = "plugin" ]; then
		avail="$CFG_KBD_PLUGIN_AVAILABLE"
	    fi
            ;;
        mouse)
            avail="$CFG_MOUSE_AVAILABLE"
	    if [ "$OPT" = "plugin" ]; then
		avail="$CFG_MOUSE_PLUGIN_AVAILABLE"
	    fi
            ;;
        *)
            avail=""
            echo "BUG: Unhandled type $VAR used in $CURRENT_OPT"
            ;;
        esac

        # Check that that user's value is available.
        found=no
        for d in $avail; do
            if [ "$VAL" = "$d" ]; then
                found=yes
                break
            fi
        done
        [ "$found" = yes ] || ERROR=yes

        if [ "$VAR" = "sql" ]; then
            # set the CFG_SQL_driver
            eval "CFG_SQL_$VAL=\$OPT"
            continue
        fi

        if [ "$OPT" = "plugin" ] || [ "$OPT" = "qt" ]; then
            if [ "$OPT" = "plugin" ]; then
                [ "$VAR" = "decoration" ] && QMakeVar del "${VAR}s" "$VAL"
                [ "$VAR" = "decoration" ] && CFG_DECORATION_ON=`echo "${CFG_DECORATION_ON} " | sed "s,${VAL} ,,g"` && CFG_DECORATION_PLUGIN="$CFG_DECORATION_PLUGIN ${VAL}"
                [ "$VAR" = "kbd" ] && QMakeVar del "${VAR}s" "$VAL"
                [ "$VAR" = "kbd" ] && CFG_KBD_ON=`echo "${CFG_KBD_ON} " | sed "s,${VAL} ,,g"` && CFG_KBD_PLUGIN="$CFG_KBD_PLUGIN ${VAL}"
                [ "$VAR" = "mouse" ] && QMakeVar del "${VAR}s" "$VAL"
                [ "$VAR" = "mouse" ] && CFG_MOUSE_ON=`echo "${CFG_MOUSE_ON} " | sed "s,${VAL} ,,g"` && CFG_MOUSE_PLUGIN="$CFG_MOUSE_PLUGIN ${VAL}"
                [ "$VAR" = "gfx" ] && QMakeVar del "${VAR}s" "$VAL"
                [ "$VAR" = "gfx" ] && CFG_GFX_ON=`echo "${CFG_GFX_ON} " | sed "s,${VAL} ,,g"` && CFG_GFX_PLUGIN="${CFG_GFX_PLUGIN} ${VAL}"
                VAR="${VAR}-${OPT}"
            else
                if [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "decoration" ] || [ "$VAR" = "mouse" ]; then
                    [ "$VAR" = "gfx" ] && CFG_GFX_ON="$CFG_GFX_ON $VAL"
                    [ "$VAR" = "kbd" ] && CFG_KBD_ON="$CFG_KBD_ON $VAL"
		    [ "$VAR" = "decoration" ] && CFG_DECORATION_ON="$CFG_DECORATION_ON $VAL"
                    [ "$VAR" = "mouse" ] && CFG_MOUSE_ON="$CFG_MOUSE_ON $VAL"
                    VAR="${VAR}-driver"
                fi
            fi
	    QMakeVar add "${VAR}s" "${VAL}"
        elif [ "$OPT" = "no" ]; then
            PLUG_VAR="${VAR}-plugin"
            if [ "$VAR" = "gfx" ] || [ "$VAR" = "kbd" ] || [ "$VAR" = "mouse" ]; then
                IN_VAR="${VAR}-driver"
            else
                IN_VAR="${VAR}"
            fi
            [ "$VAR" = "decoration" ] && CFG_DECORATION_ON=`echo "${CFG_DECORATION_ON} " | sed "s,${VAL} ,,g"`
            [ "$VAR" = "gfx" ] && CFG_GFX_ON=`echo "${CFG_GFX_ON} " | sed "s,${VAL} ,,g"`
            [ "$VAR" = "kbd" ] && CFG_KBD_ON=`echo "${CFG_KBD_ON} " | sed "s,${VAL} ,,g"`
            [ "$VAR" = "mouse" ] && CFG_MOUSE_ON=`echo "${CFG_MOUSE_ON} " | sed "s,${VAL} ,,g"`
	    QMakeVar del "${IN_VAR}s" "$VAL"
	    QMakeVar del "${PLUG_VAR}s" "$VAL"
        fi
        if [ "$ERROR" = "yes" ]; then
           echo "$CURRENT_OPT: unknown argument"
           OPT_HELP=yes
        fi
        ;;
    v|verbose)
        if [ "$VAL" = "yes" ]; then
            if [ "$OPT_VERBOSE" = "$VAL" ]; then            # takes two verboses to turn on qmake debugs
                QMAKE_SWITCHES="$QMAKE_SWITCHES -d"
            else
                OPT_VERBOSE=yes
            fi
        elif [ "$VAL" = "no" ]; then
            if [ "$OPT_VERBOSE" = "$VAL" ] && echo "$QMAKE_SWITCHES" | grep ' -d' >/dev/null 2>&1; then
                QMAKE_SWITCHES=`echo $QMAKE_SWITCHES | sed "s, -d,,"`
            else
                OPT_VERBOSE=no
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    fast)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            OPT_FAST="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    rpath)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_RPATH="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    add_define)
        D_FLAGS="$D_FLAGS \"$VAL\""
        ;;
    add_ipath)
        I_FLAGS="$I_FLAGS -I\"${VAL}\""
        ;;
    add_lpath)
        L_FLAGS="$L_FLAGS -L\"${VAL}\""
        ;;
    add_rpath)
        RPATH_FLAGS="$RPATH_FLAGS \"${VAL}\""
        ;;
    add_link)
        l_FLAGS="$l_FLAGS -l\"${VAL}\""
        ;;
    add_fpath)
        if [ "$PLATFORM_MAC" = "yes" ]; then
            L_FLAGS="$L_FLAGS -F\"${VAL}\""
            I_FLAGS="$I_FLAGS -F\"${VAL}\""
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    add_framework)
        if [ "$PLATFORM_MAC" = "yes" ]; then
            l_FLAGS="$l_FLAGS -framework \"${VAL}\""
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    silent)
        CFG_SILENT="$VAL"
        ;;
    phonon)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PHONON="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    phonon-backend)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PHONON_BACKEND="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    multimedia)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_MULTIMEDIA="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    dont-process)
        CFG_NOPROCESS=yes
        ;;
    process)
        CFG_NOPROCESS=no
        ;;
    audio-backend)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_AUDIO_BACKEND="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    fpu)
       if [ "$VAL" != "no" ]; then
          QT_CFLAGS_FPU=$VAL
       fi
       ;;
    *)
        UNKNOWN_OPT=yes
        ;;
    esac
    if [ "$UNKNOWN_OPT" = "yes" ]; then
        echo "${CURRENT_OPT}: invalid command-line switch"
        OPT_HELP=yes
        ERROR=yes
    fi
done

if [ "$CFG_QCONFIG" != "full" ] && [ "$CFG_QT3SUPPORT" = "yes" ]; then
    echo "Warning: '-qconfig $CFG_QCONFIG' will disable the qt3support library."
    CFG_QT3SUPPORT="no"
fi
if [ "$CFG_GUI" = "no" ]; then
    echo "Warning: -no-gui will disable the qt3support library."
    CFG_QT3SUPPORT="no"
fi

#disable Qt3Support for Lighthouse
if [ "$PLATFORM_QPA" = "yes" ]; then
    CFG_QT3SUPPORT="no"
fi

# update QT_CONFIG to show our current predefined configuration
case "$CFG_QCONFIG" in
minimal|small|medium|large|full)
    # these are a sequence of increasing functionality
    for c in minimal small medium large full; do
        QT_CONFIG="$QT_CONFIG $c-config"
        [ "$CFG_QCONFIG" = $c ] && break
    done
    ;;
*)
    # not known to be sufficient for anything
    if [ '!' -f "$relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h" ] && [ '!' -f `"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"` ]; then
        echo >&2 "Error: configuration file not found:"
        echo >&2 "  $relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h"
        echo >&2 "  or"
        echo >&2 "  `"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"`"
        OPT_HELP=yes
    fi
esac

#-------------------------------------------------------------------------------
# build tree initialization
#-------------------------------------------------------------------------------

# where to find which..
unixtests="$relpath/config.tests/unix"
mactests="$relpath/config.tests/mac"
symbiantests="$relpath/config.tests/symbian"
WHICH="$unixtests/which.test"

PERL=`$WHICH perl 2>/dev/null`

# find out which awk we want to use, prefer gawk, then nawk, then regular awk
AWK=
for e in gawk nawk awk; do
    if "$WHICH" $e >/dev/null 2>&1 && ( $e -f /dev/null /dev/null ) >/dev/null 2>&1; then
        AWK=$e
        break
    fi
done

# find perl
PERL="/usr/bin/perl"
if "$WHICH" perl >/dev/null 2>&1 && ( perl /dev/null ) >/dev/null 2>&1; then
    PERL=`$WHICH perl`
fi

### skip this if the user just needs help...
if [ "$OPT_HELP" != "yes" ]; then

# is this a shadow build?
if [ "$OPT_SHADOW" = "maybe" ]; then
    OPT_SHADOW=no
    if [ "$relpath" != "$outpath" ] && [ '!' -f "$outpath/configure" ]; then
        if [ -h "$outpath" ]; then
            [ "$relpath" -ef "$outpath" ] || OPT_SHADOW=yes
        else
            OPT_SHADOW=yes
        fi
    fi
fi
if [ "$OPT_SHADOW" = "yes" ]; then
    if [ -f "$relpath/.qmake.cache" -o -f "$relpath/src/corelib/global/qconfig.h" -o -f "$relpath/src/corelib/global/qconfig.cpp" ]; then
        echo >&2 "You cannot make a shadow build from a source tree containing a previous build."
        echo >&2 "Cannot proceed."
        exit 1
    fi
    [ "$OPT_VERBOSE" = "yes" ] && echo "Performing shadow build..."
fi

if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
    echo
    echo "WARNING: -debug-and-release is not supported anymore on Qt/X11 and Qt for Embedded Linux"
    echo "Qt can be built in release mode with separate debug information, so"
    echo "-debug-and-release is not necessary anymore"
    echo
fi

# detect build style
if [ "$CFG_DEBUG" = "auto" ]; then
    if [ "$PLATFORM_MAC" = "yes" -o "$XPLATFORM_MINGW" = "yes" ]; then
        CFG_DEBUG_RELEASE=yes
        CFG_DEBUG=yes
    elif [ "$CFG_DEV" = "yes" ]; then
        CFG_DEBUG_RELEASE=no
        CFG_DEBUG=yes
    else
        CFG_DEBUG_RELEASE=no
        CFG_DEBUG=no
    fi
fi
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG build_all"
fi

if [ "$CFG_SILENT" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG silent"
fi

# if the source tree is different from the build tree,
# symlink or copy part of the sources
if [ "$OPT_SHADOW" = "yes" ]; then
    echo "Preparing build tree..."

    if [ -z "$PERL" ]; then
        echo
        echo "You need perl in your PATH to make a shadow build."
        echo "Cannot proceed."
        exit 1
    fi

    [ -d "$outpath/bin" ] || mkdir -p "$outpath/bin"

    # symlink the qmake directory
    find "$relpath/qmake" | while read a; do
        my_a=`echo "$a" | sed "s,^${relpath}/,${outpath}/,"`
        if [ '!' -f "$my_a" ]; then
            if [ -d "$a" ]; then
                # directories are created...
                mkdir -p "$my_a"
            else
                a_dir=`dirname "$my_a"`
                [ -d "$a_dir" ] || mkdir -p "$a_dir"
                # ... and files are symlinked
                case `basename "$a"` in
                *.o|*.d|GNUmakefile*|qmake)
                    ;;
                *)
                    rm -f "$my_a"
                    ln -s "$a" "$my_a"
                    ;;
                esac
            fi
        fi
    done

    # make a syncqt script that can be used in the shadow
    rm -f "$outpath/bin/syncqt"
    if [ -x "$relpath/bin/syncqt" ]; then
        mkdir -p "$outpath/bin"
        echo "#!/bin/sh" >"$outpath/bin/syncqt"
        echo "QTDIR=\"$relpath\"; export QTDIR" >>"$outpath/bin/syncqt"
        echo "perl \"$relpath/bin/syncqt\" -outdir \"$outpath\" \"\$@\"" >>"$outpath/bin/syncqt"
        chmod 755 "$outpath/bin/syncqt"
    fi

    for i in elf2e32_qtwrapper createpackage patch_capabilities; do
        rm -f "$outpath/bin/$i"
        if [ -x "$relpath/bin/$i" ]; then
            mkdir -p "$outpath/bin"
            echo "#!/bin/sh" >"$outpath/bin/$i"
            echo "QTDIR=\"$relpath\"; export QTDIR" >>"$outpath/bin/$i"
            echo "\"$relpath/bin/$i\" \"\$@\"" >>"$outpath/bin/$i"
            chmod 755 "$outpath/bin/$i"
        fi
    done

    # symlink the mkspecs directory
    mkdir -p "$outpath/mkspecs"
    rm -rf "$outpath"/mkspecs/*
    ln -s "$relpath"/mkspecs/* "$outpath/mkspecs"
    rm -f "$outpath/mkspecs/default"

    ShadowMkspecs()
    {
        rm -rf "$outpath/mkspecs/$1"
        find "$relpath/mkspecs/$1" -type d | sed "s,^$relpath,$outpath," | xargs mkdir -p
        find "$relpath/mkspecs/$1" -type f | sed "s,^$relpath/,," | while read f; do ln -s "$relpath/$f" "$outpath/$f"; done
    }

    # Special case for mkspecs/features directory.
    # To be able to place .prf files into a shadow build directory,
    # we're creating links for files only. The directory structure is reproduced.
    ShadowMkspecs features

    # The modules dir is special, too.
    ShadowMkspecs modules

    # symlink the doc directory
    rm -rf "$outpath/doc"
    ln -s "$relpath/doc" "$outpath/doc"

    # make sure q3porting.xml can be found
    mkdir -p "$outpath/tools/porting/src"
    rm -f "$outpath/tools/porting/src/q3porting.xml"
    ln -s "$relpath/tools/porting/src/q3porting.xml" "$outpath/tools/porting/src"
fi

# symlink fonts to be able to run application from build directory
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ] && [ ! -d "${outpath}/lib/fonts" ]; then
    if [ "$PLATFORM" = "$XPLATFORM" ]; then
        mkdir -p "${outpath}/lib"
        ln -s "${relpath}/lib/fonts" "${outpath}/lib/fonts"
    fi
fi

if [ "$OPT_FAST" = "auto" ]; then
   if [ '!' -z "$AWK" ] && [ "$CFG_DEV" = "yes" ]; then
       OPT_FAST=yes
   else
       OPT_FAST=no
   fi
fi

# find a make command
if [ -z "$MAKE" ]; then
    MAKE=
    for mk in gmake make; do
        if "$WHICH" $mk >/dev/null 2>&1; then
            MAKE=`"$WHICH" $mk`
            break
        fi
    done
    if [ -z "$MAKE" ]; then
        echo >&2 "You don't seem to have 'make' or 'gmake' in your PATH."
        echo >&2 "Cannot proceed."
        exit 1
    fi
    # export MAKE, we need it later in the config.tests
    export MAKE
fi

fi ### help

#-------------------------------------------------------------------------------
# auto-detect all that hasn't been specified in the arguments
#-------------------------------------------------------------------------------

[ "$PLATFORM_QWS" = "yes" -a "$CFG_EMBEDDED" = "no" ] && CFG_EMBEDDED=auto
if [ "$CFG_EMBEDDED" != "no" ]; then
    case "$UNAME_SYSTEM:$UNAME_RELEASE" in
    Darwin:*)
        [ -z "$PLATFORM" ] && PLATFORM=qws/macx-generic-g++
        if [ -z "$XPLATFORM" ]; then
            [ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
            XPLATFORM="qws/macx-$CFG_EMBEDDED-g++"
        fi
        ;;
    FreeBSD:*)
        [ -z "$PLATFORM" ] && PLATFORM=qws/freebsd-generic-g++
        if [ -z "$XPLATFORM" ]; then
            [ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
            XPLATFORM="qws/freebsd-$CFG_EMBEDDED-g++"
        fi
        ;;
    SunOS:5*)
        [ -z "$PLATFORM" ] && PLATFORM=qws/solaris-generic-g++
        if [ -z "$XPLATFORM" ]; then
            [ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
            XPLATFORM="qws/solaris-$CFG_EMBEDDED-g++"
        fi
        ;;
    Linux:*)
        if [ -z "$PLATFORM" ]; then
            case "$UNAME_MACHINE" in
            *86)
                PLATFORM=qws/linux-x86-g++
                ;;
            *86_64)
                PLATFORM=qws/linux-x86_64-g++
                ;;
            *)
                PLATFORM=qws/linux-generic-g++
                ;;
            esac
        fi
        if [ -z "$XPLATFORM" ]; then
            if [ "$CFG_EMBEDDED" = "auto" ]; then
                if [ -n "$CFG_ARCH" ]; then
                    CFG_EMBEDDED=$CFG_ARCH
                else
                    case "$UNAME_MACHINE" in
                    *86)
                        CFG_EMBEDDED=x86
                        ;;
                    *86_64)
                        CFG_EMBEDDED=x86_64
                        ;;
                    *)
                        CFG_EMBEDDED=generic
                        ;;
                    esac
                fi
            fi
            XPLATFORM="qws/linux-$CFG_EMBEDDED-g++"
        fi
        ;;
    QNX:*)
        [ -z "$PLATFORM" ] && PLATFORM=unsupported/qws/qnx-generic-g++
        if [ -z "$XPLATFORM" ]; then
            [ "$CFG_EMBEDDED" = "auto" ] && CFG_EMBEDDED=generic
            XPLATFORM="unsupported/qws/qnx-$CFG_EMBEDDED-g++"
        fi
        ;;
    CYGWIN*:*)
	if [ -z "$XPLATFORM" ]; then
		CFG_EMBEDDED=x86
	fi
	;;
    *)
        echo "Qt for Embedded Linux is not supported on this platform. Disabling."
        CFG_EMBEDDED=no
        PLATFORM_QWS=no
        PLATFORM_QPA=no
        ;;
    esac
fi
if [ -z "$PLATFORM" ]; then
    PLATFORM_NOTES=
    case "$UNAME_SYSTEM:$UNAME_RELEASE" in
     Darwin:*)
        if [ "$PLATFORM_MAC" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
          PLATFORM=macx-g++
        # PLATFORM=macx-xcode
        else
          PLATFORM=darwin-g++
        fi
        ;;
     AIX:*)
        #PLATFORM=aix-g++
        #PLATFORM=aix-g++-64
        PLATFORM=aix-xlc
        #PLATFORM=aix-xlc-64
        PLATFORM_NOTES="
            - Also available for AIX: aix-g++ aix-g++-64 aix-xlc-64
        "
        ;;
     GNU:*)
        PLATFORM=hurd-g++
        ;;
     dgux:*)
        PLATFORM=dgux-g++
        ;;
#     DYNIX/ptx:4*)
#       PLATFORM=dynix-g++
#       ;;
     ULTRIX:*)
        PLATFORM=ultrix-g++
        ;;
     FreeBSD:*)
        PLATFORM=freebsd-g++
        PLATFORM_NOTES="
            - Also available for FreeBSD: freebsd-icc
        "
        ;;
     OpenBSD:*)
        PLATFORM=openbsd-g++
        ;;
     NetBSD:*)
        PLATFORM=netbsd-g++
        ;;
     BSD/OS:*|BSD/386:*)
        PLATFORM=bsdi-g++
        ;;
     IRIX*:*)
        #PLATFORM=irix-g++
        PLATFORM=irix-cc
        #PLATFORM=irix-cc-64
        PLATFORM_NOTES="
            - Also available for IRIX: irix-g++ irix-cc-64
        "
        ;;
     HP-UX:*)
        case "$UNAME_MACHINE" in
            ia64)
                #PLATFORM=hpuxi-acc-32
                PLATFORM=hpuxi-acc-64
                PLATFORM_NOTES="
                    - Also available for HP-UXi: hpuxi-acc-32
                "
            ;;
            *)
                #PLATFORM=hpux-g++
                PLATFORM=hpux-acc
                #PLATFORM=hpux-acc-64
                #PLATFORM=hpux-cc
                #PLATFORM=hpux-acc-o64
                PLATFORM_NOTES="
                    - Also available for HP-UX: hpux-g++ hpux-acc-64 hpux-acc-o64
                "
            ;;
        esac
        ;;
     OSF1:*)
        #PLATFORM=tru64-g++
        PLATFORM=tru64-cxx
        PLATFORM_NOTES="
            - Also available for Tru64: tru64-g++
        "
        ;;
     Linux:*)
        case "$UNAME_MACHINE" in
            x86_64|s390x|ppc64)
                PLATFORM=linux-g++-64
                ;;
            *)
                PLATFORM=linux-g++
                ;;
        esac
        PLATFORM_NOTES="
            - Also available for Linux: linux-kcc linux-icc linux-cxx
        "
        ;;
     SunOS:5*)
        if [ "$XPLATFORM_MINGW" = "yes" ]; then
            PLATFORM="solaris-g++"
        else
            #PLATFORM=solaris-g++
            PLATFORM=solaris-cc
            #PLATFORM=solaris-cc64
        fi
        PLATFORM_NOTES="
            - Also available for Solaris: solaris-g++ solaris-cc-64
        "
        ;;
     ReliantUNIX-*:*|SINIX-*:*)
        PLATFORM=reliant-cds
        #PLATFORM=reliant-cds-64
        PLATFORM_NOTES="
            - Also available for Reliant UNIX: reliant-cds-64
        "
        ;;
     CYGWIN*:*)
        PLATFORM=cygwin-g++
        ;;
     LynxOS*:*)
        PLATFORM=lynxos-g++
        ;;
     OpenUNIX:*)
        #PLATFORM=unixware-g++
        PLATFORM=unixware-cc
        PLATFORM_NOTES="
            - Also available for OpenUNIX: unixware-g++
        "
        ;;
     UnixWare:*)
        #PLATFORM=unixware-g++
        PLATFORM=unixware-cc
        PLATFORM_NOTES="
            - Also available for UnixWare: unixware-g++
        "
        ;;
     SCO_SV:*)
        #PLATFORM=sco-g++
        PLATFORM=sco-cc
        PLATFORM_NOTES="
            - Also available for SCO OpenServer: sco-g++
        "
        ;;
     UNIX_SV:*)
        PLATFORM=unixware-g++
        ;;
     QNX:*)
        PLATFORM=unsupported/qnx-g++
        ;;
     *)
        if [ "$OPT_HELP" != "yes" ]; then
            echo
            for p in $PLATFORMS; do
                echo "    $relconf $* -platform $p"
            done
            echo >&2
            echo "   The build script does not currently recognize all" >&2
            echo "   platforms supported by Qt." >&2
            echo "   Rerun this script with a -platform option listed to" >&2
            echo "   set the system/compiler combination you use." >&2
            echo >&2
            exit 2
        fi
    esac
fi

if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    CFG_SM=no
    PLATFORMS=`find "$relpath/mkspecs/qws" | sed "s,$relpath/mkspecs/qws/,,"`
else
    PLATFORMS=`find "$relpath/mkspecs/" -type f | grep -v qws | sed "s,$relpath/mkspecs/qws/,,"`
fi

[ -z "$XPLATFORM" ] && XPLATFORM="$PLATFORM"

case `basename "$XPLATFORM"` in win32-g++*) XPLATFORM_MINGW=yes;; esac
case "$XPLATFORM" in *symbian*) XPLATFORM_SYMBIAN=yes;; esac
case "$XPLATFORM" in symbian-sbsv2) XPLATFORM_SYMBIAN_SBSV2=yes;; esac

if [ -d "$PLATFORM" ]; then
  QMAKESPEC="$PLATFORM"
else
  QMAKESPEC="$relpath/mkspecs/${PLATFORM}"
fi
if [ -d "$XPLATFORM" ]; then
  XQMAKESPEC="$XPLATFORM"
else
  XQMAKESPEC="$relpath/mkspecs/${XPLATFORM}"
fi
if [ "$PLATFORM" != "$XPLATFORM" ]; then
    QT_CROSS_COMPILE=yes
    QMAKE_CONFIG="$QMAKE_CONFIG cross_compile"
fi

if [ "$PLATFORM_MAC" = "yes" ]; then
   if [ `basename $QMAKESPEC` = "macx-xcode" ] || [ `basename $XQMAKESPEC` = "macx-xcode" ]; then
      echo >&2
      echo "   Platform 'macx-xcode' should not be used when building Qt/Mac." >&2
      echo "   Please build Qt/Mac with 'macx-g++', then if you would like to" >&2
      echo "   use mac-xcode on your application code it can link to a Qt/Mac" >&2
      echo "   built with 'macx-g++'" >&2
      echo >&2
      exit 2
    fi
fi

# check specified platforms are supported
if [ '!' -d "$QMAKESPEC" ]; then
    echo
    echo "   The specified system/compiler is not supported:"
    echo
    echo "      $QMAKESPEC"
    echo
    echo "   Please see the README file for a complete list."
    echo
    exit 2
fi
if [ '!' -d "$XQMAKESPEC" ]; then
    echo
    echo "   The specified system/compiler is not supported:"
    echo
    echo "      $XQMAKESPEC"
    echo
    echo "   Please see the README file for a complete list."
    echo
    exit 2
fi
if [ '!' -f "${XQMAKESPEC}/qplatformdefs.h" ]; then
    echo
    echo "   The specified system/compiler port is not complete:"
    echo
    echo "      $XQMAKESPEC/qplatformdefs.h"
    echo
    echo "   Please contact qt-bugs@trolltech.com."
    echo
    exit 2
fi

# now look at the configs and figure out what platform we are config'd for
[ "$CFG_EMBEDDED" = "no" ] && [ "$PLATFORM_QPA" != "yes" ] \
  && [ '!' -z "`getQMakeConf \"$XQMAKESPEC\" | grep QMAKE_LIBS_X11 | awk '{print $3;}'`" ] \
  && PLATFORM_X11=yes
### echo "$XQMAKESPEC" | grep mkspecs/qws >/dev/null 2>&1 && PLATFORM_QWS=yes

if [ "$UNAME_SYSTEM" = "SunOS" ]; then
    # Solaris 2.5 and 2.6 have libposix4, which was renamed to librt for Solaris 7 and up
    if echo $UNAME_RELEASE | grep "^5\.[5|6]" >/dev/null 2>&1; then
        sed -e "s,-lrt,-lposix4," "$XQMAKESPEC/qmake.conf" > "$XQMAKESPEC/qmake.conf.new"
        mv "$XQMAKESPEC/qmake.conf.new" "$XQMAKESPEC/qmake.conf"
    fi
fi

#-------------------------------------------------------------------------------
# determine the system architecture
#-------------------------------------------------------------------------------
if [ "$OPT_VERBOSE" = "yes" ]; then
    echo "Determining system architecture... ($UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_MACHINE)"
fi

if [ "$CFG_EMBEDDED" != "no" -a "$CFG_EMBEDDED" != "auto" ] && [ -n "$CFG_ARCH" ]; then
    if [ "$CFG_ARCH" != "$CFG_EMBEDDED" ]; then
        echo ""
        echo "You have specified a target architecture with -embedded and -arch."
        echo "The two architectures you have specified are different, so we can"
        echo "not proceed. Either set both to be the same, or only use -embedded."
        echo ""
        exit 1
    fi
fi

if [ "$CFG_RTOS_ENABLED" = "no" ]; then
    case `basename "$XPLATFORM"` in
	qnx-* | vxworks-*)
            echo ""
            echo "You are not licensed for Qt for `basename $XPLATFORM`."
            echo ""
            echo "Please contact qt-info@nokia.com to upgrade your license to"
            echo "include this platform, or install the Qt Open Source Edition"
            echo "if you intend to develop free software."
            exit 1
	    ;;
    esac
fi

if [ -z "${CFG_HOST_ARCH}" ]; then
    case "$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_MACHINE" in
    GNU:*:*)
        CFG_HOST_ARCH=`echo ${UNAME_MACHINE} | sed -e 's,[-/].*$,,'`
        case "$CFG_HOST_ARCH" in
            i?86)
                CFG_HOST_ARCH=i386
                ;;
        esac
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    GNU/Hurd ($CFG_HOST_ARCH)"
        fi
        ;;
    IRIX*:*:*)
        CFG_HOST_ARCH=`uname -p`
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    SGI ($CFG_HOST_ARCH)"
        fi
        ;;
    SunOS:5*:*)
        case "$UNAME_MACHINE" in
	sun4u*|sun4v*)
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo "    Sun SPARC (sparc)"
            fi
            CFG_HOST_ARCH=sparc
            ;;
        i86pc)
	    case "$PLATFORM" in
	    *-64*)
                if [ "$OPT_VERBOSE" = "yes" ]; then
	            echo "    64-bit AMD 80x86 (x86_64)"
                fi
                CFG_HOST_ARCH=x86_64
                ;;
	    *)
                if [ "$OPT_VERBOSE" = "yes" ]; then
	            echo "    32-bit Intel 80x86 (i386)"
                fi
                CFG_HOST_ARCH=i386
                ;;
            esac
        esac
        ;;
    Darwin:*:*)
        case "$UNAME_MACHINE" in
            Power?Macintosh)
                if [ "$OPT_VERBOSE" = "yes" ]; then
                    echo "    32-bit Apple PowerPC (powerpc)"
                fi
                ;;
            x86)
                if [ "$OPT_VERBOSE" = "yes" ]; then
                    echo "    32-bit Intel 80x86 (i386)"
                fi
                ;;
        esac
        CFG_HOST_ARCH=macosx
        ;;
    AIX:*:00????????00)
        if [ "$OPT_VERBOSE" = "yes" ]; then
        echo "    64-bit IBM PowerPC (powerpc)"
        fi
        CFG_HOST_ARCH=powerpc
        ;;
    HP-UX:*:9000*)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    HP PA-RISC (parisc)"
        fi
        CFG_HOST_ARCH=parisc
        ;;
    *:*:i?86)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    32-bit Intel 80x86 (i386)"
        fi
        CFG_HOST_ARCH=i386
        ;;
    *:*:x86_64|*:*:amd64)
        if [ "$PLATFORM" = "linux-g++-32" -o "$PLATFORM" = "linux-icc-32" ]; then
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo "    32 bit on 64-bit AMD 80x86 (i386)"
            fi
            CFG_HOST_ARCH=i386
        else
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo "    64-bit AMD 80x86 (x86_64)"
            fi
            CFG_HOST_ARCH=x86_64
        fi
        ;;
    *:*:ppc)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    32-bit PowerPC (powerpc)"
        fi
        CFG_HOST_ARCH=powerpc
        ;;
    *:*:ppc64)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    64-bit PowerPC (powerpc)"
        fi
        CFG_HOST_ARCH=powerpc
        ;;
    *:*:s390*)
    	if [ "$OPT_VERBOSE" = "yes" ]; then
    	    echo "    IBM S/390 (s390)"
    	fi
    	CFG_HOST_ARCH=s390
    	;;
    *:*:arm*)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    ARM (arm)"
        fi
        CFG_HOST_ARCH=arm
        ;;
    Linux:*:sparc*)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    Linux on SPARC"
        fi
        CFG_HOST_ARCH=sparc
        ;;
    QNX:*:*)
        case "$UNAME_MACHINE" in
        x86pc)
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo "    QNX on Intel 80x86 (i386)"
            fi
            CFG_HOST_ARCH=i386
            ;;
        esac
        ;;
    *:*:*)
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    Trying '$UNAME_MACHINE'..."
        fi
        CFG_HOST_ARCH="$UNAME_MACHINE"
        ;;
    esac
fi

if [ "$PLATFORM" != "$XPLATFORM" -a "$CFG_EMBEDDED" != "no" ]; then
    if [ -n "$CFG_ARCH" ]; then
        CFG_EMBEDDED=$CFG_ARCH
    fi

    case "$CFG_EMBEDDED" in
    x86)
        CFG_ARCH=i386
        ;;
    x86_64)
        CFG_ARCH=x86_64
        ;;
    ipaq|sharp)
        CFG_ARCH=arm
        ;;
    dm7000)
        CFG_ARCH=powerpc
        ;;
    dm800)
        CFG_ARCH=mips
        ;;
    sh4al)
        CFG_ARCH=sh4a
        ;;
    arm*)
        CFG_ARCH=arm
        ;;
    *)
        CFG_ARCH="$CFG_EMBEDDED"
        ;;
    esac
elif [ "$XPLATFORM_MINGW" = "yes" ]; then
    [ -z "$CFG_ARCH" ] && CFG_ARCH="windows"
elif [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    CFG_ARCH=symbian
elif [ "$PLATFORM_MAC" = "yes" ] || [ -z "$CFG_ARCH" ]; then
    CFG_ARCH=$CFG_HOST_ARCH
fi

# for compatibility
COMPAT_ARCH=
case "$CFG_ARCH" in
arm*)
    # previously, armv6 was a different arch
    CFG_ARCH=arm
    COMPAT_ARCH=armv6
    ;;
esac

if [ -d "$relpath/src/corelib/arch/$CFG_ARCH" ]; then
    if [ "$OPT_VERBOSE" = "yes" ]; then
        echo "    '$CFG_ARCH' is supported"
    fi
else
    if [ "$OPT_VERBOSE" = "yes" ]; then
        echo "    '$CFG_ARCH' is unsupported, using 'generic'"
    fi
    CFG_ARCH=generic
fi
if [ "$CFG_HOST_ARCH" != "$CFG_ARCH" ]; then
    if [ -d "$relpath/src/corelib/arch/$CFG_HOST_ARCH" ]; then
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    '$CFG_HOST_ARCH' is supported"
        fi
    else
        if [ "$OPT_VERBOSE" = "yes" ]; then
            echo "    '$CFG_HOST_ARCH' is unsupported, using 'generic'"
        fi
        CFG_HOST_ARCH=generic
    fi
fi

if [ "$OPT_VERBOSE" = "yes" ]; then
    echo "System architecture: '$CFG_ARCH'"
    if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
	echo "Host architecture: '$CFG_HOST_ARCH'"
    fi
fi

#-------------------------------------------------------------------------------
# tests that don't need qmake (must be run before displaying help)
#-------------------------------------------------------------------------------

if [ -z "$PKG_CONFIG" ]; then
    # See if PKG_CONFIG is set in the mkspec:
    PKG_CONFIG=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%PKG_CONFIG[^_].*=%%p' | tr '\n' ' '`
fi
if [ -z "$PKG_CONFIG" ]; then
    PKG_CONFIG=`"$WHICH" pkg-config 2>/dev/null`
fi

# Work out if we can use pkg-config
if [ "$QT_CROSS_COMPILE" = "yes" ]; then
    if [ "$QT_FORCE_PKGCONFIG" = "yes" ]; then
        echo >&2 ""
        echo >&2 "You have asked to use pkg-config and are cross-compiling."
        echo >&2 "Please make sure you have a correctly set-up pkg-config"
        echo >&2 "environment!"
        echo >&2 ""
        if [ -z "$PKG_CONFIG_PATH" ]; then
            echo >&2 ""
            echo >&2 "Warning: PKG_CONFIG_PATH has not been set.  This could mean"
            echo >&2 "the host compiler's .pc files will be used. This is probably"
            echo >&2 "not what you want."
            echo >&2 ""
        elif [ -z "$PKG_CONFIG_SYSROOT" ] && [ -z "$PKG_CONFIG_SYSROOT_DIR" ]; then
            echo >&2 ""
            echo >&2 "Warning: PKG_CONFIG_SYSROOT/PKG_CONFIG_SYSROOT_DIR has not"
            echo >&2 "been set. This means your toolchain's .pc files must contain"
            echo >&2 "the paths to the toolchain's libraries & headers. If configure"
            echo >&2 "tests are failing, please check these files."
            echo >&2 ""
        fi
    else
        echo >&2 ""
        echo >&2 "You have not explicitly asked to use pkg-config and are cross-compiling."
        echo >&2 "pkg-config will not be used to automatically query cflag/lib parameters for"
        echo >&2 "dependencies"
        echo >&2 ""
        PKG_CONFIG=""
    fi
fi

# process CFG_MAC_ARCHS
if [ "$PLATFORM_MAC" = "yes" ]; then
#   check -arch arguments for validity.
    ALLOWED="x86 ppc x86_64 ppc64 i386"
    # Save the list so we can re-write it using only valid values
    CFG_MAC_ARCHS_IN="$CFG_MAC_ARCHS"
    CFG_MAC_ARCHS=
    for i in $CFG_MAC_ARCHS_IN
    do 
        if echo "$ALLOWED" | grep -w -v "$i" > /dev/null 2>&1; then
            echo "Unknown architecture: \"$i\". Supported architectures: x86[i386] ppc x86_64 ppc64";
            exit 2;
        fi
        if [ "$i" = "i386" -o "$i" = "x86" ]; then
            # These are synonymous values
            # CFG_MAC_ARCHS requires x86 while GCC requires i386
            CFG_MAC_ARCHS="$CFG_MAC_ARCHS x86"
            MAC_CONFIG_TEST_COMMANDLINE="$MAC_CONFIG_TEST_COMMANDLINE -arch i386"
        else
            CFG_MAC_ARCHS="$CFG_MAC_ARCHS $i"
            MAC_CONFIG_TEST_COMMANDLINE="$MAC_CONFIG_TEST_COMMANDLINE -arch $i"
        fi
    done
fi

# pass on $CFG_SDK to the configure tests.
if [ '!' -z "$CFG_SDK" ]; then
    MAC_CONFIG_TEST_COMMANDLINE="$MAC_CONFIG_TEST_COMMANDLINE -sdk $CFG_SDK"
fi

# find the default framework value
if [ "$PLATFORM_MAC" = "yes" ] && [ "$PLATFORM" != "macx-xlc" ]; then
    if [ "$CFG_FRAMEWORK" = "auto" ]; then
        CFG_FRAMEWORK="$CFG_SHARED"
    elif [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_SHARED" = "no" ]; then
	echo
	echo "WARNING: Using static linking will disable the use of Mac frameworks."
	echo
        CFG_FRAMEWORK="no"
    fi
else
    CFG_FRAMEWORK=no
fi

QMAKE_CONF_COMPILER=`getQMakeConf "$XQMAKESPEC" | grep "^QMAKE_CXX[^_A-Z0-9]" | sed "s,.* *= *\(.*\)$,\1," | tail -1`
TEST_COMPILER="$CXX"

[ -z "$TEST_COMPILER" ] && TEST_COMPILER=$QMAKE_CONF_COMPILER
if [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
    #for Symbian we don't need this checking
    if [ -z "$TEST_COMPILER" ]; then
        echo "ERROR: Cannot set the compiler for the configuration tests"
        exit 1
    fi
fi

if [ "$CFG_EMBEDDED" = "nacl" ]; then
    TEST_COMPILER="nacl-gcc"
fi

# auto-detect precompiled header support
if [ "$CFG_PRECOMPILE" = "auto" ]; then
    if [ `echo "$CFG_MAC_ARCHS" | wc -w` -gt 1 ]; then
       CFG_PRECOMPILE=no
    elif "$unixtests/precomp.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
       CFG_PRECOMPILE=no
    else
       CFG_PRECOMPILE=yes
    fi
elif [ "$CFG_PRECOMPILE" = "yes" ] && [ `echo "$CFG_MAC_ARCHS" | wc -w` -gt 1 ]; then
    echo
    echo "WARNING: Using universal binaries disables precompiled headers."
    echo
    CFG_PRECOMPILE=no
fi

#auto-detect DWARF2 on the mac
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_DWARF2" = "auto" ]; then
    if "$mactests/dwarf2.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests" ; then
        CFG_MAC_DWARF2=no
    else
        CFG_MAC_DWARF2=yes
    fi
fi

# auto-detect support for -Xarch on the mac
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_XARCH" = "auto" ]; then
    if "$mactests/xarch.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests" ; then
        CFG_MAC_XARCH=no
    else
        CFG_MAC_XARCH=yes
    fi
fi

# don't autodetect support for separate debug info on objcopy when
# cross-compiling as lots of toolchains seems to have problems with this
if [ "$QT_CROSS_COMPILE" = "yes" ] && [ "$CFG_SEPARATE_DEBUG_INFO" = "auto" ]; then
    CFG_SEPARATE_DEBUG_INFO="no"
fi

# auto-detect support for separate debug info in objcopy
if [ "$CFG_SEPARATE_DEBUG_INFO" != "no" ] && [ "$CFG_SHARED" = "yes" ]; then
    TEST_COMPILER_CFLAGS=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%QMAKE_CFLAGS[^_=]*[+*]*=%%p' | tr '\n' ' '`
    TEST_COMPILER_CXXFLAGS=`getQMakeConf "$XQMAKESPEC" | sed -n -e 's%QMAKE_CXXFLAGS[^_=]*[+*]*=%%p' | tr '\n' ' '`
    TEST_OBJCOPY=`getQMakeConf "$XQMAKESPEC" | grep "^QMAKE_OBJCOPY" | sed "s%.* *= *\(.*\)$%\1%" | tail -1`
    COMPILER_WITH_FLAGS="$TEST_COMPILER $TEST_COMPILER_CXXFLAGS"
    COMPILER_WITH_FLAGS=`echo "$COMPILER_WITH_FLAGS" | sed -e "s%\\$\\$QMAKE_CFLAGS%$TEST_COMPILER_CFLAGS%g"`
    if "$unixtests/objcopy.test" "$COMPILER_WITH_FLAGS" "$TEST_OBJCOPY" "$OPT_VERBOSE"; then
       CFG_SEPARATE_DEBUG_INFO=no
    else
       case "$PLATFORM" in
       hpux-*)
           # binutils on HP-UX is buggy; default to no.
           CFG_SEPARATE_DEBUG_INFO=no
           ;;
       *)
           CFG_SEPARATE_DEBUG_INFO=yes
           ;;
       esac
    fi
fi

# auto-detect -fvisibility support
if [ "$CFG_REDUCE_EXPORTS" = "auto" ]; then
    if "$unixtests/fvisibility.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
       CFG_REDUCE_EXPORTS=no
    else
       CFG_REDUCE_EXPORTS=yes
    fi
fi

# detect the availability of the -Bsymbolic-functions linker optimization
if [ "$CFG_REDUCE_RELOCATIONS" != "no" ]; then
    if "$unixtests/bsymbolic_functions.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
        CFG_REDUCE_RELOCATIONS=no
    else
        CFG_REDUCE_RELOCATIONS=yes
    fi
fi

# auto-detect GNU make support
if [ "$CFG_USE_GNUMAKE" = "auto" ] && "$MAKE" -v | grep "GNU Make" >/dev/null 2>&1; then
   CFG_USE_GNUMAKE=yes
fi

# If -opengl wasn't specified, don't try to auto-detect
if [ "$PLATFORM_QWS" = "yes" ] && [ "$CFG_OPENGL" = "auto" ]; then
        CFG_OPENGL=no
fi

# mac
if [ "$PLATFORM_MAC" = "yes" ]; then
    if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
        CFG_OPENGL=desktop
    fi
fi

# find the default framework value
if [ "$PLATFORM_MAC" = "yes" ] && [ "$PLATFORM" != "macx-xlc" ]; then
    if [ "$CFG_FRAMEWORK" = "auto" ]; then
        CFG_FRAMEWORK="$CFG_SHARED"
    elif [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_SHARED" = "no" ]; then
	echo
	echo "WARNING: Using static linking will disable the use of Mac frameworks."
	echo
        CFG_FRAMEWORK="no"
    fi
else
    CFG_FRAMEWORK=no
fi

# Print a warning if configure was called with the 10.4u SDK option on Snow Leopard
# with the default mkspec. The 10.4u SDK does not support gcc 4.2.
if [ "$PLATFORM_MAC" = "yes" ] && [ '!' -z "$CFG_SDK" ]; then
    # get the darwin version. 10.0.0 and up means snow leopard.
    VERSION=`uname -r | tr '.' ' ' | awk '{print $1}'`
    if [ "$VERSION" -gt 9 ] && [ "$CFG_SDK" == "/Developer/SDKs/MacOSX10.4u.sdk/" ] && [ "$PLATFORM" == "macx-g++" ]; then
        echo
        echo "WARNING: The 10.4u SDK does not support gcc 4.2. Configure with -platform macx-g++40. "
        echo
    fi
fi

# x11 tests are done after qmake is built


#setup the build parts
if [ -z "$CFG_BUILD_PARTS" ]; then
    CFG_BUILD_PARTS="$QT_DEFAULT_BUILD_PARTS"

    # don't build tools by default when cross-compiling
    if [ "$PLATFORM" != "$XPLATFORM" ]; then
	CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, tools,,g"`
    fi
fi
for nobuild in $CFG_NOBUILD_PARTS; do
    CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, $nobuild,,g"`
done
if echo $CFG_BUILD_PARTS | grep -v libs >/dev/null 2>&1; then
#    echo
#    echo "WARNING: libs is a required part of the build."
#    echo
    CFG_BUILD_PARTS="$CFG_BUILD_PARTS libs"
fi

#-------------------------------------------------------------------------------
# post process QT_INSTALL_* variables
#-------------------------------------------------------------------------------

#prefix
if [ -z "$QT_INSTALL_PREFIX" ]; then
    if [ "$CFG_DEV" = "yes" ]; then
        QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default
    elif [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
        if [ "$PLATFORM_QPA" = "yes" ]; then
	QT_INSTALL_PREFIX="/usr/local/Trolltech/QtLighthouse-${QT_VERSION}"
        else
	QT_INSTALL_PREFIX="/usr/local/Trolltech/QtEmbedded-${QT_VERSION}"
        fi
        if [ "$PLATFORM" != "$XPLATFORM" ]; then
            QT_INSTALL_PREFIX="${QT_INSTALL_PREFIX}-${CFG_ARCH}"
        fi
    elif [ -d "$EPOCROOT" ] && [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        QT_INSTALL_PREFIX="$EPOCROOT/epoc32/"
        QT_INSTALL_LIBS="$EPOCROOT/epoc32/release/armv5/lib/"
    else
        QT_INSTALL_PREFIX="/usr/local/Trolltech/Qt-${QT_VERSION}" # the default install prefix is /usr/local/Trolltech/Qt-$QT_VERSION
    fi
fi
QT_INSTALL_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PREFIX"`

if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    [ -z "$QT_HOST_PREFIX" ] && QT_HOST_PREFIX="$QT_INSTALL_PREFIX"
    [ -z "$QT_INSTALL_DOCS" ] && QT_INSTALL_DOCS=
    [ -z "$QT_INSTALL_HEADERS" ] && QT_INSTALL_HEADERS=
    [ -z "$QT_INSTALL_LIBS" ] && QT_INSTALL_LIBS=
    [ -z "$QT_INSTALL_BINS" ] && QT_INSTALL_BINS=
    [ -z "$QT_INSTALL_PLUGINS" ] && QT_INSTALL_PLUGINS="\\\\resource\\\\qt$QT_LIBINFIX\\\\plugins"
    [ -z "$QT_INSTALL_IMPORTS" ] && QT_INSTALL_IMPORTS="\\\\resource\\\\qt$QT_LIBINFIX\\\\imports"
    [ -z "$QT_INSTALL_DATA" ] && QT_INSTALL_DATA=
    [ -z "$QT_INSTALL_TRANSLATIONS" ] && QT_INSTALL_TRANSLATIONS="\\\\resource\\\\qt$QT_LIBINFIX\\\\translations"
    [ -z "$QT_INSTALL_SETTINGS" ] && QT_INSTALL_SETTINGS=
    [ -z "$QT_INSTALL_EXAMPLES" ] && QT_INSTALL_EXAMPLES=
    [ -z "$QT_INSTALL_DEMOS" ] && QT_INSTALL_DEMOS=
else
    #docs
    if [ -z "$QT_INSTALL_DOCS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_DOCS="/Developer/Documentation/Qt"
            fi
        fi
        [ -z "$QT_INSTALL_DOCS" ] && QT_INSTALL_DOCS="$QT_INSTALL_PREFIX/doc" #fallback

    fi
    QT_INSTALL_DOCS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DOCS"`

    #headers
    if [ -z "$QT_INSTALL_HEADERS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        if [ "$CFG_FRAMEWORK" = "yes" ]; then
		    QT_INSTALL_HEADERS=
                fi
            fi
        fi
        [ -z "$QT_INSTALL_HEADERS" ] && QT_INSTALL_HEADERS="$QT_INSTALL_PREFIX/include"

    fi
    QT_INSTALL_HEADERS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_HEADERS"`

    #libs
    if [ -z "$QT_INSTALL_LIBS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        if [ "$CFG_FRAMEWORK" = "yes" ]; then
		    QT_INSTALL_LIBS="/Libraries/Frameworks"
                fi
            fi
        fi
        [ -z "$QT_INSTALL_LIBS" ] && QT_INSTALL_LIBS="$QT_INSTALL_PREFIX/lib" #fallback
    fi
    QT_INSTALL_LIBS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBS"`

    #bins
    if [ -z "$QT_INSTALL_BINS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_BINS="/Developer/Applications/Qt"
            fi
        fi
        [ -z "$QT_INSTALL_BINS" ] && QT_INSTALL_BINS="$QT_INSTALL_PREFIX/bin" #fallback

    fi
    QT_INSTALL_BINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_BINS"`

    #plugins
    if [ -z "$QT_INSTALL_PLUGINS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_PLUGINS="/Developer/Applications/Qt/plugins"
            fi
        fi
        [ -z "$QT_INSTALL_PLUGINS" ] && QT_INSTALL_PLUGINS="$QT_INSTALL_PREFIX/plugins" #fallback
    fi
    QT_INSTALL_PLUGINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PLUGINS"`

    #imports
    if [ -z "$QT_INSTALL_IMPORTS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_IMPORTS="/Developer/Applications/Qt/imports"
            fi
        fi
        [ -z "$QT_INSTALL_IMPORTS" ] && QT_INSTALL_IMPORTS="$QT_INSTALL_PREFIX/imports" #fallback
    fi
    QT_INSTALL_IMPORTS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_IMPORTS"`

    #data
    if [ -z "$QT_INSTALL_DATA" ]; then #default
        QT_INSTALL_DATA="$QT_INSTALL_PREFIX"
    fi
    QT_INSTALL_DATA=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DATA"`

    #translations
    if [ -z "$QT_INSTALL_TRANSLATIONS" ]; then #default
        QT_INSTALL_TRANSLATIONS="$QT_INSTALL_PREFIX/translations"
    fi
    QT_INSTALL_TRANSLATIONS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_TRANSLATIONS"`

    #settings
    if [ -z "$QT_INSTALL_SETTINGS" ]; then #default
        if [ "$PLATFORM_MAC" = "yes" ]; then
	    QT_INSTALL_SETTINGS=/Library/Preferences/Qt
        else
	    QT_INSTALL_SETTINGS=/etc/xdg
        fi
    fi
    QT_INSTALL_SETTINGS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_SETTINGS"`

    #examples
    if [ -z "$QT_INSTALL_EXAMPLES" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_EXAMPLES="/Developer/Examples/Qt"
            fi
        fi
        [ -z "$QT_INSTALL_EXAMPLES" ] && QT_INSTALL_EXAMPLES="$QT_INSTALL_PREFIX/examples" #fallback
    fi
    QT_INSTALL_EXAMPLES=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_EXAMPLES"`

    #demos
    if [ -z "$QT_INSTALL_DEMOS" ]; then #default
        if [ "$CFG_PREFIX_INSTALL" = "no" ]; then
	    if [ "$PLATFORM_MAC" = "yes" ]; then
	        QT_INSTALL_DEMOS="/Developer/Examples/Qt/Demos"
            fi
        fi
        [ -z "$QT_INSTALL_DEMOS" ] && QT_INSTALL_DEMOS="$QT_INSTALL_PREFIX/demos"
    fi
    QT_INSTALL_DEMOS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_DEMOS"`
fi

#-------------------------------------------------------------------------------
# help - interactive parts of the script _after_ this section please
#-------------------------------------------------------------------------------

# next, emit a usage message if something failed.
if [ "$OPT_HELP" = "yes" ]; then
    [ "x$ERROR" = "xyes" ] && echo
    if [ "$CFG_NIS" = "no" ]; then
        NSY=" "
        NSN="*"
    else
        NSY="*"
        NSN=" "
    fi
    if [ "$CFG_CUPS" = "no" ]; then
        CUY=" "
        CUN="*"
    else
        CUY="*"
        CUN=" "
    fi
    if [ "$CFG_ICONV" = "no" ]; then
        CIY=" "
        CIN="*"
    else
        CIY="*"
        CIN=" "
    fi
    if [ "$CFG_LARGEFILE" = "no" ]; then
        LFSY=" "
        LFSN="*"
    else
        LFSY="*"
        LFSN=" "
    fi
    if [ "$CFG_STL" = "auto" ] || [ "$CFG_STL" = "yes" ]; then
        SHY="*"
        SHN=" "
    else
        SHY=" "
        SHN="*"
    fi
    if [ "$CFG_IPV6" = "auto" ]; then
        I6Y="*"
        I6N=" "
    fi
    if [ "$CFG_PRECOMPILE" = "auto" ] || [ "$CFG_PRECOMPILE" = "no" ]; then
        PHY=" "
        PHN="*"
    else
        PHY="*"
        PHN=" "
    fi

    cat <<EOF
Usage:  $relconf [-h] [-prefix <dir>] [-prefix-install] [-bindir <dir>] [-libdir <dir>]
        [-docdir <dir>] [-headerdir <dir>] [-plugindir <dir> ] [-importdir <dir>] [-datadir <dir>]
        [-translationdir <dir>] [-sysconfdir <dir>] [-examplesdir <dir>]
        [-demosdir <dir>] [-buildkey <key>] [-release] [-debug]
        [-debug-and-release] [-developer-build] [-shared] [-static] [-no-fast] [-fast] [-no-largefile]
        [-largefile] [-no-exceptions] [-exceptions] [-no-accessibility]
        [-accessibility] [-no-stl] [-stl] [-no-sql-<driver>] [-sql-<driver>]
        [-plugin-sql-<driver>] [-system-sqlite] [-no-qt3support] [-qt3support]
        [-platform] [-D <string>] [-I <string>] [-L <string>] [-help]
        [-qt-zlib] [-system-zlib] [-no-gif] [-no-libtiff] [-qt-libtiff] [-system-libtiff]
        [-no-libpng] [-qt-libpng] [-system-libpng] [-no-libmng] [-qt-libmng]
        [-system-libmng] [-no-libjpeg] [-qt-libjpeg] [-system-libjpeg] [-make <part>]
        [-nomake <part>] [-R <string>]  [-l <string>] [-no-rpath]  [-rpath] [-continue]
        [-verbose] [-v] [-silent] [-no-nis] [-nis] [-no-cups] [-cups] [-no-iconv]
        [-iconv] [-no-pch] [-pch] [-no-dbus] [-dbus] [-dbus-linked] [-no-gui]
        [-no-separate-debug-info] [-no-mmx] [-no-3dnow] [-no-sse] [-no-sse2]
        [-no-sse3] [-no-ssse3] [-no-sse4.1] [-no-sse4.2] [-no-avx] [-no-neon]
        [-qtnamespace <namespace>] [-qtlibinfix <infix>] [-separate-debug-info] [-armfpa]
        [-no-optimized-qmake] [-optimized-qmake] [-no-xmlpatterns] [-xmlpatterns]
        [-no-multimedia] [-multimedia] [-no-phonon] [-phonon] [-no-phonon-backend] [-phonon-backend]
        [-no-media-backend] [-media-backend] [-no-audio-backend] [-audio-backend] 
        [-no-openssl] [-openssl] [-openssl-linked]
        [-no-gtkstyle] [-gtkstyle] [-no-svg] [-svg] [-no-webkit] [-webkit] [-webkit-debug]
        [-no-javascript-jit] [-javascript-jit]
        [-no-script] [-script] [-no-scripttools] [-scripttools] 
	[-no-declarative] [-declarative][-no-declarative-debug] [-declarative-debug]
        [additional platform specific options (see below)]


Installation options:

 These are optional, but you may specify install directories.

    -prefix <dir> ...... This will install everything relative to <dir>
                         (default $QT_INSTALL_PREFIX)
EOF
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
cat <<EOF

    -hostprefix [dir] .. Tools and libraries needed when developing
                         applications are installed in [dir]. If [dir] is
                         not given, the current build directory will be used.
EOF
fi
cat <<EOF

  * -prefix-install .... Force a sandboxed "local" installation of
                         Qt. This will install into
                         $QT_INSTALL_PREFIX, if this option is
                         disabled then some platforms will attempt a
                         "system" install by placing default values to
                         be placed in a system location other than
                         PREFIX.

 You may use these to separate different parts of the install:

    -bindir <dir> ......... Executables will be installed to <dir>
                            (default PREFIX/bin)
    -libdir <dir> ......... Libraries will be installed to <dir>
                            (default PREFIX/lib)
    -docdir <dir> ......... Documentation will be installed to <dir>
                            (default PREFIX/doc)
    -headerdir <dir> ...... Headers will be installed to <dir>
                            (default PREFIX/include)
    -plugindir <dir> ...... Plugins will be installed to <dir>
                            (default PREFIX/plugins)
    -importdir <dir> ...... Imports for QML will be installed to <dir>
                            (default PREFIX/imports)
    -datadir <dir> ........ Data used by Qt programs will be installed to <dir>
                            (default PREFIX)
    -translationdir <dir> . Translations of Qt programs will be installed to <dir>
                            (default PREFIX/translations)
    -sysconfdir <dir> ..... Settings used by Qt programs will be looked for in <dir>
                            (default PREFIX/etc/settings)
    -examplesdir <dir> .... Examples will be installed to <dir>
                            (default PREFIX/examples)
    -demosdir <dir> ....... Demos will be installed to <dir>
                            (default PREFIX/demos)

 You may use these options to turn on strict plugin loading.

    -buildkey <key> .... Build the Qt library and plugins using the specified
                         <key>.  When the library loads plugins, it will only
                         load those that have a matching key.

Configure options:

 The defaults (*) are usually acceptable. A plus (+) denotes a default value
 that needs to be evaluated. If the evaluation succeeds, the feature is
 included. Here is a short explanation of each option:

 *  -release ........... Compile and link Qt with debugging turned off.
    -debug ............. Compile and link Qt with debugging turned on.
    -debug-and-release . Compile and link two versions of Qt, with and without
                         debugging turned on (Mac only).

    -developer-build ... Compile and link Qt with Qt developer options (including auto-tests exporting)

    -opensource ........ Compile and link the Open-Source Edition of Qt.
    -commercial ........ Compile and link the Commercial Edition of Qt.


 *  -shared ............ Create and use shared Qt libraries.
    -static ............ Create and use static Qt libraries.

 *  -no-fast ........... Configure Qt normally by generating Makefiles for all
                         project files.
    -fast .............. Configure Qt quickly by generating Makefiles only for
                         library and subdirectory targets.  All other Makefiles
                         are created as wrappers, which will in turn run qmake.

    -no-largefile ...... Disables large file support.
 +  -largefile ......... Enables Qt to access files larger than 4 GB.

EOF
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    EXCN="*"
    EXCY=" "
else
    EXCN=" "
    EXCY="*"
fi
if [ "$CFG_DBUS" = "no" ]; then
    DBY=" "
    DBN="+"
else
    DBY="+"
    DBN=" "
fi

    cat << EOF
 $EXCN  -no-exceptions ..... Disable exceptions on compilers that support it.
 $EXCY  -exceptions ........ Enable exceptions on compilers that support it.

    -no-accessibility .. Do not compile Accessibility support.
 *  -accessibility ..... Compile Accessibility support.

 $SHN  -no-stl ............ Do not compile STL support.
 $SHY  -stl ............... Compile STL support.

    -no-sql-<driver> ... Disable SQL <driver> entirely.
    -qt-sql-<driver> ... Enable a SQL <driver> in the QtSql library, by default
                         none are turned on.
    -plugin-sql-<driver> Enable SQL <driver> as a plugin to be linked to
                         at run time.

                         Possible values for <driver>:
                         [ $CFG_SQL_AVAILABLE ]

    -system-sqlite ..... Use sqlite from the operating system.

    -no-qt3support ..... Disables the Qt 3 support functionality.
 *  -qt3support ........ Enables the Qt 3 support functionality.

    -no-xmlpatterns .... Do not build the QtXmlPatterns module.
 +  -xmlpatterns ....... Build the QtXmlPatterns module.
                         QtXmlPatterns is built if a decent C++ compiler
                         is used and exceptions are enabled.

    -no-multimedia ..... Do not build the QtMultimedia module.
 +  -multimedia ........ Build the QtMultimedia module.

    -no-audio-backend .. Do not build the platform audio backend into QtMultimedia.
 +  -audio-backend ..... Build the platform audio backend into QtMultimedia if available.

    -no-phonon ......... Do not build the Phonon module.
 +  -phonon ............ Build the Phonon module.
                         Phonon is built if a decent C++ compiler is used.
    -no-phonon-backend.. Do not build the platform phonon plugin.
 +  -phonon-backend..... Build the platform phonon plugin.

    -no-svg ............ Do not build the SVG module.
 +  -svg ............... Build the SVG module.

    -no-webkit ......... Do not build the WebKit module.
 +  -webkit ............ Build the WebKit module.
                         WebKit is built if a decent C++ compiler is used.
    -webkit-debug ...... Build the WebKit module with debug symbols.

    -no-javascript-jit . Do not build the JavaScriptCore JIT compiler.
 +  -javascript-jit .... Build the JavaScriptCore JIT compiler.

    -no-script ......... Do not build the QtScript module.
 +  -script ............ Build the QtScript module.

    -no-scripttools .... Do not build the QtScriptTools module.
 +  -scripttools ....... Build the QtScriptTools module.

    -no-declarative ..... Do not build the declarative module.
 +  -declarative ....... Build the declarative module.

    -no-declarative-debug ..... Do not build the declarative debugging support.
 +  -declarative-debug ....... Build the declarative debugging support.

    -platform target ... The operating system and compiler you are building
                         on ($PLATFORM).

                         See the README file for a list of supported
                         operating systems and compilers.
EOF
if [ "${PLATFORM_QWS}" != "yes" ]; then
cat << EOF
    -graphicssystem <sys> Sets an alternate graphics system. Available options are:
                           raster - Software rasterizer
                           opengl - Rendering via OpenGL, Experimental!
                           openvg - Rendering via OpenVG, Experimental!

EOF
fi
cat << EOF

    -no-mmx ............ Do not compile with use of MMX instructions.
    -no-3dnow .......... Do not compile with use of 3DNOW instructions.
    -no-sse ............ Do not compile with use of SSE instructions.
    -no-sse2 ........... Do not compile with use of SSE2 instructions.
    -no-sse3 ........... Do not compile with use of SSE3 instructions.
    -no-ssse3 .......... Do not compile with use of SSSE3 instructions.
    -no-sse4.1.......... Do not compile with use of SSE4.1 instructions.
    -no-sse4.2.......... Do not compile with use of SSE4.2 instructions.
    -no-avx ............ Do not compile with use of AVX instructions.
    -no-neon ........... Do not compile with use of NEON instructions.

    -qtnamespace <name>  Wraps all Qt library code in 'namespace <name> {...}'.
    -qtlibinfix <infix>  Renames all libQt*.so to libQt*<infix>.so.

    -D <string> ........ Add an explicit define to the preprocessor.
    -I <string> ........ Add an explicit include path.
    -L <string> ........ Add an explicit library path.

    -help, -h .......... Display this information.

Third Party Libraries:

    -qt-zlib ........... Use the zlib bundled with Qt.
 +  -system-zlib ....... Use zlib from the operating system.
                         See http://www.gzip.org/zlib

    -no-gif ............ Do not compile GIF reading support.

    -no-libtiff ........ Do not compile TIFF support.
    -qt-libtiff ........ Use the libtiff bundled with Qt.
 +  -system-libtiff .... Use libtiff from the operating system.
                         See http://www.libtiff.org

    -no-libpng ......... Do not compile PNG support.
    -qt-libpng ......... Use the libpng bundled with Qt.
 +  -system-libpng ..... Use libpng from the operating system.
                         See http://www.libpng.org/pub/png

    -no-libmng ......... Do not compile MNG support.
    -qt-libmng ......... Use the libmng bundled with Qt.
 +  -system-libmng ..... Use libmng from the operating system.
                         See http://www.libmng.com

    -no-libjpeg ........ Do not compile JPEG support.
    -qt-libjpeg ........ Use the libjpeg bundled with Qt.
 +  -system-libjpeg .... Use libjpeg from the operating system.
                         See http://www.ijg.org

    -no-openssl ........ Do not compile support for OpenSSL.
 +  -openssl ........... Enable run-time OpenSSL support.
    -openssl-linked .... Enabled linked OpenSSL support.

    -ptmalloc .......... Override the system memory allocator with ptmalloc.
                         (Experimental.)

Additional options:

    -make <part> ....... Add part to the list of parts to be built at make time.
                         ($QT_DEFAULT_BUILD_PARTS)
    -nomake <part> ..... Exclude part from the list of parts to be built.

    -R <string> ........ Add an explicit runtime library path to the Qt
                         libraries.
    -l <string> ........ Add an explicit library.

    -no-rpath .......... Do not use the library install path as a runtime
                         library path.
 +  -rpath ............. Link Qt libraries and executables using the library
                         install path as a runtime library path. Equivalent
                         to -R install_libpath

    -continue .......... Continue as far as possible if an error occurs.

    -verbose, -v ....... Print verbose information about each step of the
                         configure process.

    -silent ............ Reduce the build output so that warnings and errors
                         can be seen more easily.

 *  -no-optimized-qmake ... Do not build qmake optimized.
    -optimized-qmake ...... Build qmake optimized.

    -no-gui ............ Don't build the Qt GUI library

 $NSN  -no-nis ............ Do not compile NIS support.
 $NSY  -nis ............... Compile NIS support.

 $CUN  -no-cups ........... Do not compile CUPS support.
 $CUY  -cups .............. Compile CUPS support.
                         Requires cups/cups.h and libcups.so.2.

 $CIN  -no-iconv .......... Do not compile support for iconv(3).
 $CIY  -iconv ............. Compile support for iconv(3).

 $PHN  -no-pch ............ Do not use precompiled header support.
 $PHY  -pch ............... Use precompiled header support.

 $DBN  -no-dbus ........... Do not compile the QtDBus module.
 $DBY  -dbus .............. Compile the QtDBus module and dynamically load libdbus-1.
    -dbus-linked ....... Compile the QtDBus module and link to libdbus-1.

    -reduce-relocations ..... Reduce relocations in the libraries through extra
                              linker optimizations (Qt/X11 and Qt for Embedded Linux only;
                              experimental; needs GNU ld >= 2.18).
EOF

if [ "$CFG_SEPARATE_DEBUG_INFO" = "auto" ]; then
    if [ "$QT_CROSS_COMPILE" = "yes" ]; then
        SBY=""
        SBN="*"
    else
        SBY="*"
        SBN=" "
    fi
elif [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
    SBY="*"
    SBN=" "
else
    SBY=" "
    SBN="*"
fi

if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then

    cat << EOF

 $SBN  -no-separate-debug-info . Do not store debug information in a separate file.
 $SBY  -separate-debug-info .... Strip debug information into a separate .debug file.

EOF

fi # X11/QWS

if [ "$PLATFORM_X11" = "yes" ]; then
    if [ "$CFG_SM" = "no" ]; then
        SMY=" "
        SMN="*"
    else
        SMY="*"
        SMN=" "
    fi
    if [ "$CFG_XSHAPE" = "no" ]; then
        SHY=" "
        SHN="*"
    else
        SHY="*"
        SHN=" "
    fi
    if [ "$CFG_XVIDEO" = "no" ]; then
        XVY=" "
        XVN="*"
    else
        XVY="*"
        XVN=" "
    fi
    if [ "$CFG_XINERAMA" = "no" ]; then
        XAY=" "
        XAN="*"
    else
        XAY="*"
        XAN=" "
    fi
    if [ "$CFG_FONTCONFIG" = "no" ]; then
        FCGY=" "
        FCGN="*"
    else
        FCGY="*"
        FCGN=" "
    fi
    if [ "$CFG_XCURSOR" = "no" ]; then
        XCY=" "
        XCN="*"
    else
        XCY="*"
        XCN=" "
    fi
    if [ "$CFG_XFIXES" = "no" ]; then
        XFY=" "
        XFN="*"
    else
        XFY="*"
        XFN=" "
    fi
    if [ "$CFG_XRANDR" = "no" ]; then
        XZY=" "
        XZN="*"
    else
        XZY="*"
        XZN=" "
    fi
    if [ "$CFG_XRENDER" = "no" ]; then
        XRY=" "
        XRN="*"
    else
        XRY="*"
        XRN=" "
    fi
    if [ "$CFG_MITSHM" = "no" ]; then
        XMY=" "
        XMN="*"
    else
        XMY="*"
        XMN=" "
    fi
    if [ "$CFG_XINPUT" = "no" ]; then
        XIY=" "
        XIN="*"
    else
        XIY="*"
        XIN=" "
    fi
    if [ "$CFG_XKB" = "no" ]; then
        XKY=" "
        XKN="*"
    else
        XKY="*"
        XKN=" "
    fi
    if [ "$CFG_IM" = "no" ]; then
        IMY=" "
        IMN="*"
    else
        IMY="*"
        IMN=" "
    fi
    cat << EOF

Qt/X11 only:

    -no-gtkstyle ....... Do not build the GTK theme integration.
 +  -gtkstyle .......... Build the GTK theme integration.

 *  -no-nas-sound ...... Do not compile in NAS sound support.
    -system-nas-sound .. Use NAS libaudio from the operating system.
                         See http://radscan.com/nas.html

    -egl ............... Use EGL instead of GLX to manage contexts.
                         When building for desktop OpenGL, this option will
                         make Qt use EGL to manage contexts rather than the
                         GLX, which is the default. Note: For OpenGL ES, EGL
                         is always used.

    -no-opengl ......... Do not support OpenGL.
 +  -opengl <api> ...... Enable OpenGL support.
                         With no parameter, this will auto-detect the "best"
                         OpenGL API to use. If desktop OpenGL is available, it
                         will be used. Use desktop, es1, or es2 for <api>
                         to force the use of the Desktop (OpenGL 1.x or 2.x),
                         OpenGL ES 1.x Common profile, or 2.x APIs instead.

     -no-openvg ........ Do not support OpenVG.
 +   -openvg ........... Enable OpenVG support.
                         Requires EGL support, typically supplied by an OpenGL
                         or other graphics implementation.

 $SMN  -no-sm ............. Do not support X Session Management.
 $SMY  -sm ................ Support X Session Management, links in -lSM -lICE.

 $SHN  -no-xshape ......... Do not compile XShape support.
 $SHY  -xshape ............ Compile XShape support.
                         Requires X11/extensions/shape.h.

 $XVN  -no-xvideo ......... Do not compile XVideo support.
 $XVY  -xvideo ............ Compile XVideo support.
                         Requires X11/extensions/Xv.h & Xvlib.h.

 $SHN  -no-xsync .......... Do not compile XSync support.
 $SHY  -xsync ............. Compile XSync support.
                         Requires X11/extensions/sync.h.

 $XAN  -no-xinerama ....... Do not compile Xinerama (multihead) support.
 $XAY  -xinerama .......... Compile Xinerama support.
                         Requires X11/extensions/Xinerama.h and libXinerama.
			 By default, Xinerama support will be compiled if
                         available and the shared libraries are dynamically
                         loaded at runtime.

 $XCN  -no-xcursor ........ Do not compile Xcursor support.
 $XCY  -xcursor ........... Compile Xcursor support.
                         Requires X11/Xcursor/Xcursor.h and libXcursor.
			 By default, Xcursor support will be compiled if
                         available and the shared libraries are dynamically
                         loaded at runtime.

 $XFN  -no-xfixes ......... Do not compile Xfixes support.
 $XFY  -xfixes ............ Compile Xfixes support.
                         Requires X11/extensions/Xfixes.h and libXfixes.
			 By default, Xfixes support will be compiled if
                         available and the shared libraries are dynamically
                         loaded at runtime.

 $XZN  -no-xrandr ......... Do not compile Xrandr (resize and rotate) support.
 $XZY  -xrandr ............ Compile Xrandr support.
                         Requires X11/extensions/Xrandr.h and libXrandr.

 $XRN  -no-xrender ........ Do not compile Xrender support.
 $XRY  -xrender ........... Compile Xrender support.
                         Requires X11/extensions/Xrender.h and libXrender.

 $XMN  -no-mitshm ......... Do not compile MIT-SHM support.
 $XMY  -mitshm ............ Compile MIT-SHM support.
                         Requires sys/ipc.h, sys/shm.h and X11/extensions/XShm.h

 $FCGN  -no-fontconfig ..... Do not compile FontConfig (anti-aliased font) support.
 $FCGY  -fontconfig ........ Compile FontConfig support.
                         Requires fontconfig/fontconfig.h, libfontconfig,
                         freetype.h and libfreetype.

 $XIN  -no-xinput ......... Do not compile Xinput support.
 $XIY  -xinput ............ Compile Xinput support. This also enabled tablet support
                         which requires IRIX with wacom.h and libXi or
                         XFree86 with X11/extensions/XInput.h and libXi.

 $XKN  -no-xkb ............ Do not compile XKB (X KeyBoard extension) support.
 $XKY  -xkb ............... Compile XKB support.

EOF
fi

if [ "$PLATFORM_MAC" = "yes" ]; then
    cat << EOF

Qt/Mac only:

    -Fstring ........... Add an explicit framework path.
    -fw string ......... Add an explicit framework.

    -cocoa ............. [Deprecated] Cocoa is now enabled by default.

    -carbon .............Build the Carbon version of Qt. 64-bit archs
                         are not supported by carbon and will be built
                         with cocoa

 *  -framework ......... Build Qt as a series of frameworks and
                         link tools against those frameworks.
    -no-framework ...... Do not build Qt as a series of frameworks.

 *  -dwarf2 ............ Enable dwarf2 debugging symbols.
    -no-dwarf2 ......... Disable dwarf2 debugging symbols.

    -universal ......... Equivalent to -arch "ppc x86"

    -arch <arch> ....... Build Qt for <arch>
                         Example values for <arch>: x86 ppc x86_64 ppc64
                         Multiple -arch arguments can be specified.

    -sdk <sdk> ......... Build Qt using Apple provided SDK <sdk>. This option requires gcc 4.
                         To use a different SDK with gcc 3.3, set the SDKROOT environment variable.

EOF
fi

if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    cat << EOF

Qt for Embedded Linux only:

    -xplatform target ... The target platform when cross-compiling.

    -no-feature-<feature> Do not compile in <feature>.
    -feature-<feature> .. Compile in <feature>. The available features
                          are described in src/corelib/global/qfeatures.txt

    -embedded <arch> .... This will enable the embedded build, you must have a
                          proper license for this switch to work.
                          Example values for <arch>: arm mips x86 generic

    -qpa <arch> ......... This will enable the QPA build.
                          Example values for <arch>: arm mips x86 generic
                          QPA is a window system agnostic implementation of Qt.

    -armfpa ............. Target platform uses the ARM-FPA floating point format.
    -no-armfpa .......... Target platform does not use the ARM-FPA floating point format.

                          The floating point format is usually autodetected by configure. Use this
                          to override the detected value.

    -little-endian ...... Target platform is little endian (LSB first).
    -big-endian ......... Target platform is big endian (MSB first).

    -host-little-endian . Host platform is little endian (LSB first).
    -host-big-endian .... Host platform is big endian (MSB first).

                          You only need to specify the endianness when
                          cross-compiling, otherwise the host
                          endianness will be used.

    -no-freetype ........ Do not compile in Freetype2 support.
    -qt-freetype ........ Use the libfreetype bundled with Qt.
 *  -system-freetype .... Use libfreetype from the operating system.
                          See http://www.freetype.org/

    -qconfig local ...... Use src/corelib/global/qconfig-local.h rather than the
                          default ($CFG_QCONFIG).

    -depths <list> ...... Comma-separated list of supported bit-per-pixel
                          depths, from: 1, 4, 8, 12, 15, 16, 18, 24, 32 and 'all'.

    -qt-decoration-<style> ....Enable a decoration <style> in the QtGui library,
                               by default all available decorations are on.
			       Possible values for <style>: [ $CFG_DECORATION_AVAILABLE ]
    -plugin-decoration-<style> Enable decoration <style> as a plugin to be
                               linked to at run time.
			       Possible values for <style>: [ $CFG_DECORATION_PLUGIN_AVAILABLE ]
    -no-decoration-<style> ....Disable decoration <style> entirely.
                               Possible values for <style>: [ $CFG_DECORATION_AVAILABLE ]

    -no-opengl .......... Do not support OpenGL.
    -opengl <api> ....... Enable OpenGL ES support
                          With no parameter, this will attempt to auto-detect OpenGL ES 1.x
                          or 2.x. Use es1 or es2 for <api> to override auto-detection.

                          NOTE: A QGLScreen driver for the hardware is required to support
                                OpenGL ES on Qt for Embedded Linux.

    -qt-gfx-<driver> ... Enable a graphics <driver> in the QtGui library.
                         Possible values for <driver>: [ $CFG_GFX_AVAILABLE ]
    -plugin-gfx-<driver> Enable graphics <driver> as a plugin to be
                         linked to at run time.
                         Possible values for <driver>: [ $CFG_GFX_PLUGIN_AVAILABLE ]
    -no-gfx-<driver> ... Disable graphics <driver> entirely.
                         Possible values for <driver>: [ $CFG_GFX_AVAILABLE ]

    -qt-kbd-<driver> ... Enable a keyboard <driver> in the QtGui library.
                         Possible values for <driver>: [ $CFG_KBD_AVAILABLE ]

    -plugin-kbd-<driver> Enable keyboard <driver> as a plugin to be linked to
                         at runtime.
                         Possible values for <driver>: [ $CFG_KBD_PLUGIN_AVAILABLE ]

    -no-kbd-<driver> ... Disable keyboard <driver> entirely.
                         Possible values for <driver>: [ $CFG_KBD_AVAILABLE ]

    -qt-mouse-<driver> ... Enable a mouse <driver> in the QtGui library.
                           Possible values for <driver>: [ $CFG_MOUSE_AVAILABLE ]
    -plugin-mouse-<driver> Enable mouse <driver> as a plugin to be linked to
                           at runtime.
                           Possible values for <driver>: [ $CFG_MOUSE_PLUGIN_AVAILABLE ]
    -no-mouse-<driver> ... Disable mouse <driver> entirely.
                           Possible values for <driver>: [ $CFG_MOUSE_AVAILABLE ]

    -iwmmxt ............ Compile using the iWMMXt instruction set
                         (available on some XScale CPUs).
EOF
fi


if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" -o "$PLATFORM_X11" = "yes" ]; then
    if [ "$CFG_GLIB" = "no" ]; then
        GBY=" "
        GBN="+"
    else
        GBY="+"
        GBN=" "
    fi
    cat << EOF
 $GBN  -no-glib ........... Do not compile Glib support.
 $GBY  -glib .............. Compile Glib support.

EOF
fi

if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    cat << EOF

Qt for Symbian only:
    -no-s60 ............ Do not compile in S60 support.
 +  -s60 ............... Compile with support for the S60 UI Framework.
    -no-style-s60....... Disable s60 style
 +  -qt-style-s60....... Enable s60 style in the Qt Library

    -no-usedeffiles .... Disable the usage of DEF files.
 *  -usedeffiles ....... Enable the usage of DEF files.
EOF
fi
   [ "x$ERROR" = "xyes" ] && exit 1
   exit 0
fi # Help


# -----------------------------------------------------------------------------
# LICENSING, INTERACTIVE PART
# -----------------------------------------------------------------------------

if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    Platform="Qt for Embedded Linux"
elif [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    Platform="Qt for Symbian"
elif [ "$PLATFORM_MAC" = "yes" ]; then
    Platform="Qt for Mac OS X"
elif [ "$XPLATFORM_MINGW" = "yes" ]; then
    Platform="Qt for Windows"
elif [ '!' -z "`getQMakeConf \"$XQMAKESPEC\" | grep QMAKE_LIBS_X11 | awk '{print $3;}'`" ]; then
    PLATFORM_X11=yes
    Platform="Qt for Linux/X11"
fi

echo
echo "This is the $Platform ${EditionString} Edition."
echo

if [ "$Edition" = "NokiaInternalBuild" ]; then
    echo "Detected -nokia-developer option"
    echo "Nokia employees and agents are allowed to use this software under"
    echo "the authority of Nokia Corporation and/or its subsidiary(-ies)"
elif [ "$Edition" = "OpenSource" ]; then
    while true; do
        echo "You are licensed to use this software under the terms of"
        echo "the Lesser GNU General Public License (LGPL) versions 2.1."
        if [ -f "$relpath/LICENSE.GPL3" ]; then
            echo "You are also licensed to use this software under the terms of"
            echo "the GNU General Public License (GPL) versions 3."
            affix="either"
        else
            affix="the"
        fi
        echo
        if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
            echo "You have already accepted the terms of the $LicenseType license."
            acceptance=yes
        else
            if [ -f "$relpath/LICENSE.GPL3" ]; then
                echo "Type '3' to view the GNU General Public License version 3."
            fi
            echo "Type 'L' to view the Lesser GNU General Public License version 2.1."
            echo "Type 'yes' to accept this license offer."
            echo "Type 'no' to decline this license offer."
            echo
            echo $ECHO_N "Do you accept the terms of $affix license? $ECHO_C"
            read acceptance
        fi
        echo
        if [ "$acceptance" = "yes" ] || [ "$acceptance" = "y" ]; then
            break
        elif [ "$acceptance" = "no" ]; then
            echo "You are not licensed to use this software."
            echo
            exit 1
        elif [ "$acceptance" = "3" ]; then
            more "$relpath/LICENSE.GPL3"
        elif [ "$acceptance" = "L" ]; then
            more "$relpath/LICENSE.LGPL"
        fi
    done
elif [ "$Edition" = "Preview" ]; then
    TheLicense=`head -n 1 "$relpath/LICENSE.PREVIEW.COMMERCIAL"`
    while true; do

        if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
            echo "You have already accepted the terms of the $LicenseType license."
            acceptance=yes
        else
            echo "You are licensed to use this software under the terms of"
            echo "the $TheLicense"
            echo
            echo "Type '?' to read the Preview License."
            echo "Type 'yes' to accept this license offer."
            echo "Type 'no' to decline this license offer."
            echo
            echo $ECHO_N "Do you accept the terms of the license? $ECHO_C"
            read acceptance
        fi
        echo
        if [ "$acceptance" = "yes" ]; then
            break
        elif [ "$acceptance" = "no" ] ;then
            echo "You are not licensed to use this software."
            echo
            exit 0
        elif [ "$acceptance" = "?" ]; then
            more "$relpath/LICENSE.PREVIEW.COMMERCIAL"
        fi
    done
elif [ "$Edition" != "OpenSource" ]; then
    if [ -n "$ExpiryDate" ]; then
        ExpiryDate=`echo $ExpiryDate | sed -e "s,-,,g" | tr -d "\n\r"`
        [ -z "$ExpiryDate" ] && ExpiryDate="0"
        Today=`date +%Y%m%d`
        if [ "$Today" -gt "$ExpiryDate" ]; then
            case "$LicenseType" in
            Commercial|Academic|Educational)
                if [ "$QT_PACKAGEDATE" -gt "$ExpiryDate" ]; then
                    echo
                    echo "NOTICE  NOTICE  NOTICE  NOTICE"
                    echo
                    echo "  Your support and upgrade period has expired."
                    echo
                    echo "  You are no longer licensed to use this version of Qt."
                    echo "  Please contact qt-info@nokia.com to renew your support"
                    echo "  and upgrades for this license."
                    echo
                    echo "NOTICE  NOTICE  NOTICE  NOTICE"
                    echo
                    exit 1
                else
                    echo
                    echo "WARNING  WARNING  WARNING  WARNING"
                    echo
                    echo "  Your support and upgrade period has expired."
                    echo
                    echo "  You may continue to use your last licensed release"
                    echo "  of Qt under the terms of your existing license"
                    echo "  agreement. But you are not entitled to technical"
                    echo "  support, nor are you entitled to use any more recent"
                    echo "  Qt releases."
                    echo
                    echo "  Please contact qt-info@nokia.com to renew your"
                    echo "  support and upgrades for this license."
                    echo
                    echo "WARNING  WARNING  WARNING  WARNING"
                    echo
                    sleep 3
                fi
                ;;
            Evaluation|*)
                echo
                echo "NOTICE  NOTICE  NOTICE  NOTICE"
                echo
                echo "  Your Evaluation license has expired."
                echo
                echo "  You are no longer licensed to use this software. Please"
                echo "  contact qt-info@nokia.com to purchase license, or install"
                echo "  the Qt Open Source Edition if you intend to develop free"
                echo "  software."
                echo
                echo "NOTICE  NOTICE  NOTICE  NOTICE"
                echo
                exit 1
                ;;
            esac
        fi
    fi
    TheLicense=`head -n 1 "$outpath/LICENSE"`
    while true; do
        if [ "$OPT_CONFIRM_LICENSE" = "yes" ]; then
	    echo "You have already accepted the terms of the $TheLicense."
            acceptance=yes
        else
            echo "You are licensed to use this software under the terms of"
            echo "the $TheLicense."
            echo
            echo "Type '?' to view the $TheLicense."
            echo "Type 'yes' to accept this license offer."
            echo "Type 'no' to decline this license offer."
            echo
            echo $ECHO_N "Do you accept the terms of the $TheLicense? $ECHO_C"
            read acceptance
        fi
        echo
        if [ "$acceptance" = "yes" ]; then
            break
        elif [ "$acceptance" = "no" ]; then
            echo "You are not licensed to use this software."
            echo
            exit 1
        else [ "$acceptance" = "?" ]
            more "$outpath/LICENSE"
        fi
    done
fi

# this should be moved somewhere else
case "$PLATFORM" in
aix-*)
    AIX_VERSION=`uname -v`
    if [ "$AIX_VERSION" -lt "5" ]; then
	QMakeVar add QMAKE_LIBS_X11 -lbind
    fi
    ;;
*)
    ;;
esac

#-------------------------------------------------------------------------------
# generate qconfig.cpp
#-------------------------------------------------------------------------------
[ -d "$outpath/src/corelib/global" ] || mkdir -p "$outpath/src/corelib/global"

LICENSE_USER_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_lcnsuser=$Licensee"`
LICENSE_PRODUCTS_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_lcnsprod=$Edition"`
PREFIX_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_prfxpath=$QT_INSTALL_PREFIX"`
DOCUMENTATION_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_docspath=$QT_INSTALL_DOCS"`
HEADERS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_hdrspath=$QT_INSTALL_HEADERS"`
LIBRARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_libspath=$QT_INSTALL_LIBS"`
BINARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_binspath=$QT_INSTALL_BINS"`
PLUGINS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_plugpath=$QT_INSTALL_PLUGINS"`
IMPORTS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_impspath=$QT_INSTALL_IMPORTS"`
DATA_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_datapath=$QT_INSTALL_DATA"`
TRANSLATIONS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_trnspath=$QT_INSTALL_TRANSLATIONS"`
SETTINGS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_stngpath=$QT_INSTALL_SETTINGS"`
EXAMPLES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_xmplpath=$QT_INSTALL_EXAMPLES"`
DEMOS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_demopath=$QT_INSTALL_DEMOS"`

TODAY=`date +%Y-%m-%d`
cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* License Info */
static const char qt_configure_licensee_str          [256 + 12] = "$LICENSE_USER_STR";
static const char qt_configure_licensed_products_str [256 + 12] = "$LICENSE_PRODUCTS_STR";

/* Installation date */
static const char qt_configure_installation          [12+11]    = "qt_instdate=$TODAY";
EOF


if [ ! -z "$QT_HOST_PREFIX" ]; then
    HOSTPREFIX_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_prfxpath=$QT_HOST_PREFIX"`
    HOSTDOCUMENTATION_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_docspath=$QT_HOST_PREFIX/doc"`
    HOSTHEADERS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_hdrspath=$QT_HOST_PREFIX/include"`
    HOSTLIBRARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_libspath=$QT_HOST_PREFIX/lib"`
    HOSTBINARIES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_binspath=$QT_HOST_PREFIX/bin"`
    HOSTPLUGINS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_plugpath=$QT_HOST_PREFIX/plugins"`
    HOSTIMPORTS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_impspath=$QT_HOST_PREFIX/IMPORTS"`
    HOSTDATA_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_datapath=$QT_HOST_PREFIX"`
    HOSTTRANSLATIONS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_trnspath=$QT_HOST_PREFIX/translations"`
    HOSTSETTINGS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_stngpath=$QT_INSTALL_SETTINGS"`
    HOSTEXAMPLES_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_xmplpath=$QT_INSTALL_EXAMPLES"`
    HOSTDEMOS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_demopath=$QT_INSTALL_DEMOS"`

    cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF

#if defined(QT_BOOTSTRAPPED) || defined(QT_BUILD_QMAKE)
/* Installation Info */
static const char qt_configure_prefix_path_str       [256 + 12] = "$HOSTPREFIX_PATH_STR";
static const char qt_configure_documentation_path_str[256 + 12] = "$HOSTDOCUMENTATION_PATH_STR";
static const char qt_configure_headers_path_str      [256 + 12] = "$HOSTHEADERS_PATH_STR";
static const char qt_configure_libraries_path_str    [256 + 12] = "$HOSTLIBRARIES_PATH_STR";
static const char qt_configure_binaries_path_str     [256 + 12] = "$HOSTBINARIES_PATH_STR";
static const char qt_configure_plugins_path_str      [256 + 12] = "$HOSTPLUGINS_PATH_STR";
static const char qt_configure_imports_path_str      [256 + 12] = "$HOSTIMPORTS_PATH_STR";
static const char qt_configure_data_path_str         [256 + 12] = "$HOSTDATA_PATH_STR";
static const char qt_configure_translations_path_str [256 + 12] = "$HOSTTRANSLATIONS_PATH_STR";
static const char qt_configure_settings_path_str     [256 + 12] = "$HOSTSETTINGS_PATH_STR";
static const char qt_configure_examples_path_str     [256 + 12] = "$HOSTEXAMPLES_PATH_STR";
static const char qt_configure_demos_path_str        [256 + 12] = "$HOSTDEMOS_PATH_STR";
#else // QT_BOOTSTRAPPED
EOF
fi

cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* Installation Info */
static const char qt_configure_prefix_path_str       [256 + 12] = "$PREFIX_PATH_STR";
static const char qt_configure_documentation_path_str[256 + 12] = "$DOCUMENTATION_PATH_STR";
static const char qt_configure_headers_path_str      [256 + 12] = "$HEADERS_PATH_STR";
static const char qt_configure_libraries_path_str    [256 + 12] = "$LIBRARIES_PATH_STR";
static const char qt_configure_binaries_path_str     [256 + 12] = "$BINARIES_PATH_STR";
static const char qt_configure_plugins_path_str      [256 + 12] = "$PLUGINS_PATH_STR";
static const char qt_configure_imports_path_str      [256 + 12] = "$IMPORTS_PATH_STR";
static const char qt_configure_data_path_str         [256 + 12] = "$DATA_PATH_STR";
static const char qt_configure_translations_path_str [256 + 12] = "$TRANSLATIONS_PATH_STR";
static const char qt_configure_settings_path_str     [256 + 12] = "$SETTINGS_PATH_STR";
static const char qt_configure_examples_path_str     [256 + 12] = "$EXAMPLES_PATH_STR";
static const char qt_configure_demos_path_str        [256 + 12] = "$DEMOS_PATH_STR";
EOF

if [ ! -z "$QT_HOST_PREFIX" ]; then
    cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
#endif // QT_BOOTSTRAPPED

EOF
fi

cat >> "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* strlen( "qt_lcnsxxxx" ) == 12 */
#define QT_CONFIGURE_LICENSEE qt_configure_licensee_str + 12;
#define QT_CONFIGURE_LICENSED_PRODUCTS qt_configure_licensed_products_str + 12;
#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12;
#define QT_CONFIGURE_DOCUMENTATION_PATH qt_configure_documentation_path_str + 12;
#define QT_CONFIGURE_HEADERS_PATH qt_configure_headers_path_str + 12;
#define QT_CONFIGURE_LIBRARIES_PATH qt_configure_libraries_path_str + 12;
#define QT_CONFIGURE_BINARIES_PATH qt_configure_binaries_path_str + 12;
#define QT_CONFIGURE_PLUGINS_PATH qt_configure_plugins_path_str + 12;
#define QT_CONFIGURE_IMPORTS_PATH qt_configure_imports_path_str + 12;
#define QT_CONFIGURE_DATA_PATH qt_configure_data_path_str + 12;
#define QT_CONFIGURE_TRANSLATIONS_PATH qt_configure_translations_path_str + 12;
#define QT_CONFIGURE_SETTINGS_PATH qt_configure_settings_path_str + 12;
#define QT_CONFIGURE_EXAMPLES_PATH qt_configure_examples_path_str + 12;
#define QT_CONFIGURE_DEMOS_PATH qt_configure_demos_path_str + 12;
EOF

# avoid unecessary rebuilds by copying only if qconfig.cpp has changed
if cmp -s "$outpath/src/corelib/global/qconfig.cpp" "$outpath/src/corelib/global/qconfig.cpp.new"; then
    rm -f "$outpath/src/corelib/global/qconfig.cpp.new"
else
    [ -f "$outpath/src/corelib/global/qconfig.cpp" ] && chmod +w "$outpath/src/corelib/global/qconfig.cpp"
    mv "$outpath/src/corelib/global/qconfig.cpp.new" "$outpath/src/corelib/global/qconfig.cpp"
    chmod -w "$outpath/src/corelib/global/qconfig.cpp"
fi

# -----------------------------------------------------------------------------
if [ "$LicenseType" = "Evaluation" ]; then
    EVALKEY=`"$relpath/config.tests/unix/padstring" 524 "qt_qevalkey=$LicenseKeyExt"`
elif echo "$D_FLAGS" | grep QT_EVAL >/dev/null 2>&1; then
    EVALKEY=`"$relpath/config.tests/unix/padstring" 524 "qt_qevalkey="`
fi

if [ -n "$EVALKEY" ]; then
    rm -f "$outpath/src/corelib/global/qconfig_eval.cpp"
    cat > "$outpath/src/corelib/global/qconfig_eval.cpp" <<EOF
/* Evaluation license key */
static const volatile char qt_eval_key_data                   [512 + 12] = "$EVALKEY";
EOF
    chmod -w "$outpath/src/corelib/global/qconfig_eval.cpp"
fi


# -----------------------------------------------------------------------------
# build qmake
# -----------------------------------------------------------------------------

# symlink includes
if [ -n "$PERL" ] && [ -x "$relpath/bin/syncqt" ]; then
    SYNCQT_OPTS=
    [ "$CFG_DEV" = "yes" ] && SYNCQT_OPTS="$SYNCQT_OPTS -check-includes"
    if [ "$OPT_SHADOW" = "yes" ]; then
        "$outpath/bin/syncqt" $SYNCQT_OPTS
    elif [ "$CFG_DEV" = "yes" ] || [ ! -d $relpath/include ] || [ -d $relpath/.git ]; then
        QTDIR="$relpath" perl "$outpath/bin/syncqt" $SYNCQT_OPTS
    fi
fi

# $1: variable name
# $2: optional transformation
# relies on $QMAKESPEC, $COMPILER_CONF and $mkfile being set correctly, as the latter
# is where the resulting variable is written to
# Assumes that the optional transformation produces the same variable name for each hit
setBootstrapVariable()
{
    getQMakeConf | $AWK '/^('"$1"')[^_A-Z0-9]/ { print $0; }' | ( [ -n "$2" ] && sed "$2" ; [ -z "$2" ] && cat ) | $AWK '
BEGIN {
    variable = ""
    combinedValue = ""
}
{
    valStart = index($0, "=") + 1

    append = 0
    if (substr($0, valStart - 2, 1) == "+") {
        append = 1
    }

    variable = substr($0, 0, valStart - 2 - append)
    value = substr($0, valStart)
    gsub("[ \t]+", "", variable)
    gsub("^[ \t]+", "", value)
    gsub("[ \t]+$", "", value)

    if (append == 1 && length(combinedValue) > 0) {
        combinedValue = combinedValue " " value
    } else {
        combinedValue = value
    }
}
END {
    if (length(combinedValue) > 0) {
        printf "%s = %s\n", variable, combinedValue
    }
}' >> "$mkfile"
}

# build qmake
if true; then ###[ '!' -f "$outpath/bin/qmake" ];
    echo "Creating qmake. Please wait..."

    OLD_QCONFIG_H=
    QCONFIG_H="$outpath/src/corelib/global/qconfig.h"
    QMAKE_QCONFIG_H="${QCONFIG_H}.qmake"
    if [ -f "$QCONFIG_H" ]; then
         OLD_QCONFIG_H=$QCONFIG_H
         mv -f "$OLD_QCONFIG_H" "${OLD_QCONFIG_H}.old"
    fi

    # create temporary qconfig.h for compiling qmake, if it doesn't exist
    # when building qmake, we use #defines for the install paths,
    # however they are real functions in the library
    if [ '!' -f "$QMAKE_QCONFIG_H" ]; then
        mkdir -p "$outpath/src/corelib/global"
        [ -f "$QCONFIG_H" ] && chmod +w "$QCONFIG_H"
        echo "/* All features enabled while building qmake */" >"$QMAKE_QCONFIG_H"
    fi

    mv -f "$QMAKE_QCONFIG_H" "$QCONFIG_H"

    #mkspecs/default is used as a (gasp!) default mkspec so QMAKESPEC needn't be set once configured
    rm -rf mkspecs/default
    if [ "$XPLATFORM_SYMBIAN_SBSV2" = "yes" ]; then
#Link is not supported for Symbian build system
        cp -a mkspecs/`echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"` mkspecs/default
    else
        ln -s `echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"` mkspecs/default
    fi
    # fix makefiles
    for mkfile in GNUmakefile Makefile; do
        EXTRA_LFLAGS=
        EXTRA_CFLAGS=
        in_mkfile="${mkfile}.in"
        if [ "$mkfile" = "Makefile" ]; then
#           if which qmake >/dev/null 2>&1 && [ -f qmake/qmake.pro ]; then
#               (cd qmake && qmake) >/dev/null 2>&1 && continue
#           fi
            in_mkfile="${mkfile}.unix"
        fi
        in_mkfile="$relpath/qmake/$in_mkfile"
        mkfile="$outpath/qmake/$mkfile"
        if [ -f "$mkfile" ]; then
            [ "$CFG_DEV" = "yes" ] && "$WHICH" chflags >/dev/null 2>&1 && chflags nouchg "$mkfile"
            rm -f "$mkfile"
        fi
        [ -f "$in_mkfile" ] || continue

        echo "########################################################################" > "$mkfile"
        echo "## This file was autogenerated by configure, all changes will be lost ##" >> "$mkfile"
        echo "########################################################################" >> "$mkfile"
        EXTRA_OBJS=
        EXTRA_SRCS=
        EXTRA_CFLAGS="\$(QMAKE_CFLAGS)"
        EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS)"
        EXTRA_LFLAGS="\$(QMAKE_LFLAGS)"

        if [ "$PLATFORM" = "irix-cc" ] || [ "$PLATFORM" = "irix-cc-64" ]; then
	    EXTRA_LFLAGS="$EXTRA_LFLAGS -lm"
        fi

	[ -n "$CC" ] && echo "CC = $CC" >> "$mkfile"
	[ -n "$CXX" ] && echo "CXX = $CXX" >> "$mkfile"
        if [ "$CFG_SILENT" = "yes" ]; then
            [ -z "$CC" ] && setBootstrapVariable QMAKE_CC 's,QMAKE_CC.*=,CC=\@,'
            [ -z "$CXX" ] && setBootstrapVariable QMAKE_CXX 's,QMAKE_CXX.*=,CXX=\@,'
        else
            [ -z "$CC" ] && setBootstrapVariable QMAKE_CC 's,QMAKE_CC,CC,'
            [ -z "$CXX" ] && setBootstrapVariable QMAKE_CXX 's,QMAKE_CXX,CXX,'
        fi
        setBootstrapVariable QMAKE_CFLAGS
        setBootstrapVariable QMAKE_CXXFLAGS 's,\$\$QMAKE_CFLAGS,\$(QMAKE_CFLAGS),'
        setBootstrapVariable QMAKE_LFLAGS

        if [ $QT_EDITION = "QT_EDITION_OPENSOURCE" ]; then
            EXTRA_CFLAGS="$EXTRA_CFLAGS -DQMAKE_OPENSOURCE_EDITION"
            EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -DQMAKE_OPENSOURCE_EDITION"
        fi
        if [ "$CFG_RELEASE_QMAKE" = "yes" ]; then
            setBootstrapVariable QMAKE_CFLAGS_RELEASE
            setBootstrapVariable QMAKE_CXXFLAGS_RELEASE 's,\$\$QMAKE_CFLAGS_RELEASE,\$(QMAKE_CFLAGS_RELEASE),'
            EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
            EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
        elif [ "$CFG_DEBUG" = "yes" ]; then
            setBootstrapVariable QMAKE_CFLAGS_DEBUG
            setBootstrapVariable QMAKE_CXXFLAGS_DEBUG 's,\$\$QMAKE_CFLAGS_DEBUG,\$(QMAKE_CFLAGS_DEBUG),'
            EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
            EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
        fi

        if [ '!' -z "$RPATH_FLAGS" ] && [ '!' -z "`getQMakeConf \"$QMAKESPEC\" | $AWK '/QMAKE_(LFLAGS_)?RPATH/ {print $3;}'`" ]; then
            setBootstrapVariable "QMAKE_(LFLAGS_)?RPATH" 's,\$\$LITERAL_WHITESPACE, ,;s,QMAKE_RPATH,QMAKE_LFLAGS_RPATH,'
            for rpath in $RPATH_FLAGS; do
                EXTRA_LFLAGS="\$(QMAKE_LFLAGS_RPATH)\"$rpath\" $EXTRA_LFLAGS"
            done
        fi
        if [ "$BUILD_ON_MAC" = "yes" ]; then
            echo "export MACOSX_DEPLOYMENT_TARGET = 10.4" >> "$mkfile"
            echo "CARBON_LFLAGS =-framework ApplicationServices" >>"$mkfile"
            echo "CARBON_CFLAGS =-fconstant-cfstrings" >>"$mkfile"
            EXTRA_LFLAGS="$EXTRA_LFLAGS \$(CARBON_LFLAGS)"
            EXTRA_CFLAGS="$EXTRA_CFLAGS \$(CARBON_CFLAGS)"
            EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(CARBON_CFLAGS)"
            EXTRA_OBJS="qsettings_mac.o qcore_mac.o"
            EXTRA_SRCS="\"$relpath/src/corelib/io/qsettings_mac.cpp\" \"$relpath/src/corelib/kernel/qcore_mac.cpp\""
	    if echo "$CFG_MAC_ARCHS" | grep x86 > /dev/null 2>&1; then # matches both x86 and x86_64
		X86_CFLAGS="-arch i386"
		X86_LFLAGS="-arch i386"
		EXTRA_CFLAGS="$X86_CFLAGS $EXTRA_CFLAGS"
		EXTRA_CXXFLAGS="$X86_CFLAGS $EXTRA_CXXFLAGS"
                EXTRA_LFLAGS="$EXTRA_LFLAGS $X86_LFLAGS"
            fi
	    if echo "$CFG_MAC_ARCHS" | grep ppc > /dev/null 2>&1; then # matches both ppc and ppc64
		PPC_CFLAGS="-arch ppc"
		PPC_LFLAGS="-arch ppc"
		EXTRA_CFLAGS="$PPC_CFLAGS $EXTRA_CFLAGS"
		EXTRA_CXXFLAGS="$PPC_CFLAGS $EXTRA_CXXFLAGS"
                EXTRA_LFLAGS="$EXTRA_LFLAGS $PPC_LFLAGS"
            fi
	    if [ '!' -z "$CFG_SDK" ]; then
		echo "SDK_LFLAGS =-Wl,-syslibroot,$CFG_SDK" >>"$mkfile"
		echo "SDK_CFLAGS =-isysroot $CFG_SDK" >>"$mkfile"
		EXTRA_CFLAGS="$EXTRA_CFLAGS \$(SDK_CFLAGS)"
		EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(SDK_CFLAGS)"
		EXTRA_LFLAGS="$EXTRA_LFLAGS \$(SDK_LFLAGS)"
            fi
        fi
        [ "$CFG_EMBEDDED" != "no" ] && EXTRA_CFLAGS="$EXTRA_CFLAGS -DQWS"
        if [ '!' -z "$D_FLAGS" ]; then
            for DEF in $D_FLAGS; do
                EXTRA_CFLAGS="$EXTRA_CFLAGS \"-D${DEF}\""
            done
        fi
        QMAKE_BIN_DIR="$QT_INSTALL_BINS"
        [ -z "$QMAKE_BIN_DIR" ] && QMAKE_BIN_DIR="${QT_INSTALL_PREFIX}/bin"
        QMAKE_DATA_DIR="$QT_INSTALL_DATA"
        [ -z "$QMAKE_DATA_DIR" ] && QMAKE_DATA_DIR="${QT_INSTALL_PREFIX}"
        echo >>"$mkfile"
	adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
	adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
	adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`
        sed -e "s,@SOURCE_PATH@,$adjrelpath,g" -e "s,@BUILD_PATH@,$adjoutpath,g" \
            -e "s,@QMAKE_CFLAGS@,$EXTRA_CFLAGS,g" -e "s,@QMAKE_LFLAGS@,$EXTRA_LFLAGS,g" \
            -e "s,@QMAKE_CXXFLAGS@,$EXTRA_CXXFLAGS,g" \
            -e "s,@QT_INSTALL_BINS@,\$(INSTALL_ROOT)$QMAKE_BIN_DIR,g" \
            -e "s,@QT_INSTALL_DATA@,\$(INSTALL_ROOT)$QMAKE_DATA_DIR,g" \
            -e "s,@QMAKE_QTOBJS@,$EXTRA_OBJS,g" -e "s,@QMAKE_QTSRCS@,$EXTRA_SRCS,g" \
	    -e "s,@QMAKESPEC@,$adjqmakespec,g" "$in_mkfile" >>"$mkfile"

        if "$WHICH" makedepend >/dev/null 2>&1 && grep 'depend:' "$mkfile" >/dev/null 2>&1; then
            (cd "$outpath/qmake" && "$MAKE" -f "$mkfile" depend) >/dev/null 2>&1
	    sed "s,^.*/\([^/]*.o\):,\1:,g" "$mkfile" >"$mkfile.tmp"
	    sed "s,$outpath,$adjoutpath,g" "$mkfile.tmp" >"$mkfile"
	    rm "$mkfile.tmp"
        fi
    done

    QMAKE_BUILD_ERROR=no
    (cd "$outpath/qmake"; "$MAKE") || QMAKE_BUILD_ERROR=yes
    [ '!' -z "$QCONFIG_H" ] && mv -f "$QCONFIG_H" "$QMAKE_QCONFIG_H" #move qmake's qconfig.h to qconfig.h.qmake
    [ '!' -z "$OLD_QCONFIG_H" ] && mv -f "${OLD_QCONFIG_H}.old" "$OLD_QCONFIG_H" #put back qconfig.h
    [ "$QMAKE_BUILD_ERROR" = "yes" ] && exit 2
fi # Build qmake

#-------------------------------------------------------------------------------
# tests that need qmake
#-------------------------------------------------------------------------------

# detect availability of float math.h functions
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/floatmath "floatmath" $L_FLAGS $I_FLAGS $l_FLAGS; then
    CFG_USE_FLOATMATH=yes
else
    CFG_USE_FLOATMATH=no
fi

# detect mmx support
if [ "${CFG_MMX}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mmx "mmx" $L_FLAGS $I_FLAGS $l_FLAGS "-mmmx"; then
	CFG_MMX=yes
    else
	CFG_MMX=no
    fi
fi

# detect 3dnow support
if [ "${CFG_3DNOW}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/3dnow "3dnow" $L_FLAGS $I_FLAGS $l_FLAGS "-m3dnow"; then
	CFG_3DNOW=yes
    else
	CFG_3DNOW=no
    fi
fi

# detect sse support
if [ "${CFG_SSE}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse "sse" $L_FLAGS $I_FLAGS $l_FLAGS "-msse"; then
	CFG_SSE=yes
    else
	CFG_SSE=no
    fi
fi

# detect sse2 support
if [ "${CFG_SSE2}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse2 "sse2" $L_FLAGS $I_FLAGS $l_FLAGS "-msse2"; then
       CFG_SSE2=yes
    else
       CFG_SSE2=no
    fi
fi

# detect sse3 support
if [ "${CFG_SSE3}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse3 "sse3" $L_FLAGS $I_FLAGS $l_FLAGS "-msse3"; then
       CFG_SSE3=yes
    else
       CFG_SSE3=no
    fi
fi

# detect ssse3 support
if [ "${CFG_SSSE3}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ssse3 "ssse3" $L_FLAGS $I_FLAGS $l_FLAGS "-mssse3"; then
       CFG_SSSE3=yes
    else
       CFG_SSSE3=no
    fi
fi

# detect sse4.1 support
if [ "${CFG_SSE4_1}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse4_1 "sse4_1" $L_FLAGS $I_FLAGS $l_FLAGS "-msse4.1"; then
       CFG_SSE4_1=yes
    else
       CFG_SSE4_1=no
    fi
fi

# detect sse4.2 support
if [ "${CFG_SSE4_2}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sse4_2 "sse4_2" $L_FLAGS $I_FLAGS $l_FLAGS "-msse4.2"; then
       CFG_SSE4_2=yes
    else
       CFG_SSE4_2=no
    fi
fi

# detect avx support
if [ "${CFG_AVX}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/avx "avx" $L_FLAGS $I_FLAGS $l_FLAGS "-mavx"; then
       CFG_AVX=yes
    else
       CFG_AVX=no
    fi
fi

# check iWMMXt support
if [ "$CFG_IWMMXT" = "yes" ]; then
    "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/iwmmxt "iwmmxt" $L_FLAGS $I_FLAGS $l_FLAGS "-mcpu=iwmmxt"
    if [ $? != "0" ]; then
        echo "The iWMMXt functionality test failed!"
	echo " Please make sure your compiler supports iWMMXt intrinsics!"
	exit 1
    fi
fi

# detect neon support
if [ "$CFG_ARCH" = "arm" ] && [ "${CFG_NEON}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/neon "neon" $L_FLAGS $I_FLAGS $l_FLAGS "-mfpu=neon"; then
	CFG_NEON=yes
    else
	CFG_NEON=no
    fi
fi

[ "$XPLATFORM_MINGW" = "yes" ] && QMakeVar add styles "windowsxp windowsvista"

if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    QMakeVar set styles "windows s60"   #overwrite previous default
    CFG_LIBFREETYPE=no
    CFG_ZLIB=yes

    if [ "$CFG_LARGEFILE" = auto ]; then
        CFG_LARGEFILE=no
    fi
    if [ "$CFG_PHONON" = auto ]; then
        CFG_PHONON=yes
    fi

    if test -z "$EPOCROOT"; then
        echo "Please export EPOCROOT. It should point to the sdk install dir"
        exit 1
    fi
    if test ! -d "$EPOCROOT/epoc32"; then
        echo "Could not find the 'epoc32' dir in your EPOCROOT."
        exit 1
    fi

    if [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
        # Raptor does not support configure tests.

        # the main commands needed to compile;
        (mkdir -p config.tests/symbian/rcomp
            cd config.tests/symbian/rcomp
            rm -f rcomp_test.rsg
            touch rcomp_test.rpp rcomp_test.rsc rcomp_test.rss
            rcomp -u -m045,046,047 -s./rcomp_test.rpp -o./rcomp_test.rsc -h./rcomp_test.rsg -i./rcomp_test.rss 2>&1 > /dev/null
            if test ! -f rcomp_test.rsg; then
                echo "Finding a working rcomp in your PATH failed."
                echo "Fatal error. Make sure you have the epoc tools working and in your PATH";
                exit 1;
            fi
        )

        # compile a simple main that uses printf
        if ! "$symbiantests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/symbian/simple "simple" $L_FLAGS $I_FLAGS $l_FLAGS
        then
            echo "Testing your compiler failed. Could not compile a simple application."
            echo "Fatal error; Rerun configure with -verbose to get more details."
            exit 1;
        fi
    fi
fi

# detect zlib
if [ "$CFG_ZLIB" = "no" ]; then
    # Note: Qt no longer support builds without zlib
    # So we force a "no" to be "auto" here.
    # If you REALLY really need no zlib support, you can still disable
    # it by doing the following:
    #   add "no-zlib" to mkspecs/qconfig.pri
    #   #define QT_NO_COMPRESS (probably by adding to src/corelib/global/qconfig.h)
    #
    # There's no guarantee that Qt will build under those conditions

    CFG_ZLIB=auto
    ZLIB_FORCED=yes
fi
if [ "$CFG_ZLIB" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/zlib "zlib" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
       CFG_ZLIB=system
    else
       CFG_ZLIB=yes
    fi
fi

if [ "$CFG_LARGEFILE" = "auto" ]; then
    #Large files should be enabled for all Linux systems
    CFG_LARGEFILE=yes
fi


if [ "$CFG_S60" = "auto" ]; then
    if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        CFG_S60=yes
    else
        CFG_S60=no
    fi
fi

if [ "$CFG_QS60STYLE" = "auto" ]; then
    if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        CFG_QS60STYLE=qt
    else
        CFG_QS60STYLE=no
    fi
fi

if [ "$CFG_SYMBIAN_DEFFILES" = "auto" ]; then
    if [ "$XPLATFORM_SYMBIAN" = "yes" ] && [ "$CFG_DEV" = "no" ]; then
        CFG_SYMBIAN_DEFFILES=yes
    else
        CFG_SYMBIAN_DEFFILES=no
    fi
fi

# detect how jpeg should be built
if [ "$CFG_JPEG" = "auto" ]; then
    if [ "$CFG_SHARED" = "yes" ]; then
        CFG_JPEG=plugin
    else
        CFG_JPEG=yes
    fi
fi
# detect jpeg
if [ "$CFG_LIBJPEG" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libjpeg "libjpeg" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
       CFG_LIBJPEG=system
    else
       CFG_LIBJPEG=qt
    fi
fi

# detect how gif should be built
if [ "$CFG_GIF" = "auto" ]; then
    if [ "$CFG_SHARED" = "yes" ]; then
        CFG_GIF=plugin
    else
        CFG_GIF=yes
    fi
fi

# detect how tiff should be built
if [ "$CFG_TIFF" = "auto" ]; then
    if [ "$CFG_SHARED" = "yes" ]; then
        CFG_TIFF=plugin
    else
        CFG_TIFF=yes
    fi
fi

# detect tiff
if [ "$CFG_LIBTIFF" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libtiff "libtiff" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_LIBTIFF=system
    else
        CFG_LIBTIFF=qt
    fi
fi

# detect how mng should be built
if [ "$CFG_MNG" = "auto" ]; then
    if [ "$CFG_SHARED" = "yes" ]; then
        CFG_MNG=plugin
    else
        CFG_MNG=yes
    fi
fi
# detect mng
if [ "$CFG_LIBMNG" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libmng "libmng" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
       CFG_LIBMNG=system
    else
       CFG_LIBMNG=qt
    fi
fi

# detect png
if [ "$CFG_LIBPNG" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libpng "libpng" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
       CFG_LIBPNG=system
    else
       CFG_LIBPNG=qt
    fi
fi

# detect accessibility
if [ "$CFG_ACCESSIBILITY" = "auto" ]; then
    if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        # accessibility is currently unsupported
        CFG_ACCESSIBILITY=no
    else
        CFG_ACCESSIBILITY=yes
    fi
fi

# auto-detect SQL-modules support
for _SQLDR in $CFG_SQL_AVAILABLE; do
        case $_SQLDR in
        mysql)
            if [ "$CFG_SQL_mysql" != "no" ]; then
		[ -z "$CFG_MYSQL_CONFIG" ] && CFG_MYSQL_CONFIG=`"$WHICH" mysql_config`
                if [ -x "$CFG_MYSQL_CONFIG" ]; then
                    QT_CFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --include 2>/dev/null`
                    QT_LFLAGS_MYSQL_R=`$CFG_MYSQL_CONFIG --libs_r 2>/dev/null`
                    QT_LFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --libs 2>/dev/null`
		    QT_MYSQL_VERSION=`$CFG_MYSQL_CONFIG --version 2>/dev/null`
                    QT_MYSQL_VERSION_MAJOR=`echo $QT_MYSQL_VERSION | cut -d . -f 1`
                fi
                if [ -n "$QT_MYSQL_VERSION" ] && [ "$QT_MYSQL_VERSION_MAJOR" -lt 4 ]; then
                    if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "This version of MySql is not supported ($QT_MYSQL_VERSION)."
                        echo " You need MySql 4 or higher."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_mysql="no"
			QT_LFLAGS_MYSQL=""
			QT_LFLAGS_MYSQL_R=""
			QT_CFLAGS_MYSQL=""
                    fi
                else
                    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mysql_r "MySQL (thread-safe)" $QT_LFLAGS_MYSQL_R $L_FLAGS $QT_CFLAGS_MYSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                        QMakeVar add CONFIG use_libmysqlclient_r
                        if [ "$CFG_SQL_mysql" = "auto" ]; then
                            CFG_SQL_mysql=plugin
                        fi
                        QT_LFLAGS_MYSQL="$QT_LFLAGS_MYSQL_R"
                    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mysql "MySQL (thread-unsafe)" $QT_LFLAGS_MYSQL $L_FLAGS $QT_CFLAGS_MYSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                        if [ "$CFG_SQL_mysql" = "auto" ]; then
                            CFG_SQL_mysql=plugin
                        fi
                    else
                        if [ "$CFG_SQL_mysql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                            echo "MySQL support cannot be enabled due to functionality tests!"
                            echo " Turn on verbose messaging (-v) to $0 to see the final report."
                            echo " If you believe this message is in error you may use the continue"
                            echo " switch (-continue) to $0 to continue."
                            exit 101
                        else
                            CFG_SQL_mysql=no
			    QT_LFLAGS_MYSQL=""
			    QT_LFLAGS_MYSQL_R=""
			    QT_CFLAGS_MYSQL=""
                        fi
                    fi
                fi
            fi
            ;;
        psql)
            if [ "$CFG_SQL_psql" != "no" ]; then
                # Be careful not to use native pg_config when cross building.
                if [ "$XPLATFORM_MINGW" != "yes" ] && "$WHICH" pg_config >/dev/null 2>&1; then
                    QT_CFLAGS_PSQL=`pg_config --includedir 2>/dev/null`
                    QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null`
                fi
                [ -z "$QT_CFLAGS_PSQL" ] || QT_CFLAGS_PSQL="-I$QT_CFLAGS_PSQL"
                [ -z "$QT_LFLAGS_PSQL" ] || QT_LFLAGS_PSQL="-L$QT_LFLAGS_PSQL"
                # But, respect PSQL_LIBS if set
                [ -z "$PSQL_LIBS" ] || QT_LFLAGS_PSQL="$PSQL_LIBS"
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/psql "PostgreSQL" $QT_LFLAGS_PSQL $L_FLAGS $QT_CFLAGS_PSQL $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_psql" = "auto" ]; then
                        CFG_SQL_psql=plugin
                    fi
                else
                    if [ "$CFG_SQL_psql" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "PostgreSQL support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_psql=no
                        QT_CFLAGS_PSQL=""
                        QT_LFLAGS_PSQL=""
                    fi
                fi
            fi
        ;;
        odbc)
            if [ "$CFG_SQL_odbc" != "no" ]; then
                if ( [ "$PLATFORM_MAC" != "yes" ] || [ "$XPLATFORM_MINGW" = "yes" ] ) && "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/odbc "ODBC" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_odbc" = "auto" ]; then
                        CFG_SQL_odbc=plugin
                    fi
                else
                    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/iodbc "iODBC" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                        QT_LFLAGS_ODBC="-liodbc"
                        if [ "$CFG_SQL_odbc" = "auto" ]; then
                            CFG_SQL_odbc=plugin
                        fi
                    else
                        if [ "$CFG_SQL_odbc" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                            echo "ODBC support cannot be enabled due to functionality tests!"
                            echo " Turn on verbose messaging (-v) to $0 to see the final report."
                            echo " If you believe this message is in error you may use the continue"
                            echo " switch (-continue) to $0 to continue."
                            exit 101
                        else
                            CFG_SQL_odbc=no
                        fi
                    fi
                fi
            fi
            ;;
        oci)
            if [ "$CFG_SQL_oci" != "no" ]; then
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/oci "OCI" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_oci" = "auto" ]; then
                        CFG_SQL_oci=plugin
                    fi
                else
                    if [ "$CFG_SQL_oci" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "Oracle (OCI) support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_oci=no
                    fi
                fi
            fi
            ;;
        tds)
            if [ "$CFG_SQL_tds" != "no" ]; then
                [ -z "$SYBASE" ] || QT_LFLAGS_TDS="-L$SYBASE/lib"
                [ -z "$SYBASE_LIBS" ] || QT_LFLAGS_TDS="$QT_LFLAGS_TDS $SYBASE_LIBS"
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/tds "TDS" $QT_LFLAGS_TDS $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_tds" = "auto" ]; then
                        CFG_SQL_tds=plugin
                    fi
                else
                    if [ "$CFG_SQL_tds" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "TDS support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_tds=no
                    fi
                fi
            fi
            ;;
        db2)
            if [ "$CFG_SQL_db2" != "no" ]; then
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/db2 "DB2" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_db2" = "auto" ]; then
                        CFG_SQL_db2=plugin
                    fi
                else
                    if [ "$CFG_SQL_db2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "ODBC support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_db2=no
                    fi
                fi
            fi
            ;;
        ibase)
            if [ "$CFG_SQL_ibase" != "no" ]; then
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ibase "InterBase" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_ibase" = "auto" ]; then
                        CFG_SQL_ibase=plugin
                    fi
                else
                    if [ "$CFG_SQL_ibase" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "InterBase support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_ibase=no
                    fi
                fi
            fi
            ;;
        sqlite2)
            if [ "$CFG_SQL_sqlite2" != "no" ]; then
                if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sqlite2 "SQLite2" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                    if [ "$CFG_SQL_sqlite2" = "auto" ]; then
                        CFG_SQL_sqlite2=plugin
                    fi
                else
                    if [ "$CFG_SQL_sqlite2" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                        echo "SQLite2 support cannot be enabled due to functionality tests!"
                        echo " Turn on verbose messaging (-v) to $0 to see the final report."
                        echo " If you believe this message is in error you may use the continue"
                        echo " switch (-continue) to $0 to continue."
                        exit 101
                    else
                        CFG_SQL_sqlite2=no
                    fi
                fi
            fi
            ;;
        sqlite)
            if [ "$CFG_SQL_sqlite" = "auto" ]; then # the default
                if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
                    # sqlite on symbian is typically not build in Qt but deployed as a pre-existing sis file and should be marked as driver.
                    # Configuration parameters should be set
                    CFG_SQL_sqlite=qt
                    QT_LFLAGS_SQLITE=-lsqlite3
                    QMAKE_CONFIG="$QMAKE_CONFIG system-sqlite"
                fi
            fi
            if [ "$CFG_SQL_sqlite" != "no" ]; then
                SQLITE_AUTODETECT_FAILED="no"
                if [ "$CFG_SQLITE" = "system" ]; then
                    if [ -n "$PKG_CONFIG" ]; then
                        QT_CFLAGS_SQLITE=`$PKG_CONFIG --cflags sqlite3 2>/dev/null`
                        QT_LFLAGS_SQLITE=`$PKG_CONFIG --libs sqlite3 2>/dev/null`
                    fi
                    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/sqlite "SQLite" $QT_LFLAGS_SQLITE $L_FLAGS $QT_CFLAGS_SQLITE $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
                        if [ "$CFG_SQL_sqlite" = "auto" ]; then
                            CFG_SQL_sqlite=plugin
                        fi
                        QMAKE_CONFIG="$QMAKE_CONFIG system-sqlite"
                    else
                        SQLITE_AUTODETECT_FAILED="yes"
                        CFG_SQL_sqlite=no
                    fi
                elif [ -f "$relpath/src/3rdparty/sqlite/sqlite3.h" ]; then
                    if [ "$CFG_SQL_sqlite" = "auto" ]; then
                            CFG_SQL_sqlite=plugin
                    fi
                else
                    SQLITE_AUTODETECT_FAILED="yes"
                    CFG_SQL_sqlite=no
                fi

                if [ "$SQLITE_AUTODETECT_FAILED" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                    echo "SQLite support cannot be enabled due to functionality tests!"
                    echo " Turn on verbose messaging (-v) to $0 to see the final report."
                    echo " If you believe this message is in error you may use the continue"
                    echo " switch (-continue) to $0 to continue."
                    exit 101
                fi
            fi
            ;;
        *)
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo "unknown SQL driver: $_SQLDR"
            fi
            ;;
        esac
done

# auto-detect NIS support
if [ "$CFG_NIS" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/nis "NIS" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_NIS=yes
    else
        if [ "$CFG_NIS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "NIS support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_NIS=no
        fi
    fi
fi

# auto-detect CUPS support
if [ "$CFG_CUPS" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/cups "Cups" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_CUPS=yes
    else
        if [ "$CFG_CUPS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "Cups support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_CUPS=no
        fi
    fi
fi

# auto-detect iconv(3) support
if [ "$CFG_ICONV" != "no" ]; then
    if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
	CFG_ICONV=no
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" "$OPT_VERBOSE" "$relpath" "$outpath" "config.tests/unix/iconv" "POSIX iconv" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_ICONV=yes
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" "$OPT_VERBOSE" "$relpath" "$outpath" "config.tests/unix/sun-libiconv" "SUN libiconv" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_ICONV=sun
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" "$OPT_VERBOSE" "$relpath" "$outpath" "config.tests/unix/gnu-libiconv" "GNU libiconv" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_ICONV=gnu
    else
        if [ "$CFG_ICONV" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "Iconv support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_ICONV=no
        fi
    fi
fi

# auto-detect libdbus-1 support
if [ "$CFG_DBUS" != "no" ]; then
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --atleast-version="$MIN_DBUS_1_VERSION" dbus-1 2>/dev/null; then
        QT_CFLAGS_DBUS=`$PKG_CONFIG --cflags dbus-1 2>/dev/null`
        QT_LIBS_DBUS=`$PKG_CONFIG --libs dbus-1 2>/dev/null`
    fi
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/dbus "D-Bus" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_DBUS $QT_LIBS_DBUS $MAC_CONFIG_TEST_COMMANDLINE; then
        [ "$CFG_DBUS" = "auto" ] && CFG_DBUS=yes
        QMakeVar set QT_CFLAGS_DBUS "$QT_CFLAGS_DBUS"
        QMakeVar set QT_LIBS_DBUS "$QT_LIBS_DBUS"
    else
        if [ "$CFG_DBUS" = "auto" ]; then
            CFG_DBUS=no
        elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            # CFG_DBUS is "yes" or "linked" here

            echo "The QtDBus module cannot be enabled because libdbus-1 version $MIN_DBUS_1_VERSION was not found."
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        fi
    fi
fi

if [ "$CFG_MULTIMEDIA" = "auto" ]; then
    CFG_MULTIMEDIA="$CFG_GUI"
fi

if [ "$CFG_MULTIMEDIA" = "yes" ] && [ "$CFG_GUI" = "no" ]; then
    echo "QtMultimedia requested, but it can't be built without QtGui"
    exit 1
fi

# Generate a CRC of the namespace for using in constants for the Carbon port.
# This should mean that you really *can* load two Qt's and have our custom
# Carbon events work.
if [ "$PLATFORM_MAC" = "yes" -a ! -z "$QT_NAMESPACE" ]; then
    QT_NAMESPACE_MAC_CRC=`"$mactests/crc.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/mac/crc $QT_NAMESPACE $L_FLAGS $I_FLAGS $l_FLAGS`
fi

# X11/QWS/Lighthouse
if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then

    # auto-detect Glib support
    if [ "$CFG_GLIB" != "no" ]; then
        if [ -n "$PKG_CONFIG" ]; then
            QT_CFLAGS_GLIB=`$PKG_CONFIG --cflags glib-2.0 gthread-2.0 2>/dev/null`
            QT_LIBS_GLIB=`$PKG_CONFIG --libs glib-2.0 gthread-2.0 2>/dev/null`
        fi
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/glib "Glib" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_GLIB $QT_LIBS_GLIB $X11TESTS_FLAGS ; then
            CFG_GLIB=yes
            QMakeVar set QT_CFLAGS_GLIB "$QT_CFLAGS_GLIB"
            QMakeVar set QT_LIBS_GLIB "$QT_LIBS_GLIB"
        else
            if [ "$CFG_GLIB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                echo "Glib support cannot be enabled due to functionality tests!"
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            else
                CFG_GLIB=no
            fi
        fi
    fi

    if [ "$CFG_GUI" = "no" ]; then
        if [ "$CFG_PHONON" = "auto" ]; then
            CFG_PHONON=no
        fi
        if [ "$CFG_PHONON" != "no" ]; then
            echo "Phonon enabled, but GUI disabled."
            echo " You might need to either enable the GUI or disable Phonon"
            exit 1
        fi
    fi

    # Auto-detect GStreamer support (needed for Phonon)
    if [ "$CFG_PHONON" != "no" ]; then
        if [ "$CFG_GLIB" = "yes" -a "$CFG_GSTREAMER" != "no" ]; then
            if [ -n "$PKG_CONFIG" ]; then
                QT_CFLAGS_GSTREAMER=`$PKG_CONFIG --cflags gstreamer-0.10 gstreamer-plugins-base-0.10 2>/dev/null`
                QT_LIBS_GSTREAMER=`$PKG_CONFIG --libs gstreamer-0.10 gstreamer-plugins-base-0.10 2>/dev/null`
            fi
            if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/gstreamer "GStreamer" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_GSTREAMER $QT_LIBS_GSTREAMER $X11TESTS_FLAGS; then
                CFG_GSTREAMER=yes
                QMakeVar set QT_CFLAGS_GSTREAMER "$QT_CFLAGS_GSTREAMER"
                QMakeVar set QT_LIBS_GSTREAMER "$QT_LIBS_GSTREAMER"
            else
                if [ "$CFG_GSTREAMER" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                    echo "Gstreamer support cannot be enabled due to functionality tests!"
                    echo " Turn on verbose messaging (-v) to $0 to see the final report."
                    echo " If you believe this message is in error you may use the continue"
                    echo " switch (-continue) to $0 to continue."
                    exit 101
                else
                    CFG_GSTREAMER=no
                fi
            fi
        elif [ "$CFG_GLIB" = "no" ]; then
            CFG_GSTREAMER=no
        fi
    else
        CFG_GSTREAMER=no
    fi

    if [ "$CFG_PHONON" != "no" ]; then
        if [ "$CFG_PHONON_BACKEND" != "no" ]; then
            if [ "$CFG_GSTREAMER" = "yes" ]; then
                CFG_PHONON=yes
            else
                if [ "$CFG_PHONON" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                    echo "Phonon support cannot be enabled due to functionality tests!"
                    echo " Turn on verbose messaging (-v) to $0 to see the final report."
                    echo " If you believe this message is in error you may use the continue"
                    echo " switch (-continue) to $0 to continue."
                    exit 101
                else
                    CFG_PHONON=no
                fi
            fi
        else
            CFG_PHONON=yes
        fi
    fi

    # auto-detect icd support
    if [ "$CFG_GLIB" = "yes" -a "$CFG_ICD" != "no" ]; then
        if [ -n "$PKG_CONFIG" ]; then
            QT_CFLAGS_CONNSETTINGS=`$PKG_CONFIG --cflags connsettings icd2 2>/dev/null`
            QT_LIBS_CONNSETTINGS=`$PKG_CONFIG --libs connsettings icd2 2>/dev/null`
        fi
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/icd "ICD" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_CONNSETTINGS $QT_LIBS_CONNSETTINGS; then
            [ "$CFG_ICD" = "auto" ] && CFG_ICD=yes
            QMakeVar set QT_CFLAGS_CONNSETTINGS "$QT_CFLAGS_CONNSETTINGS"
            QMakeVar set QT_LIBS_CONNSETTINGS "$QT_LIBS_CONNSETTINGS"
        else
            if [ "$CFG_ICD" = "auto" ]; then
                CFG_ICD=no
            elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                # CFG_ICD is "yes"

                echo "The ICD Bearer Management plugin cannot be enabled because connsettings was not found."
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            fi
        fi
    elif [ "$CFG_GLIB" = "no" ]; then
        CFG_ICD=no
    fi

    # Auto-detect PulseAudio support
    if [ "$CFG_PULSEAUDIO" != "no" ]; then
        if [ -n "$PKG_CONFIG" ]; then
            QT_CFLAGS_PULSEAUDIO=`$PKG_CONFIG --cflags libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
            QT_LIBS_PULSEAUDIO=`$PKG_CONFIG --libs libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
        fi
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/pulseaudio "PulseAudio" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_PULSEAUDIO $QT_LIBS_PULSEAUDIO $X11TESTS_FLAGS; then
            CFG_PULSEAUDIO=yes
            QMakeVar set QT_CFLAGS_PULSEAUDIO "$QT_CFLAGS_PULSEAUDIO"
            QMakeVar set QT_LIBS_PULSEAUDIO "$QT_LIBS_PULSEAUDIO"
        else
            if [ "$CFG_PULSEAUDIO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                echo "PulseAudio support cannot be enabled due to functionality tests!"
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            else
		CFG_PULSEAUDIO=no
            fi
        fi
    fi
fi # X11/QWS/Lighthouse

# X11
if [ "$PLATFORM_X11" = "yes" ]; then
    x11tests="$relpath/config.tests/x11"
    X11TESTS_FLAGS=

    # work around broken X11 headers when using GCC 2.95 or later
    NOTYPE=no
    "$x11tests/notype.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath" && NOTYPE=yes
    if [ $NOTYPE = "yes" ]; then
	QMakeVar add QMAKE_CXXFLAGS -fpermissive
        X11TESTS_FLAGS="$X11TESTS_FLAGS -fpermissive"
    fi

    # Check we actually have X11 :-)
    "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xlib "XLib" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
    if [ $? != "0" ]; then
        echo "Basic XLib functionality test failed!"
        echo " You might need to modify the include and library search paths by editing"
        echo " QMAKE_INCDIR_X11 and QMAKE_LIBDIR_X11 in ${XQMAKESPEC}."
        exit 1
    fi
fi

# X11/MINGW OpenGL
if [ "$PLATFORM_X11" = "yes" -o "$XPLATFORM_MINGW" = "yes" ]; then
    # auto-detect OpenGL support (es1 = OpenGL ES 1.x Common, es2 = OpenGL ES 2.x)
    if [ "$CFG_GUI" = "no" ]; then
        if [ "$CFG_OPENGL" = "auto" ]; then
            CFG_OPENGL=no
        fi
        if [ "$CFG_OPENGL" != "no" ]; then
            echo "OpenGL enabled, but GUI disabled."
            echo " You might need to either enable the GUI or disable OpenGL"
            exit 1
        fi
    fi
    if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/opengl "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
            CFG_OPENGL=desktop
        elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es2
            if [ "$CFG_EGL" = "no" ]; then
                CFG_EGL=auto
            fi
        elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es1
            if [ "$CFG_EGL" = "no" ]; then
                CFG_EGL=auto
            fi
        else
            if [ "$CFG_OPENGL" = "yes" ]; then
                echo "All the OpenGL functionality tests failed!"
                echo " You might need to modify the include and library search paths by editing"
                echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
                echo " ${XQMAKESPEC}."
                exit 1
            fi
            CFG_OPENGL=no
        fi
        case "$PLATFORM" in
        hpux*)
            # HP-UX have buggy glx headers; check if we really need to define the GLXFBConfig struct.
            if [ "$CFG_OPENGL" = "desktop" ]; then
                "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/glxfbconfig "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
                if [ $? != "0" ]; then
                    QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
                fi
            fi
            ;;
        *)
            ;;
        esac
    elif [ "$CFG_OPENGL" = "es1" ]; then
        # OpenGL ES 1.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 1.x functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL_ES1, QMAKE_LIBDIR_OPENGL_ES1 and QMAKE_LIBS_OPENGL_ES1 in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    elif [ "$CFG_OPENGL" = "es2" ]; then
        #OpenGL ES 2.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 2.0 functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL_ES2, QMAKE_LIBDIR_OPENGL_ES2 and QMAKE_LIBS_OPENGL_ES2 in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    elif [ "$CFG_OPENGL" = "desktop" ]; then
        # Desktop OpenGL support
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/opengl "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
        case "$PLATFORM" in
        hpux*)
            # HP-UX have buggy glx headers; check if we really need to define the GLXFBConfig struct.
            "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/glxfbconfig "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
            if [ $? != "0" ]; then
                QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
            fi
            ;;
        *)
            ;;
        esac
    fi

    # if opengl is disabled and the user specified graphicssystem gl, disable it...
    if [ "$CFG_GRAPHICS_SYSTEM" = "opengl" ] && [ "$CFG_OPENGL" = "no" ]; then
	echo "OpenGL Graphics System is disabled due to missing OpenGL support..."
	CFG_GRAPHICS_SYSTEM=default
    fi
fi # X11/MINGW OpenGL

# X11
if [ "$PLATFORM_X11" = "yes" ]; then
    # auto-detect Xcursor support
    if [ "$CFG_XCURSOR" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xcursor "Xcursor" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    if [ "$CFG_XCURSOR" != "runtime" ]; then
		CFG_XCURSOR=yes;
	    fi
	else
	    if [ "$CFG_XCURSOR" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Xcursor support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XCURSOR=no
	    fi
	fi
    fi

    # auto-detect Xfixes support
    if [ "$CFG_XFIXES" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xfixes "Xfixes" $L_FLAGS $I_FLAGS $X11TESTS_FLAGS; then
	    if [ "$CFG_XFIXES" != "runtime" ]; then
		CFG_XFIXES=yes;
	    fi
	else
	    if [ "$CFG_XFIXES" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Xfixes support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XFIXES=no
	    fi
	fi
    fi

    # auto-detect Xrandr support (resize and rotate extension)
    if [ "$CFG_XRANDR" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xrandr "Xrandr" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
            if [ "$CFG_XRANDR" != "runtime" ]; then
	    CFG_XRANDR=yes
            fi
	else
	    if [ "$CFG_XRANDR" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Xrandr support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XRANDR=no
	    fi
	fi
    fi

    # auto-detect Xrender support
    if [ "$CFG_XRENDER" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xrender "Xrender" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_XRENDER=yes
	else
	    if [ "$CFG_XRENDER" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Xrender support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XRENDER=no
	    fi
	fi
    fi

    # Additional check to decide if WebKit support will be included
    if [ "$CFG_XRENDER" = "no" ] && [ "$CFG_WEBKIT" != "no" ]; then
        echo "Warning: -no-xrender will disable the QtWebkit module."
        CFG_WEBKIT="no"
    fi

    # auto-detect MIT-SHM support
    if [ "$CFG_MITSHM" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/mitshm "mitshm" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_MITSHM=yes
	else
	    if [ "$CFG_MITSHM" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "MITSHM support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_MITSHM=no
	    fi
	fi
    fi

    # auto-detect FontConfig support
    if [ "$CFG_FONTCONFIG" != "no" ]; then
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists fontconfig --exists freetype2 2>/dev/null; then
        QT_CFLAGS_FONTCONFIG=`$PKG_CONFIG --cflags fontconfig --cflags freetype2 2>/dev/null`
        QT_LIBS_FONTCONFIG=`$PKG_CONFIG --libs fontconfig --libs freetype2 2>/dev/null`
    else
        QT_CFLAGS_FONTCONFIG=
        QT_LIBS_FONTCONFIG="-lfreetype -lfontconfig"
    fi
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/fontconfig "FontConfig" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS $QT_CFLAGS_FONTCONFIG $QT_LIBS_FONTCONFIG; then
	    CFG_FONTCONFIG=yes
        QMakeVar set QMAKE_CFLAGS_X11 "$QT_CFLAGS_FONTCONFIG \$\$QMAKE_CFLAGS_X11"
        QMakeVar set QMAKE_LIBS_X11 "$QT_LIBS_FONTCONFIG \$\$QMAKE_LIBS_X11"
	    CFG_LIBFREETYPE=system
	else
	    if [ "$CFG_FONTCONFIG" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "FontConfig support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_FONTCONFIG=no
	    fi
	fi
    fi

    # auto-detect Session Management support
    if [ "$CFG_SM" = "auto" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/sm "Session Management" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_SM=yes
	else
	    if [ "$CFG_SM" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Session Management support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_SM=no
	    fi
	fi
    fi

    # auto-detect SHAPE support
    if [ "$CFG_XSHAPE" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xshape "XShape" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_XSHAPE=yes
	else
	    if [ "$CFG_XSHAPE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "XShape support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XSHAPE=no
	    fi
	fi
    fi

    # auto-detect XVideo support
    if [ "$CFG_XVIDEO" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xvideo "XVideo" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_XVIDEO=yes
	else
	    if [ "$CFG_XVIDEO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "XVideo support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XVIDEO=no
	    fi
	fi
    fi

    # auto-detect XSync support
    if [ "$CFG_XSYNC" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xsync "XSync" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    CFG_XSYNC=yes
	else
	    if [ "$CFG_XSYNC" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "XSync support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XSYNC=no
	    fi
	fi
    fi

    # auto-detect Xinerama support
    if [ "$CFG_XINERAMA" != "no" ]; then
	if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xinerama "Xinerama" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    if [ "$CFG_XINERAMA" != "runtime" ]; then
		CFG_XINERAMA=yes
	    fi
	else
	    if [ "$CFG_XINERAMA" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
		echo "Xinerama support cannot be enabled due to functionality tests!"
		echo " Turn on verbose messaging (-v) to $0 to see the final report."
		echo " If you believe this message is in error you may use the continue"
		echo " switch (-continue) to $0 to continue."
		exit 101
	    else
		CFG_XINERAMA=no
	    fi
	fi
    fi

    # auto-detect Xinput support
    if [ "$CFG_XINPUT" != "no" ]; then
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xinput "XInput" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
	    if [ "$CFG_XINPUT" != "runtime" ]; then
		CFG_XINPUT=yes
	    fi
        else
            if [ "$CFG_XINPUT" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                echo "Tablet and Xinput support cannot be enabled due to functionality tests!"
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            else
                CFG_XINPUT=no
            fi
        fi
    fi

    # auto-detect XKB support
    if [ "$CFG_XKB" != "no" ]; then
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/xkb "XKB" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
            CFG_XKB=yes
        else
            if [ "$CFG_XKB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                echo "XKB support cannot be enabled due to functionality tests!"
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            else
                CFG_XKB=no
            fi
        fi
    fi

    if [ "$CFG_GLIB" = "yes" -a "$CFG_QGTKSTYLE" != "no" ]; then
        if [ -n "$PKG_CONFIG" ]; then
            QT_CFLAGS_QGTKSTYLE=`$PKG_CONFIG --cflags gtk+-2.0 ">=" 2.10 atk 2>/dev/null`
            QT_LIBS_QGTKSTYLE=`$PKG_CONFIG --libs gobject-2.0 2>/dev/null`
        fi
        if [ -n "$QT_CFLAGS_QGTKSTYLE" ] ; then
            CFG_QGTKSTYLE=yes
            QMakeVar set QT_CFLAGS_QGTKSTYLE "$QT_CFLAGS_QGTKSTYLE"
            QMakeVar set QT_LIBS_QGTKSTYLE "$QT_LIBS_QGTKSTYLE"
        else
            if [ "$CFG_QGTKSTYLE" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
                echo "Gtk theme support cannot be enabled due to functionality tests!"
                echo " Turn on verbose messaging (-v) to $0 to see the final report."
                echo " If you believe this message is in error you may use the continue"
                echo " switch (-continue) to $0 to continue."
                exit 101
            else
                CFG_QGTKSTYLE=no
            fi
        fi
    elif [ "$CFG_GLIB" = "no" ]; then
        CFG_QGTKSTYLE=no
    fi
fi # X11


if [ "$PLATFORM_MAC" = "yes" ]; then
    if [ "$CFG_PHONON" != "no" ]; then
        # Always enable Phonon (unless it was explicitly disabled)
        CFG_PHONON=yes
    fi

    if [ "$CFG_COREWLAN" = "auto" ]; then
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/mac/corewlan "CoreWlan" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
            CFG_COREWLAN=yes
        else
            CFG_COREWLAN=no
        fi
    fi
fi


if [ "$PLATFORM_QPA" = "yes" ]; then
    # auto-detect OpenGL support (es1 = OpenGL ES 1.x Common, es2 = OpenGL ES 2.x)
    if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengldesktop "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS; then
            CFG_OPENGL=desktop
        elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es2
        elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es1
        else
            if [ "$CFG_OPENGL" = "yes" ]; then
                echo "All the OpenGL functionality tests failed!"
                echo " You might need to modify the include and library search paths by editing"
                echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
                echo " ${XQMAKESPEC}."
                exit 1
            fi
            CFG_OPENGL=no
        fi
    elif [ "$CFG_OPENGL" = "es1" ]; then
        # OpenGL ES 1.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 1.x functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL_ES1, QMAKE_LIBDIR_OPENGL_ES1 and QMAKE_LIBS_OPENGL_ES1 in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    elif [ "$CFG_OPENGL" = "es2" ]; then
        #OpenGL ES 2.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 2.0 functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL_ES2, QMAKE_LIBDIR_OPENGL_ES2 and QMAKE_LIBS_OPENGL_ES2 in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    elif [ "$CFG_OPENGL" = "desktop" ]; then
        # Desktop OpenGL support
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengldesktop "OpenGL" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    fi

    # auto-detect FontConfig support
    if [ "$CFG_FONTCONFIG" != "no" ]; then
        if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists fontconfig --exists freetype2 2>/dev/null; then
            QT_CFLAGS_FONTCONFIG=`$PKG_CONFIG --cflags fontconfig --cflags freetype2 2>/dev/null`
            QT_LIBS_FONTCONFIG=`$PKG_CONFIG --libs fontconfig --libs freetype2 2>/dev/null`
        else
            QT_CFLAGS_FONTCONFIG=
            QT_LIBS_FONTCONFIG="-lfreetype -lfontconfig"
        fi
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/x11/fontconfig "FontConfig" $L_FLAGS $I_FLAGS $l_FLAGS $X11TESTS_FLAGS $QT_CFLAGS_FONTCONFIG $QT_LIBS_FONTCONFIG; then
                QT_CONFIG="$QT_CONFIG fontconfig"
                QMakeVar set QMAKE_CFLAGS_FONTCONFIG "$QT_CFLAGS_FONTCONFIG"
                QMakeVar set QMAKE_LIBS_FONTCONFIG "$QT_LIBS_FONTCONFIG"
                CFG_LIBFREETYPE=system
        fi
    fi

    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/mac/coreservices "CoreServices" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        QT_CONFIG="$QT_CONFIG coreservices"
    else
        QMakeVar add DEFINES QT_NO_CORESERVICES
    fi

fi


# QWS
if [ "$PLATFORM_QWS" = "yes" ]; then

    # auto-detect OpenGL support (es1 = OpenGL ES 1.x Common, es2 = OpenGL ES 2.x)
    if [ "$CFG_GUI" = "no" ]; then
        if [ "$CFG_OPENGL" = "auto" ]; then
            CFG_OPENGL=no
        fi
        if [ "$CFG_OPENGL" != "no" ]; then
            echo "OpenGL enabled, but GUI disabled."
            echo " You might need to either enable the GUI or disable OpenGL"
            exit 1
        fi
    fi
    if [ "$CFG_OPENGL" = "yes" ]; then
        CFG_EGL=auto
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es2
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS; then
            CFG_OPENGL=es1
        else
            echo "All the OpenGL ES functionality tests failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
    elif [ "$CFG_OPENGL" = "es1" ]; then
        # OpenGL ES 1.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles1 "OpenGL ES 1.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 1.x functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
        CFG_EGL=yes
    elif [ "$CFG_OPENGL" = "es2" ]; then
        #OpenGL ES 2.x
        "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/opengles2 "OpenGL ES 2.x" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
            echo "The OpenGL ES 2.0 functionality test failed!"
            echo " You might need to modify the include and library search paths by editing"
            echo " QMAKE_INCDIR_OPENGL, QMAKE_LIBDIR_OPENGL and QMAKE_LIBS_OPENGL in"
            echo " ${XQMAKESPEC}."
            exit 1
        fi
        CFG_EGL=yes
    elif [ "$CFG_OPENGL" = "desktop" ]; then
        # Desktop OpenGL support
        echo "Desktop OpenGL support is not avaliable on Qt for Embedded Linux"
        exit 1
    fi
fi

if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then

    # screen drivers
    for screen in ${CFG_GFX_ON} ${CFG_GFX_PLUGIN}; do
       if [ "${screen}" = "ahi" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
           "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/ahi "Ahi" $L_FLAGS $I_FLAGS $l_FLAGS
           if [ $? != "0" ]; then
               echo "The Ahi screen driver functionality test failed!"
               echo " You might need to modify the include and library search paths by editing"
               echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
               echo " ${XQMAKESPEC}."
               exit 1
           fi
       fi

       if [ "${screen}" = "svgalib" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
           "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/svgalib "SVGAlib" $L_FLAGS $I_FLAGS $l_FLAGS
           if [ $? != "0" ]; then
               echo "The SVGAlib screen driver functionality test failed!"
               echo " You might need to modify the include and library search paths by editing"
               echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
               echo " ${XQMAKESPEC}."
               exit 1
           fi
       fi

       if [ "${screen}" = "directfb" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
           if test -n "$PKG_CONFIG" && "$PKG_CONFIG" --exists directfb 2>/dev/null; then
               QT_CFLAGS_DIRECTFB=`$PKG_CONFIG --cflags directfb 2>/dev/null`
               QT_LIBS_DIRECTFB=`$PKG_CONFIG --libs directfb 2>/dev/null`
           elif directfb-config --version >/dev/null 2>&1; then
               QT_CFLAGS_DIRECTFB=`directfb-config --cflags 2>/dev/null`
               QT_LIBS_DIRECTFB=`directfb-config --libs 2>/dev/null`
           fi

           # QMake variables set here override those in the mkspec. Therefore we only set the variables here if they are not zero.
           if [ -n "$QT_CFLAGS_DIRECTFB" ] || [ -n "$QT_LIBS_DIRECTFB" ]; then
               QMakeVar set QT_CFLAGS_DIRECTFB "$QT_CFLAGS_DIRECTFB"
               QMakeVar set QT_LIBS_DIRECTFB "$QT_LIBS_DIRECTFB"
           fi
           if [ "$CFG_QT3SUPPORT" = "yes" ]; then
               QMakeVar set QT_DEFINES_DIRECTFB "QT3_SUPPORT"
           fi

           "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/directfb "DirectFB" $L_FLAGS $I_FLAGS $l_FLAGS $QT_CFLAGS_DIRECTFB $QT_LIBS_DIRECTFB
           if [ $? != "0" ]; then
               echo "The DirectFB screen driver functionality test failed!"
               echo " You might need to modify the include and library search paths by editing"
               echo " QT_CFLAGS_DIRECTFB and QT_LIBS_DIRECTFB in"
               echo " ${XQMAKESPEC}."
               exit 1
           fi
       fi

    done

    # mouse drivers
    for mouse in ${CFG_MOUSE_ON} ${CFG_MOUSE_PLUGIN}; do
	if [ "${mouse}" = "tslib" ] && [ "${CFG_CONFIGURE_EXIT_ON_ERROR}" = "yes" ]; then
	    "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/tslib "tslib" $L_FLAGS $I_FLAGS $l_FLAGS
            if [ $? != "0" ]; then
               echo "The tslib functionality test failed!"
               echo " You might need to modify the include and library search paths by editing"
               echo " QMAKE_INCDIR and QMAKE_LIBDIR in"
               echo " ${XQMAKESPEC}."
		exit 1
	    fi
	fi
    done

    CFG_QGTKSTYLE=no

    # sound
    "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/qws/sound "sound" $L_FLAGS $I_FLAGS $l_FLAGS
    if [ $? != "0" ]; then
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SOUND"
    fi

fi # QWS

# EGL Support
if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" ]; then
    if [ "$CFG_EGL" != "no" ]; then
        # detect EGL support
        if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/egl" "EGL (EGL/egl.h)" $L_FLAGS $I_FLAGS $l_FLAGS; then
            # EGL specified by QMAKE_*_EGL, included with <EGL/egl.h>
            CFG_EGL=yes
            CFG_EGL_GLES_INCLUDES=no
        elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/egl4gles1" "EGL (GLES/egl.h)" $L_FLAGS $I_FLAGS $l_FLAGS; then
            # EGL specified by QMAKE_*_EGL, included with <GLES/egl.h>
            CFG_EGL=yes
            CFG_EGL_GLES_INCLUDES=yes
        else
            if [ "$CFG_EGL" = "yes" ]; then
                echo "The EGL functionality test failed!"
                echo " EGL is required for OpenGL ES to manage contexts & surfaces."
                echo " You might need to modify the include and library search paths by editing"
                echo " QMAKE_INCDIR_EGL, QMAKE_LIBDIR_EGL and QMAKE_LIBS_EGL in"
                echo " ${XQMAKESPEC}."
                exit 1
            fi
            CFG_EGL=no
            # If QtOpenGL would be built against OpenGL ES, disable it as we can't to that if EGL is missing
            if [ "$CFG_OPENGL" = "es1" -o "$CFG_OPENGL" = "es2" ]; then
                CFG_OPENGL=no
            fi
        fi
    fi
fi

[ "$XPLATFORM_MINGW" = "yes" ] && [ "$CFG_PHONON" != "no" ] && CFG_PHONON="yes"

# freetype support
[ "x$CFG_EMBEDDED" != "xno" ] && CFG_LIBFREETYPE="$CFG_QWS_FREETYPE"
[ "x$PLATFORM_MAC" = "xyes" ] && CFG_LIBFREETYPE=no
[ "$XPLATFORM_MINGW" = "yes" ] && [ "$CFG_LIBFREETYPE" = "auto" ] && CFG_LIBFREETYPE=no
if [ "$CFG_LIBFREETYPE" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/freetype "FreeType" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_LIBFREETYPE=system
    else
        CFG_LIBFREETYPE=yes
    fi
fi

if [ "$CFG_ENDIAN" = "auto" ]; then
    if [ "$XPLATFORM_MINGW" = "yes" ]; then
        CFG_ENDIAN="Q_LITTLE_ENDIAN"
    elif [ "$XPLATFORM_SYMBIAN_SBSV2" = "yes" ]; then
        CFG_ENDIAN="Q_LITTLE_ENDIAN"
    elif [ "$PLATFORM_MAC" = "yes" ] && [ "$XPLATFORM_SYMBIAN" = "no" ]; then
        true #leave as auto
    else
        "$unixtests/endian.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
	F="$?"
        if [ "$F" -eq 0 ]; then
            CFG_ENDIAN="Q_LITTLE_ENDIAN"
        elif [ "$F" -eq 1 ]; then
            CFG_ENDIAN="Q_BIG_ENDIAN"
        else
            echo
	    echo "The target system byte order could not be detected!"
	    echo "Turn on verbose messaging (-v) to see the final report."
	    echo "You can use the -little-endian or -big-endian switch to"
	    echo "$0 to continue."
            exit 101
        fi
    fi
fi

if [ "$CFG_HOST_ENDIAN" = "auto" ]; then
    if [ "$PLATFORM_MAC" = "yes" ]; then
	true #leave as auto
    else
        "$unixtests/endian.test" "$QMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
	F="$?"
        if [ "$F" -eq 0 ]; then
            CFG_HOST_ENDIAN="Q_LITTLE_ENDIAN"
        elif [ "$F" -eq 1 ]; then
            CFG_HOST_ENDIAN="Q_BIG_ENDIAN"
        else
            echo
	    echo "The host system byte order could not be detected!"
	    echo "Turn on verbose messaging (-v) to see the final report."
	    echo "You can use the -host-little-endian or -host-big-endian switch to"
	    echo "$0 to continue."
            exit 101
        fi
    fi
fi

if [ "$CFG_ARMFPA" != "auto" ]; then
    if [ "$CFG_ARMFPA" = "yes" ]; then
        if [ "$CFG_ENDIAN" = "Q_LITTLE_ENDIAN" ]; then
            CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE_SWAPPED"
        else
            CFG_DOUBLEFORMAT="Q_DOUBLE_BIG_SWAPPED"
        fi
    else
        CFG_DOUBLEFORMAT="normal"
    fi
fi


if [ "$CFG_DOUBLEFORMAT" = "auto" ]; then
    if [ "$PLATFORM_QWS" != "yes" -o "$PLATFORM_QPA" = "yes" ]; then
        CFG_DOUBLEFORMAT=normal
    else
        "$unixtests/doubleformat.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
	F="$?"
        if [ "$F" -eq 10 ] && [ "$CFG_ENDIAN" = "Q_LITTLE_ENDIAN" ]; then
            CFG_DOUBLEFORMAT=normal
        elif [ "$F" -eq 11 ] && [ "$CFG_ENDIAN" = "Q_BIG_ENDIAN" ]; then
            CFG_DOUBLEFORMAT=normal
        elif [ "$F" -eq 10 ]; then
            CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE"
        elif [ "$F" -eq 11 ]; then
            CFG_DOUBLEFORMAT="Q_DOUBLE_BIG"
        elif [ "$F" -eq 12 ]; then
            CFG_DOUBLEFORMAT="Q_DOUBLE_LITTLE_SWAPPED"
            CFG_ARMFPA="yes"
        elif [ "$F" -eq 13 ]; then
            CFG_DOUBLEFORMAT="Q_DOUBLE_BIG_SWAPPED"
            CFG_ARMFPA="yes"
        else
            echo
	    echo "The system floating point format could not be detected."
	    echo "This may cause data to be generated in a wrong format"
	    echo "Turn on verbose messaging (-v) to see the final report."
	    # we do not fail on this since this is a new test, and if it fails,
	    # the old behavior should be correct in most cases
            CFG_DOUBLEFORMAT=normal
        fi
    fi
fi

HAVE_STL=no
if [ "$XPLATFORM_SYMBIAN" = "yes" ] || "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/stl "STL" $L_FLAGS $I_FLAGS $l_FLAGS; then
    HAVE_STL=yes
fi

if [ "$CFG_STL" != "no" ]; then
    if [ "$HAVE_STL" = "yes" ]; then
        CFG_STL=yes
    else
        if [ "$CFG_STL" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "STL support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_STL=no
        fi
    fi
fi

# find if the platform supports IPv6
if [ "$CFG_IPV6" != "no" ]; then
    #
    # We accidently enabled IPv6 for Qt Symbian in 4.6.x. However the underlying OpenC does not fully support IPV6.
    # Therefore for 4.7.1 and following we disable it until OpenC either supports it or we have the native Qt
    # symbian socket engine.
    #
    if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        CFG_IPV6=no
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ipv6 "IPv6" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        CFG_IPV6=yes
    else
        if [ "$CFG_IPV6" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "IPv6 support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_IPV6=no
        fi
    fi
fi

# detect POSIX clock_gettime()
if [ "$CFG_CLOCK_GETTIME" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/clock-gettime "POSIX clock_gettime()" $L_FLAGS $I_FLAGS $l_FLAGS; then
	CFG_CLOCK_GETTIME=yes
    else
	CFG_CLOCK_GETTIME=no
    fi
fi

# detect POSIX monotonic clocks
if [ "$CFG_CLOCK_GETTIME" = "yes" ] && [ "$CFG_CLOCK_MONOTONIC" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/clock-monotonic "POSIX Monotonic Clock" $L_FLAGS $I_FLAGS $l_FLAGS; then
	CFG_CLOCK_MONOTONIC=yes
    else
	CFG_CLOCK_MONOTONIC=no
    fi
elif [ "$CFG_CLOCK_GETTIME" = "no" ]; then
    CFG_CLOCK_MONOTONIC=no
fi

# detect mremap
if [ "$CFG_MREMAP" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mremap "mremap" $L_FLAGS $I_FLAGS $l_FLAGS; then
	CFG_MREMAP=yes
    else
	CFG_MREMAP=no
    fi
fi

# find if the platform provides getaddrinfo (ipv6 dns lookups)
if [ "$CFG_GETADDRINFO" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/getaddrinfo "getaddrinfo" $L_FLAGS $I_FLAGS $l_FLAGS; then
        CFG_GETADDRINFO=yes
    else
	if [ "$CFG_GETADDRINFO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "getaddrinfo support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
	else
	    CFG_GETADDRINFO=no
	fi
    fi
fi

# find if the platform provides inotify
if [ "$CFG_INOTIFY" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/inotify "inotify" $L_FLAGS $I_FLAGS $l_FLAGS; then
        CFG_INOTIFY=yes
    else
	if [ "$CFG_INOTIFY" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "inotify support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
	else
	    CFG_INOTIFY=no
	fi
    fi
fi

# find if the platform provides if_nametoindex (ipv6 interface name support)
if [ "$CFG_IPV6IFNAME" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/ipv6ifname "IPv6 interface name" $L_FLAGS $I_FLAGS $l_FLAGS; then
        CFG_IPV6IFNAME=yes
    else
        if [ "$CFG_IPV6IFNAME" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "IPv6 interface name support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
	    CFG_IPV6IFNAME=no
	fi
    fi
fi

# find if the platform provides getifaddrs (network interface enumeration)
if [ "$CFG_GETIFADDRS" != "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/getifaddrs "getifaddrs" $L_FLAGS $I_FLAGS $l_FLAGS; then
        CFG_GETIFADDRS=yes
    else
        if [ "$CFG_GETIFADDRS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "getifaddrs support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
	    CFG_GETIFADDRS=no
	fi
    fi
fi

# detect OpenSSL
if [ "$CFG_OPENSSL" != "no" ] && [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/openssl "OpenSSL" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
        if [ "$CFG_OPENSSL" = "auto" ]; then
            CFG_OPENSSL=yes
        fi
    else
        if ( [ "$CFG_OPENSSL" = "yes" ] || [ "$CFG_OPENSSL" = "linked" ] ) && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "OpenSSL support cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_OPENSSL=no
        fi
    fi
else
    if [ "$CFG_OPENSSL" = "auto" ] && [ "$XPLATFORM_SYMBIAN_SBSV2" = "yes" ]; then
        #OpenSSl should be enabled for Symbian release
        CFG_OPENSSL=yes
    fi
fi

# detect OpenVG support
if [ "$CFG_OPENVG" != "no" ] && [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG openvg_on_opengl" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
        CFG_OPENVG_ON_OPENGL=yes
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG lower_case_includes" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG (lc includes)" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
        CFG_OPENVG_LC_INCLUDES=yes
    elif "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG openvg_on_opengl lower_case_includes" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/openvg" "OpenVG (lc includes)" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
        CFG_OPENVG_LC_INCLUDES=yes
        CFG_OPENVG_ON_OPENGL=yes
    else
        if [ "$CFG_OPENVG" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "$CFG_OPENVG was specified for OpenVG but cannot be enabled due to functionality tests!"
            echo " Turn on verbose messaging (-v) to $0 to see the final report."
            echo " If you believe this message is in error you may use the continue"
            echo " switch (-continue) to $0 to continue."
            exit 101
        else
            CFG_OPENVG=no
        fi
    fi
    if [ "$CFG_OPENVG" = "yes" ] && "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "config.tests/unix/shivavg" "ShivaVG" $L_FLAGS $I_FLAGS $l_FLAGS $CONFIG_ARG; then
        CFG_OPENVG_SHIVA=yes
    fi
fi

# if openvg is disabled and the user specified graphicssystem vg, disable it...
if [ "$CFG_GRAPHICS_SYSTEM" = "openvg" ] && [ "$CFG_OPENVG" = "no" ]; then
    echo "OpenVG Graphics System is disabled due to missing OpenVG support..."
    CFG_GRAPHICS_SYSTEM=default
fi

if [ -n "$CFG_RUNTIME_SYSTEM" -a "$CFG_GRAPHICS_SYSTEM" != "runtime" ] || [ "$CFG_RUNTIME_SYSTEM" = "runtime" ]; then
    echo "Argument to -runtimegraphicssystem is invalid so ignoring..."
    CFG_RUNTIME_SYSTEM=
fi

if [ "$CFG_PTMALLOC" != "no" ]; then
    # build ptmalloc, copy .a file to lib/
    echo "Building ptmalloc. Please wait..."
    (cd "$relpath/src/3rdparty/ptmalloc/"; "$MAKE" "clean" ; "$MAKE" "posix"
     mkdir "$outpath/lib/" ; cp "libptmalloc3.a" "$outpath/lib/")

    QMakeVar add QMAKE_LFLAGS "$outpath/lib/libptmalloc3.a"
fi

if [ "$CFG_ALSA" = "auto" ] && [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/alsa "alsa" $L_FLAGS $I_FLAGS $l_FLAGS; then
        CFG_ALSA=yes
    else
        CFG_ALSA=no
    fi
elif [ "$XPLATFORM_SYMBIAN_SBSV2" = "yes" ]; then
    # Disabled for Symbian release
    CFG_ALSA=no
fi

if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ] || [ "$CFG_JAVASCRIPTCORE_JIT" = "auto" ]; then 
    if [ "$CFG_ARCH" = "arm" ]; then
       "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/javascriptcore-jit "javascriptcore-jit" $L_FLAGS $I_FLAGS $l_FLAGS
        if [ $? != "0" ]; then
           CFG_JAVASCRIPTCORE_JIT=no
        fi
    fi
fi

if [ "$CFG_JAVASCRIPTCORE_JIT" = "yes" ]; then
    QMakeVar set JAVASCRIPTCORE_JIT yes
elif [ "$CFG_JAVASCRIPTCORE_JIT" = "no" ]; then
    QMakeVar set JAVASCRIPTCORE_JIT no
fi

if [ "$CFG_AUDIO_BACKEND" = "auto" ]; then
    if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
         if "$symbiantests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/symbian/audio "audio" $L_FLAGS $I_FLAGS $l_FLAGS ; then
            CFG_AUDIO_BACKEND=yes
         fi
    else
        CFG_AUDIO_BACKEND=yes
    fi
fi

if [ "$CFG_LARGEFILE" != "yes" ] && [ "$XPLATFORM_MINGW" = "yes" ]; then
    echo "Warning: largefile support cannot be disabled for win32."
    CFG_LARGEFILE="yes"
elif [ "$CFG_LARGEFILE" != "no" ] && [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    echo "Warning: largefile support cannot be enabled for symbian."
    CFG_LARGEFILE="no"
fi

#-------------------------------------------------------------------------------
# ask for all that hasn't been auto-detected or specified in the arguments
#-------------------------------------------------------------------------------

### fix this: user input should be validated in a loop
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    PROMPT_FOR_DEPTHS="yes"
else
    PROMPT_FOR_DEPTHS="no"
fi
if [ "$CFG_QWS_DEPTHS" = "prompted" -a "$PROMPT_FOR_DEPTHS" = "yes" ]; then
    echo
    echo "Choose pixel-depths to support:"
    echo
    echo "   1. 1bpp, black/white"
    echo "   4. 4bpp, grayscale"
    echo "   8. 8bpp, paletted"
    echo "  12. 12bpp, rgb 4-4-4"
    echo "  15. 15bpp, rgb 5-5-5"
    echo "  16. 16bpp, rgb 5-6-5"
    echo "  18. 18bpp, rgb 6-6-6"
    echo "  24. 24bpp, rgb 8-8-8"
    echo "  32. 32bpp, argb 8-8-8-8 and rgb 8-8-8"
    echo " all. All supported depths"
    echo
    echo "Your choices (default 8,16,32):"
    read CFG_QWS_DEPTHS
    if [ -z "$CFG_QWS_DEPTHS" ] || [ "$CFG_QWS_DEPTHS" = "yes" ]; then
        CFG_QWS_DEPTHS=8,16,32
    fi
fi
if [ -n "$CFG_QWS_DEPTHS" -a "$PLATFORM_QWS" = "yes" ]; then
    if [ "$CFG_QWS_DEPTHS" = "all" ]; then
        CFG_QWS_DEPTHS="1 4 8 12 15 16 18 24 32 generic"
    fi
    for D in `echo "$CFG_QWS_DEPTHS" | sed -e 's/,/ /g'`; do
	case $D in
	    1|4|8|12|15|16|18|24|32) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_$D";;
	    generic) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_GENERIC";;
	esac
    done
fi

# enable dwarf2 support on Mac
if [ "$CFG_MAC_DWARF2" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG dwarf2"
fi

# Set the default arch if there are no "-arch" arguments on the configure line
# For "-carbon" builds: 32 bit x86/ppc.
# For builds on snow leopard : compiler default (64-bit).
# For builds on leopard : compiler default (32-bit).
if [ "$PLATFORM_MAC" = "yes" ]  && [ "$CFG_MAC_ARCHS" = "" ]; then
    source "$mactests/defaultarch.test" "$TEST_COMPILER" "$OPT_VERBOSE" "$mactests"

	if [ "$CFG_MAC_CARBON" = "yes" ]; then
		if [ "$QT_MAC_DEFAULT_ARCH" = "x86_64" ]; then
			CFG_MAC_ARCHS=" x86"
		elif [ "$QT_MAC_DEFAULT_ARCH" = "ppc64" ]; then
			CFG_MAC_ARCHS=" ppc"
		else
			CFG_MAC_ARCHS=" $QT_MAC_DEFAULT_ARCH"
		fi
	else
		CFG_MAC_ARCHS=" $QT_MAC_DEFAULT_ARCH"
    fi

    [ "$OPT_VERBOSE" = "yes" ] && echo "Setting Mac architechture to$CFG_MAC_ARCHS."
fi

# enable Cocoa and/or Carbon on Mac
#  -carbon on the command line disables Cocoa, except for 64-bit archs
if [ "$CFG_MAC_CARBON" = "yes" ]; then
    CFG_MAC_CARBON="YES"
    CFG_MAC_COCOA="NO"

#    check which archs are in use, enable cocoa if we find a 64-bit one
    if echo "$CFG_MAC_ARCHS" | grep 64 > /dev/null 2>&1; then
        CFG_MAC_COCOA="yes";
        CFG_MAC_CARBON="no";
        if echo "$CFG_MAC_ARCHS" | grep -w ppc > /dev/null 2>&1; then
            CFG_MAC_CARBON="yes";
        fi
        if echo "$CFG_MAC_ARCHS" | grep -w x86 > /dev/null 2>&1; then
            CFG_MAC_CARBON="yes";
        fi
    fi
fi

# select Carbon on 10.4 Tiger.
if [ "$PLATFORM_MAC" = "yes" ]; then
    VERSION=`uname -r | tr '.' ' ' | awk '{print $1}'`
    if [ "$VERSION" == 8 ]; then
        CFG_MAC_COCOA="no";
        CFG_MAC_CARBON="yes";
    fi
fi

# select Carbon when using the 10.4u SDK
if [ "$PLATFORM_MAC" = "yes" ]; then
    if [ "TEST$CFG_SDK" = "TEST/Developer/SDKs/MacOSX10.4u.sdk/" ]; then
        echo "Carbon on";
        CFG_MAC_COCOA="no";
        CFG_MAC_CARBON="yes";
    fi
fi

# but disable Cocoa if cross-building for mingw and symbian
[ "$XPLATFORM_MINGW" = "yes" ] && CFG_MAC_COCOA="no"
[ "$XPLATFORM_SYMBIAN" = "yes" ] && CFG_MAC_COCOA="no"

# set the global Mac deployment target. This is overridden on an arch-by-arch basis
# in some cases, see code further down
case "$PLATFORM,$CFG_MAC_COCOA" in
    macx*,yes)
	# Cocoa
	QMakeVar set QMAKE_MACOSX_DEPLOYMENT_TARGET 10.5
	;;
    macx*,no)
	# gcc, Carbon
	QMakeVar set QMAKE_MACOSX_DEPLOYMENT_TARGET 10.4
	;;
esac

# disable Qt 3 support on VxWorks and Symbian
case "$XPLATFORM" in
    unsupported/vxworks*|symbian*)
	CFG_QT3SUPPORT="no"
    ;;
esac

# enable Qt 3 support functionality
if [ "$CFG_QT3SUPPORT" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG qt3support"
fi

# enable Phonon
if [ "$CFG_PHONON" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG phonon"
    if [ "$CFG_PHONON_BACKEND" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG phonon-backend"
    fi
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_PHONON"
fi

# disable accessibility
if [ "$CFG_ACCESSIBILITY" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ACCESSIBILITY"
else
    QT_CONFIG="$QT_CONFIG accessibility"
fi

# egl stuff does not belong in lighthouse, but rather in plugins
if [ "$PLATFORM_QPA" = "yes" ]; then
    CFG_EGL="no"
fi

# enable egl
if [ "$CFG_EGL" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGL"
else
    QT_CONFIG="$QT_CONFIG egl"
    if [ "$CFG_EGL_GLES_INCLUDES" = "yes" ]; then
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GLES_EGL"
    fi
fi

# enable openvg
if [ "$CFG_OPENVG" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENVG"
else
    QT_CONFIG="$QT_CONFIG openvg"
    if [ "$CFG_OPENVG_LC_INCLUDES" = "yes" ]; then
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LOWER_CASE_VG_INCLUDES"
    fi
    if [ "$CFG_OPENVG_ON_OPENGL" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG openvg_on_opengl"
    fi
    if [ "$CFG_OPENVG_SHIVA" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG shivavg"
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SHIVAVG"
    fi
fi

if [ "$CFG_QS60STYLE" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_S60"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_STYLE_S60"
fi

# Just check if OpenGL is not set by command argumets for Symbian.
if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
        if [ "$CFG_OPENGL" = "auto" ]; then
            CFG_OPENGL="no"
        fi
fi

# enable opengl
if [ "$CFG_OPENGL" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENGL"
else
    QT_CONFIG="$QT_CONFIG opengl"
fi

if [ "$CFG_OPENGL" = "es1" ] || [ "$CFG_OPENGL" = "es2" ]; then
    if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
	if [ "$PLATFORM_QWS" = "yes" ]; then
	    QCONFIG_FLAGS="$QCONFIG_FLAGS Q_BACKINGSTORE_SUBSURFACES"
	else
	    echo "### Q_BACKINGSTORE_SUBSURFACES disabled, re-enable once it compiles again"
	fi
	QCONFIG_FLAGS="$QCONFIG_FLAGS Q_USE_EGLWINDOWSURFACE"
    fi
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES"
fi

if [ "$CFG_OPENGL" = "es1" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_1"
    QT_CONFIG="$QT_CONFIG opengles1"
fi

if [ "$CFG_OPENGL" = "es2" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_2"
    QT_CONFIG="$QT_CONFIG opengles2"
fi

# safe execution environment
if [ "$CFG_SXE" != "no" ]; then
    QT_CONFIG="$QT_CONFIG sxe"
fi

# build up the variables for output
if [ "$CFG_DEBUG" = "yes" ]; then
    QMAKE_OUTDIR="${QMAKE_OUTDIR}debug"
    QMAKE_CONFIG="$QMAKE_CONFIG debug"
elif [ "$CFG_DEBUG" = "no" ]; then
    QMAKE_OUTDIR="${QMAKE_OUTDIR}release"
    QMAKE_CONFIG="$QMAKE_CONFIG release"
fi
if [ "$CFG_SHARED" = "yes" ]; then
    QMAKE_OUTDIR="${QMAKE_OUTDIR}-shared"
    QMAKE_CONFIG="$QMAKE_CONFIG shared dll"
elif [ "$CFG_SHARED" = "no" ]; then
    QMAKE_OUTDIR="${QMAKE_OUTDIR}-static"
    QMAKE_CONFIG="$QMAKE_CONFIG static"
fi
if [ "$PLATFORM_QWS" = "yes" ]; then
    QMAKE_OUTDIR="${QMAKE_OUTDIR}-emb-$CFG_EMBEDDED"
    QMAKE_CONFIG="$QMAKE_CONFIG embedded"
    QT_CONFIG="$QT_CONFIG embedded"
    rm -f "src/.moc/$QMAKE_OUTDIR/allmoc.cpp" # needs remaking if config changes
fi
if [ "$PLATFORM_QPA" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG qpa"
    QT_CONFIG="$QT_CONFIG qpa"
    rm -f "src/.moc/$QMAKE_OUTDIR/allmoc.cpp" # needs remaking if config changes
fi

if [ "$CFG_EMBEDDED" = "nacl" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG nacl pepper"
    QT_CONFIG="$QT_CONFIG nacl pepper"
    rm -f "src/.moc/$QMAKE_OUTDIR/allmoc.cpp" # needs remaking if config changes
fi

if [ "$XPLATFORM_MINGW" != "yes" ]; then
    # Do not set this here for Windows. Let qmake do it so
    # debug and release precompiled headers are kept separate.
    QMakeVar set PRECOMPILED_DIR ".pch/$QMAKE_OUTDIR"
fi
QMakeVar set OBJECTS_DIR ".obj/$QMAKE_OUTDIR"
QMakeVar set MOC_DIR ".moc/$QMAKE_OUTDIR"
QMakeVar set RCC_DIR ".rcc/$QMAKE_OUTDIR"
QMakeVar set UI_DIR ".uic/$QMAKE_OUTDIR"
if [ "$CFG_LARGEFILE" = "yes" ] && [ "$XPLATFORM_MINGW" != "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG largefile"
fi
if [ "$CFG_STL" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STL"
else
    QMAKE_CONFIG="$QMAKE_CONFIG stl"
fi
if [ "$CFG_USE_GNUMAKE" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG GNUmake"
fi
[ "$CFG_REDUCE_EXPORTS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_exports"
[ "$CFG_REDUCE_RELOCATIONS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_relocations"
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
    QMakeVar add QMAKE_CFLAGS -g
    QMakeVar add QMAKE_CXXFLAGS -g
    QMAKE_CONFIG="$QMAKE_CONFIG separate_debug_info"
fi
if [ "$CFG_SEPARATE_DEBUG_INFO_NOCOPY" = "yes" ] ; then
    QMAKE_CONFIG="$QMAKE_CONFIG separate_debug_info_nocopy"
fi
[ "$CFG_MMX" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG mmx"
[ "$CFG_3DNOW" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG 3dnow"
[ "$CFG_SSE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse"
[ "$CFG_SSE2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse2"
[ "$CFG_SSE3" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse3"
[ "$CFG_SSSE3" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG ssse3"
[ "$CFG_SSE4_1" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse4_1"
[ "$CFG_SSE4_2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse4_2"
[ "$CFG_AVX" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG avx"
[ "$CFG_IWMMXT" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG iwmmxt"
[ "$CFG_NEON" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG neon"
[ "$PLATFORM_MAC" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG $CFG_MAC_ARCHS"
if [ "$CFG_IPV6" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG ipv6"
fi
if [ "$CFG_CLOCK_GETTIME" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG clock-gettime"
fi
if [ "$CFG_CLOCK_MONOTONIC" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG clock-monotonic"
fi
if [ "$CFG_MREMAP" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG mremap"
fi
if [ "$CFG_GETADDRINFO" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG getaddrinfo"
fi
if [ "$CFG_IPV6IFNAME" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG ipv6ifname"
fi
if [ "$CFG_GETIFADDRS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG getifaddrs"
fi
if [ "$CFG_INOTIFY" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG inotify"
fi
if [ "$CFG_LIBJPEG" = "no" ]; then
    CFG_JPEG="no"
elif [ "$CFG_LIBJPEG" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-jpeg"
fi
if [ "$CFG_JPEG" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-jpeg"
elif [ "$CFG_JPEG" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG jpeg"
fi
if [ "$CFG_LIBMNG" = "no" ]; then
    CFG_MNG="no"
elif [ "$CFG_LIBMNG" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-mng"
fi
if [ "$CFG_MNG" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-mng"
elif [ "$CFG_MNG" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG mng"
fi
if [ "$CFG_LIBPNG" = "no" ]; then
    CFG_PNG="no"
fi
if [ "$CFG_LIBPNG" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-png"
fi
if [ "$CFG_PNG" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-png"
elif [ "$CFG_PNG" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG png"
fi
if [ "$CFG_GIF" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-gif"
elif [ "$CFG_GIF" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG gif"
fi
if [ "$CFG_LIBTIFF" = "no" ]; then
    CFG_TIFF="no"
elif [ "$CFG_LIBTIFF" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-tiff"
fi
if [ "$CFG_TIFF" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-tiff"
elif [ "$CFG_TIFF" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG tiff"
fi
if [ "$CFG_LIBFREETYPE" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-freetype"
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
elif [ "$CFG_LIBFREETYPE" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-freetype"
else
    QT_CONFIG="$QT_CONFIG freetype"
fi
if [ "$CFG_GUI" = "auto" ]; then
    CFG_GUI="yes"
fi
if [ "$CFG_GUI" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-gui"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GUI"
fi


if [ "x$PLATFORM_MAC" = "xyes" ] && [ "$XPLATFORM_MINGW" != "yes" ] && [ "$XPLATFORM_SYMBIAN" != "yes" ]; then
    #On Mac we implicitly link against libz, so we
    #never use the 3rdparty stuff.
    [ "$CFG_ZLIB" = "yes" ] && CFG_ZLIB="system"
fi
if [ "$CFG_ZLIB" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG zlib"
elif [ "$CFG_ZLIB" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-zlib"
fi

if [ "$CFG_S60" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG s60"
fi

if [ "$CFG_SYMBIAN_DEFFILES" = "yes" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG def_files"
else
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG def_files_disabled"
fi

[ "$CFG_NIS" = "yes" ] && QT_CONFIG="$QT_CONFIG nis"
[ "$CFG_CUPS" = "yes" ] && QT_CONFIG="$QT_CONFIG cups"
[ "$CFG_ICONV" = "yes" ] && QT_CONFIG="$QT_CONFIG iconv"
[ "$CFG_ICONV" = "sun" ] && QT_CONFIG="$QT_CONFIG sun-libiconv"
[ "$CFG_ICONV" = "gnu" ] && QT_CONFIG="$QT_CONFIG gnu-libiconv"
[ "$CFG_GLIB" = "yes" ] && QT_CONFIG="$QT_CONFIG glib"
[ "$CFG_GSTREAMER" = "yes" ] && QT_CONFIG="$QT_CONFIG gstreamer"
[ "$CFG_DBUS" = "yes" ] && QT_CONFIG="$QT_CONFIG dbus"
[ "$CFG_DBUS" = "linked" ] && QT_CONFIG="$QT_CONFIG dbus dbus-linked"
[ "$CFG_NAS" = "system" ] && QT_CONFIG="$QT_CONFIG nas"
[ "$CFG_OPENSSL" = "yes" ] && QT_CONFIG="$QT_CONFIG openssl"
[ "$CFG_OPENSSL" = "linked" ] && QT_CONFIG="$QT_CONFIG openssl-linked"

if [ "$PLATFORM_X11" = "yes" ]; then
    [ "$CFG_SM" = "yes" ] && QT_CONFIG="$QT_CONFIG x11sm"

    # for some reason, the following libraries are not always built shared,
    # so *every* program/lib (including Qt) has to link against them
    if [ "$CFG_XSHAPE" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xshape"
    fi
    if [ "$CFG_XVIDEO" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xvideo"
    fi
    if [ "$CFG_XSYNC" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xsync"
    fi
    if [ "$CFG_XINERAMA" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xinerama"
	QMakeVar set QMAKE_LIBS_X11 '-lXinerama $$QMAKE_LIBS_X11'
    fi
    if [ "$CFG_XCURSOR" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xcursor"
	QMakeVar set QMAKE_LIBS_X11 '-lXcursor $$QMAKE_LIBS_X11'
    fi
    if [ "$CFG_XFIXES" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xfixes"
	QMakeVar set QMAKE_LIBS_X11 '-lXfixes $$QMAKE_LIBS_X11'
    fi
    if [ "$CFG_XRANDR" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xrandr"
        if [ "$CFG_XRENDER" != "yes" ]; then
            # libXrandr uses 1 function from libXrender, so we always have to have it :/
	    QMakeVar set QMAKE_LIBS_X11 '-lXrandr -lXrender $$QMAKE_LIBS_X11'
        else
	    QMakeVar set QMAKE_LIBS_X11 '-lXrandr $$QMAKE_LIBS_X11'
        fi
    fi
    if [ "$CFG_XRENDER" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xrender"
	QMakeVar set QMAKE_LIBS_X11 '-lXrender $$QMAKE_LIBS_X11'
    fi
    if [ "$CFG_MITSHM" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG mitshm"
    fi
    if [ "$CFG_FONTCONFIG" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG fontconfig"
    fi
    if [ "$CFG_XINPUT" = "yes" ]; then
	QMakeVar set QMAKE_LIBS_X11 '-lXi $$QMAKE_LIBS_X11'
    fi
    if [ "$CFG_XINPUT" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xinput tablet"
    fi
    if [ "$CFG_XKB" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG xkb"
    fi
fi

[ '!' -z "$D_FLAGS" ] && QMakeVar add DEFINES "$D_FLAGS"
[ '!' -z "$L_FLAGS" ] && QMakeVar add QMAKE_LIBDIR_FLAGS "$L_FLAGS"
[ '!' -z "$l_FLAGS" ] && QMakeVar add LIBS "$l_FLAGS"

if [ "$PLATFORM_MAC" = "yes" ]; then
    if [ "$CFG_RPATH" = "yes" ]; then
       QMAKE_CONFIG="$QMAKE_CONFIG absolute_library_soname"
    fi
elif [ -z "`getQMakeConf \"$XQMAKESPEC\" | $AWK '/QMAKE_(LFLAGS_)?RPATH/ {print $3;}'`" ]; then
    if [ -n "$RPATH_FLAGS" ]; then
        echo
        echo "ERROR: -R cannot be used on this platform as \$QMAKE_LFLAGS_RPATH is"
        echo "       undefined."
        echo
        exit 1
    elif [ "$CFG_RPATH" = "yes" ]; then
        RPATH_MESSAGE="        NOTE: This platform does not support runtime library paths, using -no-rpath."
        CFG_RPATH=no
    fi
else
    if [ "$CFG_RPATH" = "yes" ]; then
        # set the default rpath to the library installation directory
        RPATH_FLAGS="\"$QT_INSTALL_LIBS\" $RPATH_FLAGS"
    fi
    if [ -n "$RPATH_FLAGS" ]; then
        # add the user defined rpaths
	QMakeVar add QMAKE_RPATHDIR "$RPATH_FLAGS"
    fi
fi

if [ '!' -z "$I_FLAGS" ]; then
    # add the user define include paths
    QMakeVar add QMAKE_CFLAGS "$I_FLAGS"
    QMakeVar add QMAKE_CXXFLAGS "$I_FLAGS"
fi

# turn off exceptions for the compilers that support it
if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    COMPILER=`echo $XPLATFORM | cut -f 3- -d-`
elif [ "$XPLATFORM" != "$PLATFORM" ]; then
    COMPILER=`echo $XPLATFORM | cut -f 2- -d-`
else
    COMPILER=`echo $PLATFORM | cut -f 2- -d-`
fi
if [ "$CFG_EXCEPTIONS" = "unspecified" -a "$PLATFORM_QWS" = "yes" ]; then
    CFG_EXCEPTIONS=no
fi

if [ "$CFG_EXCEPTIONS" != "no" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG exceptions"
fi

if [ "$XPLATFORM_MINGW" = "yes" ]; then
    # mkspecs/features/win32/default_pre.prf sets "no-rtti".
    # Follow default behavior of configure.exe by overriding with "rtti".
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG rtti"
fi

if [ "$CFG_ALSA" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG alsa"
fi

if [ "$CFG_PULSEAUDIO" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG pulseaudio"
fi

if [ "$CFG_COREWLAN" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG corewlan"
fi

if [ "$CFG_ICD" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG icd"
fi

#
# Some Qt modules are too advanced in C++ for some old compilers
# Detect here the platforms where they are known to work.
#
# See Qt documentation for more information on which features are
# supported and on which compilers.
#
canBuildQtXmlPatterns="yes"
canBuildWebKit="$HAVE_STL"
canBuildQtConcurrent="yes"

# WebKit requires stdint.h
"$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/stdint "Stdint" $L_FLAGS $I_FLAGS $l_FLAGS
if [ $? != "0" ]; then
    canBuildWebKit="no"
fi

case "$XPLATFORM" in
    hpux-g++*)
	# PA-RISC's assembly is too limited
	# gcc 3.4 on that platform can't build QtXmlPatterns
	# the assembly it generates cannot be compiled

	# Check gcc's version
	case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
	    4*)
		;;
	    3.4*)
		canBuildQtXmlPatterns="no"
		;;
	    *)
		canBuildWebKit="no"
		canBuildQtXmlPatterns="no"
		;;
	esac
	;;
    unsupported/vxworks-*-g++*)
	canBuildWebKit="no"
	;;
    unsupported/vxworks-*-dcc*)
	canBuildWebKit="no"
	canBuildQtXmlPatterns="no"
	;;
    *-g++*)
	# Check gcc's version
	case "$(${QMAKE_CONF_COMPILER} -dumpversion)" in
	    4*|3.4*)
		;;
            3.3*)
                canBuildWebKit="no"
                ;;
	    *)
		canBuildWebKit="no"
		canBuildQtXmlPatterns="no"
		;;
	esac
	;;
    solaris-cc*)
        # Check the compiler version
        case `${QMAKE_CONF_COMPILER} -V 2>&1 | awk '{print $4}'` in
            5.[012345678])
                canBuildWebKit="no"
                canBuildQtXmlPatterns="no"
                canBuildQtConcurrent="no"
                ;;
            5.*)
                canBuildWebKit="no"
                canBuildQtConcurrent="no"
                ;;
        esac
        ;;
    hpux-acc*)
	canBuildWebKit="no"
	canBuildQtXmlPatterns="no"
        canBuildQtConcurrent="no"
	;;
    hpuxi-acc*)
	canBuildWebKit="no"
	;;
    aix-xlc*)
        # Get the xlC version
        cat > xlcver.c <<EOF
#include <stdio.h>
int main()
{
    printf("%d.%d\n", __xlC__ >> 8, __xlC__ & 0xFF);
    return 0;
}
EOF
        xlcver=
        if ${QMAKE_CONF_COMPILER} -o xlcver xlcver.c >/dev/null 2>/dev/null; then
            xlcver=`./xlcver 2>/dev/null`
            rm -f ./xlcver
        fi
        if [ "$OPT_VERBOSE" = "yes" ]; then
            if [ -n "$xlcver" ]; then
                echo Found IBM xlC version: $xlcver.
            else
                echo Could not determine IBM xlC version, assuming oldest supported.
            fi
        fi

        case "$xlcver" in
            [123456].*)
                canBuildWebKit="no"
                canBuildQtXmlPatterns="no"
                canBuildQtConcurrent="no"
                ;;
            *)
                canBuildWebKit="no"
                canBuildQtConcurrent="no"
                ;;
        esac
        ;;
    irix-cc*)
        canBuildWebKit="no"
        canBuildQtConcurrent="no"
	;;
    symbian/*-gcce)
        canBuildWebKit="no"
        canBuildQtConcurrent="no"
        ;;
    symbian/*-armcc)
        canBuildQtConcurrent="no"
        ;;
esac

if [ "$CFG_GUI" = "no" ]; then
    # WebKit requires QtGui
    canBuildWebKit="no"
fi

if [ "$CFG_SHARED" = "no" ]; then
    echo
    echo "WARNING: Using static linking will disable the WebKit module."
    echo
    canBuildWebKit="no"
fi

CFG_CONCURRENT="yes"
if [ "$canBuildQtConcurrent" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT"
    CFG_CONCURRENT="no"
fi

if [ "$CFG_XMLPATTERNS" = "yes" -a "$CFG_EXCEPTIONS" = "no" ]; then
    echo "QtXmlPatterns was requested, but it can't be built due to exceptions being disabled."
    exit 1
fi
if [ "$CFG_XMLPATTERNS" = "auto" -a "$CFG_EXCEPTIONS" != "no" ]; then
    CFG_XMLPATTERNS="$canBuildQtXmlPatterns"
elif [ "$CFG_EXCEPTIONS" = "no" ]; then
    CFG_XMLPATTERNS="no"
fi
if [ "$CFG_XMLPATTERNS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG xmlpatterns"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XMLPATTERNS"
fi

if [ "$CFG_MULTIMEDIA" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MULTIMEDIA"
else
    QT_CONFIG="$QT_CONFIG multimedia"
fi

if [ "$CFG_AUDIO_BACKEND" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG audio-backend"
fi

if [ "$CFG_SVG" = "auto" ]; then
    CFG_SVG=$CFG_GUI
fi

if [ "$CFG_SVG" = "yes" ] && [ "$CFG_GUI" = "no" ]; then
    echo "QtSvg requested, but it can't be built without QtGui"
    exit 1
fi

if [ "$CFG_SVG" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG svg"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SVG"
fi

if [ "$CFG_WEBKIT" = "auto" ]; then
    CFG_WEBKIT="$canBuildWebKit"
fi

if [ "$CFG_WEBKIT" != "no" ]; then
    # This include takes care of adding "webkit" to QT_CONFIG.
    cp -f "$relpath/src/3rdparty/webkit/WebKit/qt/qt_webkit_version.pri" "$outpath/mkspecs/modules/qt_webkit_version.pri"
    # The reason we set CFG_WEBKIT, is such that the printed overview of what will be enabled, shows correctly.
    if [ "$CFG_WEBKIT" = "debug" ]; then
        QMAKE_CONFIG="$QMAKE_CONFIG webkit-debug"
    fi
else
    rm -f "$outpath/mkspecs/modules/qt_webkit_version.pri"
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_WEBKIT"
fi

if [ "$CFG_SCRIPT" = "auto" ]; then
    CFG_SCRIPT="yes"
fi

if [ "$CFG_SCRIPT" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG script"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SCRIPT"
fi

if [ "$CFG_SCRIPTTOOLS" = "yes" -a "$CFG_SCRIPT" = "no" ]; then
    echo "QtScriptTools was requested, but it can't be built due to QtScript being disabled."
    exit 1
fi
if [ "$CFG_SCRIPTTOOLS" = "auto" -a "$CFG_SCRIPT" != "no" ]; then
    case "$XPLATFORM" in
    symbian*)
        CFG_SCRIPTTOOLS="no"
        ;;
    *)
        CFG_SCRIPTTOOLS="yes"
        ;;
    esac
elif [ "$CFG_SCRIPT" = "no" ]; then
    CFG_SCRIPTTOOLS="no"
fi

if [ "$CFG_SCRIPTTOOLS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG scripttools"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SCRIPTTOOLS"
fi


if [ "$CFG_DECLARATIVE" = "yes" ]; then
    if [ "$CFG_SCRIPT" = "no" -o "$CFG_GUI" = "no" ]; then
        echo "Error: QtDeclarative was requested, but it can't be built due to QtScript or QtGui being disabled."
        exit 1
    fi
fi
if [ "$CFG_DECLARATIVE" = "auto" ]; then
    if [ "$CFG_SCRIPT" = "no" -o "$CFG_GUI" = "no" ]; then
            CFG_DECLARATIVE=no
    else
            CFG_DECLARATIVE=yes
    fi
fi

if [ "$CFG_DECLARATIVE" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG declarative"
    if [ "$CFG_DECLARATIVE_DEBUG" = "no" ]; then
        QCONFIG_FLAGS="$QCONFIG_FLAGS QDECLARATIVE_NO_DEBUG_PROTOCOL"
    fi
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DECLARATIVE"
fi

if [ "$CFG_EXCEPTIONS" = "no" ]; then
    case "$COMPILER" in
    g++*)
	QMakeVar add QMAKE_CFLAGS -fno-exceptions
	QMakeVar add QMAKE_CXXFLAGS -fno-exceptions
	QMakeVar add QMAKE_LFLAGS -fno-exceptions
        ;;
    cc*)
        case "$PLATFORM" in
        irix-cc*)
	    QMakeVar add QMAKE_CFLAGS -LANG:exceptions=off
	    QMakeVar add QMAKE_CXXFLAGS -LANG:exceptions=off
	    QMakeVar add QMAKE_LFLAGS -LANG:exceptions=off
            ;;
        *) ;;
        esac
        ;;
    *) ;;
    esac
    QMAKE_CONFIG="$QMAKE_CONFIG exceptions_off"
fi

# On Mac, set the minimum deployment target for the different architechtures 
# using the Xarch compiler option when supported (10.5 and up).  On 10.4 the
# deployment version is set to 10.4 globally using the QMAKE_MACOSX_DEPLOYMENT_TARGET
# env. variable. 
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_XARCH" != "no" ] ; then
    if echo "$CFG_MAC_ARCHS" | grep '\<x86\>' > /dev/null 2>&1; then
        QMakeVar add QMAKE_CFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_CXXFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_LFLAGS "-Xarch_i386 -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_OBJECTIVE_CFLAGS_X86 "-arch i386 -Xarch_i386 -mmacosx-version-min=10.4"
    fi
    if echo "$CFG_MAC_ARCHS" | grep '\<ppc\>' > /dev/null 2>&1; then
        QMakeVar add QMAKE_CFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_CXXFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_LFLAGS "-Xarch_ppc -mmacosx-version-min=10.4"
        QMakeVar add QMAKE_OBJECTIVE_CFLAGS_PPC "-arch ppc -Xarch_ppc -mmacosx-version-min=10.4"
    fi
    if echo "$CFG_MAC_ARCHS" | grep '\<x86_64\>' > /dev/null 2>&1; then
        QMakeVar add QMAKE_CFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_CXXFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_LFLAGS "-Xarch_x86_64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_OBJECTIVE_CFLAGS_X86_64 "-arch x86_64 -Xarch_x86_64 -mmacosx-version-min=10.5"
    fi
    if echo "$CFG_MAC_ARCHS" | grep '\<ppc64\>' > /dev/null 2>&1; then
        QMakeVar add QMAKE_CFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_CXXFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_LFLAGS "-Xarch_ppc64 -mmacosx-version-min=10.5"
        QMakeVar add QMAKE_OBJECTIVE_CFLAGS_PPC_64 "-arch ppc64 -Xarch_ppc64 -mmacosx-version-min=10.5"
    fi
fi

#-------------------------------------------------------------------------------
# generate QT_BUILD_KEY
#-------------------------------------------------------------------------------

# some compilers generate binary incompatible code between different versions,
# so we need to generate a build key that is different between these compilers
COMPAT_COMPILER=
case "$COMPILER" in
g++*)
    # GNU C++
    COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -dumpversion 2>/dev/null`

    case "$COMPILER_VERSION" in
    *.*.*)
        QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
        QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
        QT_GCC_PATCH_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
        ;;
    *.*)
        QT_GCC_MAJOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\1,'`
        QT_GCC_MINOR_VERSION=`echo $COMPILER_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\).*,\2,'`
        QT_GCC_PATCH_VERSION=0
        ;;
    esac

    case "$COMPILER_VERSION" in
    2.95.*)
        COMPILER_VERSION="2.95.*"
        ;;
    3.*)
        COMPILER_VERSION="3.*"
        ;;
    4.*)
        COMPILER_VERSION="4"
        ;;
    *)
        ;;
    esac
    [ '!' -z "$COMPILER_VERSION" ] && COMPILER="g++-${COMPILER_VERSION}"
    ;;
icc*)
    # The Intel CC compiler on Unix systems matches the ABI of the g++
    # that is found on PATH
    COMPAT_COMPILER="icc"
    COMPILER="g++-4"
    case "`g++ -dumpversion` 2>/dev/null" in
    2.95.*)
        COMPILER="g++-2.95.*"
        ;;
    3.*)
a        COMPILER="g++-3.*"
        ;;
    *)
        ;;
    esac
    ;;
*)
    #
    ;;
esac

# QT_CONFIG can contain the following:
#
# Things that affect the Qt API/ABI:
#
#   Options:
#     minimal-config small-config medium-config large-config full-config
#
#   Different edition modules:
#     gui network canvas table xml opengl sql
#
# Things that do not affect the Qt API/ABI:
#     stl
#     system-jpeg no-jpeg jpeg
#     system-mng no-mng mng
#     system-png no-png png
#     system-zlib no-zlib zlib
#     system-libtiff no-libtiff
#     no-gif gif
#     debug release
#     dll staticlib
#
#     nocrosscompiler
#     GNUmake
#     largefile
#     nis
#     nas
#     tablet
#     ipv6
#
#     X11     : x11sm xinerama xcursor xfixes xrandr xrender mitshm fontconfig xkb
#     Embedded: embedded qpa freetype
#
ALL_OPTIONS=
BUILD_CONFIG=
BUILD_OPTIONS=

# determine the build options
for config_option in $QMAKE_CONFIG $QT_CONFIG; do
    SKIP="yes"
    case "$config_option" in
    *-config)
        # take the last *-config setting.  this is the highest config being used,
        # and is the one that we will use for tagging plugins
        BUILD_CONFIG="$config_option"
        ;;

    *) # skip all other options since they don't affect the Qt API/ABI.
        ;;
    esac

    if [ "$SKIP" = "no" ]; then
        BUILD_OPTIONS="$BUILD_OPTIONS $config_option"
    fi
done

# put the options that we are missing into .options
rm -f .options
for opt in `echo $ALL_OPTIONS`; do
    SKIP="no"
    if echo $BUILD_OPTIONS | grep $opt >/dev/null 2>&1; then
        SKIP="yes"
    fi
    if [ "$SKIP" = "no" ]; then
        echo "$opt" >> .options
    fi
done

# reconstruct BUILD_OPTIONS with a sorted negative feature list
# (ie. only things that are missing are will be put into the build key)
BUILD_OPTIONS=
if [ -f .options ]; then
    for opt in `sort -f .options | uniq`; do
        BUILD_OPTIONS="$BUILD_OPTIONS no-$opt"
    done
fi
rm -f .options

# QT_NO* defines affect the Qt API (and binary compatibility).  they need
# to be included in the build key
for build_option in $D_FLAGS; do
    build_option=`echo $build_option | cut -d \" -f 2 -`
    case "$build_option" in
    QT_NO*)
        echo "$build_option" >> .options
        ;;
    *)
        # skip all other compiler defines
        ;;
    esac
done

# sort the compile time defines (helps ensure that changes in this configure
# script don't affect the QT_BUILD_KEY generation)
if [ -f .options ]; then
    for opt in `sort -f .options | uniq`; do
        BUILD_OPTIONS="$BUILD_OPTIONS $opt"
    done
fi
rm -f .options

BUILD_OPTIONS="$BUILD_CONFIG $BUILD_OPTIONS"
# extract the operating system from the XPLATFORM
TARGET_OPERATING_SYSTEM=`echo $XPLATFORM | cut -f 2- -d/ | cut -f -1 -d-`
if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    QT_BUILD_KEY_SYSTEM_PART="Symbian"
else
    QT_BUILD_KEY_SYSTEM_PART="$CFG_ARCH $TARGET_OPERATING_SYSTEM $COMPILER"
fi

# when cross-compiling, don't include build-host information (build key is target specific)
QT_BUILD_KEY="$CFG_USER_BUILD_KEY $QT_BUILD_KEY_SYSTEM_PART $BUILD_OPTIONS"
if [ -n "$QT_NAMESPACE" ]; then
    QT_BUILD_KEY="$QT_BUILD_KEY $QT_NAMESPACE"
fi
MAC_NEED_TWO_BUILD_KEYS="no"
if [ "$PLATFORM_MAC" = "yes" -a "$CFG_MAC_COCOA" = "yes" ]; then
    QT_BUILD_KEY_CARBON=$QT_BUILD_KEY
    TARGET_OPERATING_SYSTEM="$TARGET_OPERATING_SYSTEM-cocoa"
    QT_BUILD_KEY_COCOA="$CFG_USER_BUILD_KEY $CFG_ARCH $TARGET_OPERATING_SYSTEM $COMPILER $BUILD_OPTIONS"
    if [ "$CFG_MAC_CARBON" = "no" ]; then
        QT_BUILD_KEY=$QT_BUILD_KEY_COCOA
    else
        MAC_NEED_TWO_BUILD_KEYS="yes"
    fi
fi
# don't break loading plugins build with an older version of Qt
QT_BUILD_KEY_COMPAT=
if [ "$QT_CROSS_COMPILE" = "no" ]; then
    # previous versions of Qt used a build key built from the uname
    QT_BUILD_KEY_COMPAT="$CFG_USER_BUILD_KEY $UNAME_MACHINE $UNAME_SYSTEM $COMPILER $BUILD_OPTIONS"
    if [ -n "$QT_NAMESPACE" ]; then
        QT_BUILD_KEY_COMPAT="$QT_BUILD_KEY_COMPAT $QT_NAMESPACE"
    fi
fi

# is this compiler compatible with some other "standard" build key
QT_BUILD_KEY_COMPAT_COMPILER=
if [ ! -z "$COMPAT_COMPILER" ]; then
    QT_BUILD_KEY_COMPAT_COMPILER="$CFG_USER_BUILD_KEY $CFG_ARCH $TARGET_OPERATING_SYSTEM $COMPAT_COMPILER $BUILD_OPTIONS"
    if [ -n "$QT_NAMESPACE" ]; then
        QT_BUILD_KEY_COMPAT_COMPILER="$QT_BUILD_KEY_COMPAT_COMPILER $QT_NAMESPACE"
    fi
fi

# is this arch compatible with some other "standard" build key
QT_BUILD_KEY_COMPAT_ARCH=
if [ ! -z "$COMPAT_ARCH" ]; then
    QT_BUILD_KEY_COMPAT_ARCH="$CFG_USER_BUILD_KEY $COMPAT_ARCH $TARGET_OPERATING_SYSTEM $COMPILER $BUILD_OPTIONS"
    if [ -n "$QT_NAMESPACE" ]; then
        QT_BUILD_KEY_COMPAT_COMPILER="$QT_BUILD_KEY_COMPAT_ARCH $QT_NAMESPACE"
    fi
fi

# strip out leading/trailing/extra whitespace
QT_BUILD_KEY=`echo $QT_BUILD_KEY | sed -e "s,  *, ,g" -e "s,^  *,," -e "s,  *$,,"`
QT_BUILD_KEY_COMPAT=`echo $QT_BUILD_KEY_COMPAT | sed -e "s,  *, ,g" -e "s,^  *,," -e "s,  *$,,"`
QT_BUILD_KEY_COMPAT_COMPILER=`echo $QT_BUILD_KEY_COMPAT_COMPILER | sed -e "s,  *, ,g" -e "s,^  *,," -e "s,  *$,,"`
QT_BUILD_KEY_COMPAT_ARCH=`echo $QT_BUILD_KEY_COMPAT_ARCH | sed -e "s,  *, ,g" -e "s,^  *,," -e "s,  *$,,"`

#-------------------------------------------------------------------------------
# part of configuration information goes into qconfig.h
#-------------------------------------------------------------------------------

case "$CFG_QCONFIG" in
full)
    echo "/* Everything */" >"$outpath/src/corelib/global/qconfig.h.new"
    ;;
*)
    tmpconfig="$outpath/src/corelib/global/qconfig.h.new"
    echo "#ifndef QT_BOOTSTRAPPED" >"$tmpconfig"
    if [ -f "$relpath/src/corelib/global/qconfig-$CFG_QCONFIG.h" ]; then
        cat "$relpath/src/corelib/global/qconfig-$CFG_QCONFIG.h" >>"$tmpconfig"
    elif [ -f `"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"` ]; then
        cat `"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"` >>"$tmpconfig"
    fi
    echo "#endif" >>"$tmpconfig"
    ;;
esac

cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF

/* Qt Edition */
#ifndef QT_EDITION
#  define QT_EDITION $QT_EDITION
#endif

/* Machine byte-order */
#define Q_BIG_ENDIAN 4321
#define Q_LITTLE_ENDIAN 1234
EOF

if [ "$MAC_NEED_TWO_BUILD_KEYS" = "no" ]; then
    echo "#define QT_BUILD_KEY \"$QT_BUILD_KEY\"" \
        >> "$outpath/src/corelib/global/qconfig.h.new"
else
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF

#define QT_BUILD_KEY_CARBON "$QT_BUILD_KEY_CARBON"
#define QT_BUILD_KEY_COCOA "$QT_BUILD_KEY_COCOA"
EOF
fi

if [ -n "$QT_BUILD_KEY_COMPAT" ]; then
    echo "#define QT_BUILD_KEY_COMPAT \"$QT_BUILD_KEY_COMPAT\"" \
        >> "$outpath/src/corelib/global/qconfig.h.new"
fi
if [ -n "$QT_BUILD_KEY_COMPAT_COMPILER" ]; then
    echo "#define QT_BUILD_KEY_COMPAT2 \"$QT_BUILD_KEY_COMPAT_COMPILER\"" \
        >> "$outpath/src/corelib/global/qconfig.h.new"
fi
if [ -n "$QT_BUILD_KEY_COMPAT_ARCH" ]; then
    echo "#define QT_BUILD_KEY_COMPAT3 \"$QT_BUILD_KEY_COMPAT_ARCH\"" \
        >> "$outpath/src/corelib/global/qconfig.h.new"
fi

echo "" >>"$outpath/src/corelib/global/qconfig.h.new"

echo "#ifdef QT_BOOTSTRAPPED" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "$CFG_HOST_ENDIAN" = "auto" ]; then
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN
#else
# error "Unable to determine byte order!"
#endif
EOF
else
    echo "#define Q_BYTE_ORDER $CFG_HOST_ENDIAN" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
echo "#else" >>"$outpath/src/corelib/global/qconfig.h.new"
if [ "$CFG_ENDIAN" = "auto" ]; then
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#if defined(__BIG_ENDIAN__)
# define Q_BYTE_ORDER Q_BIG_ENDIAN
#elif defined(__LITTLE_ENDIAN__)
# define Q_BYTE_ORDER Q_LITTLE_ENDIAN
#else
# error "Unable to determine byte order!"
#endif
EOF
else
    echo "#define Q_BYTE_ORDER $CFG_ENDIAN" >>"$outpath/src/corelib/global/qconfig.h.new"
fi
echo "#endif" >>"$outpath/src/corelib/global/qconfig.h.new"

if [ "$CFG_DOUBLEFORMAT" != "normal" ]; then
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
/* Non-IEEE double format */
#define Q_DOUBLE_LITTLE "01234567"
#define Q_DOUBLE_BIG "76543210"
#define Q_DOUBLE_LITTLE_SWAPPED "45670123"
#define Q_DOUBLE_BIG_SWAPPED "32107654"
#define Q_DOUBLE_FORMAT $CFG_DOUBLEFORMAT
EOF
fi
if [ "$CFG_ARMFPA" = "yes" ]; then
    if [ "$CFG_ARCH" != "$CFG_HOST_ARCH" ]; then
	cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#ifndef QT_BOOTSTRAPPED
# define QT_ARMFPA
#endif
EOF
    else
	echo "#define QT_ARMFPA" >>"$outpath/src/corelib/global/qconfig.h.new"
    fi
fi

CFG_ARCH_STR=`echo $CFG_ARCH | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
CFG_HOST_ARCH_STR=`echo $CFG_HOST_ARCH | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
/* Machine Architecture */
#ifndef QT_BOOTSTRAPPED
# define QT_ARCH_${CFG_ARCH_STR}
#else
# define QT_ARCH_${CFG_HOST_ARCH_STR}
#endif
EOF

echo '/* Compile time features */' >>"$outpath/src/corelib/global/qconfig.h.new"
[ '!' -z "$LicenseKeyExt" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKeyExt\"" >>"$outpath/src/corelib/global/qconfig.h.new"

if [ "$CFG_LARGEFILE" = "yes" ] && [ "$XPLATFORM_MINGW" != "yes" ]; then
    echo "#define QT_LARGEFILE_SUPPORT 64" >>"$outpath/src/corelib/global/qconfig.h.new"
fi

# if both carbon and cocoa are specified, enable the autodetection code.
if [ "$PLATFORM_MAC" = "yes" -a "$CFG_MAC_COCOA" = "yes" -a "$CFG_MAC_CARBON" = "yes" ]; then
    echo "#define QT_AUTODETECT_COCOA 1" >>"$outpath/src/corelib/global/qconfig.h.new"
elif [ "$PLATFORM_MAC" = "yes" -a "$CFG_MAC_COCOA" = "yes" ]; then
    echo "#define QT_MAC_USE_COCOA 1" >>"$outpath/src/corelib/global/qconfig.h.new"
fi

if [ "$CFG_FRAMEWORK" = "yes" ]; then
    echo "#define QT_MAC_FRAMEWORK_BUILD" >>"$outpath/src/corelib/global/qconfig.h.new"
fi

if [ "$PLATFORM_MAC" = "yes" ]; then
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
#if defined(__LP64__)
# define QT_POINTER_SIZE 8
#else
# define QT_POINTER_SIZE 4
#endif
EOF
else
    "$unixtests/ptrsize.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath"
    echo "#define QT_POINTER_SIZE $?" >>"$outpath/src/corelib/global/qconfig.h.new"
fi


echo "" >>"$outpath/src/corelib/global/qconfig.h.new"

if [ "$CFG_DEV" = "yes" ]; then
    echo "#define QT_BUILD_INTERNAL" >>"$outpath/src/corelib/global/qconfig.h.new"
fi

# Embedded compile time options
if [ "$PLATFORM_QWS" = "yes" ]; then
    # Add QWS to config.h
    QCONFIG_FLAGS="$QCONFIG_FLAGS Q_WS_QWS"

    # Add excluded decorations to $QCONFIG_FLAGS
    decors=`grep '^decorations -= ' "$QMAKE_VARS_FILE" | ${AWK} '{print $3}'`
    for decor in $decors; do
        NODECORATION=`echo $decor | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        QCONFIG_FLAGS="${QCONFIG_FLAGS} QT_NO_QWS_DECORATION_${NODECORATION}"
    done

    # Figure which embedded drivers which are turned off
    CFG_GFX_OFF="$CFG_GFX_AVAILABLE"
    for ADRIVER in $CFG_GFX_ON; do
        CFG_GFX_OFF=`echo "${CFG_GFX_OFF} " | sed "s,${ADRIVER} ,,g"`
    done

    CFG_KBD_OFF="$CFG_KBD_AVAILABLE"
    # the um driver is currently not in the available list for external builds
    if [ "$CFG_DEV" = "no" ]; then
	CFG_KBD_OFF="$CFG_KBD_OFF um"
    fi
    for ADRIVER in $CFG_KBD_ON; do
        CFG_KBD_OFF=`echo "${CFG_KBD_OFF} " | sed "s,${ADRIVER} ,,g"`
    done

    CFG_MOUSE_OFF="$CFG_MOUSE_AVAILABLE"
    for ADRIVER in $CFG_MOUSE_ON; do
        CFG_MOUSE_OFF=`echo "${CFG_MOUSE_OFF} " | sed "s,${ADRIVER} ,,g"`
    done

    for DRIVER in $CFG_GFX_OFF; do
        NODRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_$NODRIVER"
    done

    for DRIVER in $CFG_KBD_OFF; do
        NODRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_KBD_$NODRIVER"
    done

    for DRIVER in $CFG_MOUSE_OFF; do
        NODRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_QWS_MOUSE_$NODRIVER"
    done
fi # QWS

if [ "$PLATFORM_QPA" = "yes" ]; then
    # Add QPA to config.h
    QCONFIG_FLAGS="$QCONFIG_FLAGS Q_WS_QPA QT_NO_QWS_QPF QT_NO_QWS_QPF2"
fi

if [ "${CFG_USE_FLOATMATH}" = "yes" ]; then
    QCONFIG_FLAGS="${QCONFIG_FLAGS} QT_USE_MATH_H_FLOATS"
fi

# Add turned on SQL drivers
for DRIVER in $CFG_SQL_AVAILABLE; do
    eval "VAL=\$CFG_SQL_$DRIVER"
    case "$VAL" in
    qt)
        ONDRIVER=`echo $DRIVER | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SQL_$ONDRIVER"
        SQL_DRIVERS="$SQL_DRIVERS $DRIVER"
    ;;
    plugin)
        SQL_PLUGINS="$SQL_PLUGINS $DRIVER"
    ;;
    esac
done


QMakeVar set sql-drivers "$SQL_DRIVERS"
QMakeVar set sql-plugins "$SQL_PLUGINS"

# Add other configuration options to the qconfig.h file
[ "$CFG_GIF" = "yes" ]       && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_BUILTIN_GIF_READER=1"
[ "$CFG_TIFF" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_TIFF"
[ "$CFG_PNG" != "yes" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
[ "$CFG_JPEG" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
[ "$CFG_MNG" != "yes" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_MNG"
[ "$CFG_ZLIB" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ZLIB"
[ "$CFG_S60" != "yes" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_S60"
[ "$CFG_EXCEPTIONS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EXCEPTIONS"
[ "$CFG_IPV6" = "no" ]       && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6"
[ "$CFG_SXE" = "no" ]        && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SXE"
[ "$CFG_DBUS" = "no" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DBUS"

if [ "$PLATFORM_QWS" != "yes" ]; then
    [ "$CFG_GRAPHICS_SYSTEM" = "raster" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_RASTER"
    [ "$CFG_GRAPHICS_SYSTEM" = "opengl" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_OPENGL"
    [ "$CFG_GRAPHICS_SYSTEM" = "openvg" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_OPENVG"
    [ "$CFG_GRAPHICS_SYSTEM" = "runtime" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_GRAPHICSSYSTEM_RUNTIME"
fi

# X11/Unix/Mac only configs
[ "$CFG_CUPS" = "no" ]       && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CUPS"
[ "$CFG_ICONV" = "no" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ICONV"
[ "$CFG_GLIB" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GLIB"
[ "$CFG_GSTREAMER" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GSTREAMER"
[ "$CFG_QGTKSTYLE" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_GTK"
[ "$CFG_CLOCK_MONOTONIC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CLOCK_MONOTONIC"
[ "$CFG_MREMAP" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MREMAP"
[ "$CFG_GETADDRINFO" = "no" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETADDRINFO"
[ "$CFG_IPV6IFNAME" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IPV6IFNAME"
[ "$CFG_GETIFADDRS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GETIFADDRS"
[ "$CFG_INOTIFY" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_INOTIFY"
[ "$CFG_NAS" = "no" ]        && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NAS"
[ "$CFG_NIS" = "no" ]        && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NIS"
[ "$CFG_OPENSSL" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENSSL"
[ "$CFG_OPENSSL" = "linked" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LINKED_OPENSSL"

[ "$CFG_SM" = "no" ]         && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SESSIONMANAGER"
[ "$CFG_XCURSOR" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XCURSOR"
[ "$CFG_XFIXES" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XFIXES"
[ "$CFG_FONTCONFIG" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FONTCONFIG"
[ "$CFG_XINERAMA" = "no" ]   && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINERAMA"
[ "$CFG_XKB" = "no" ]        && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XKB"
[ "$CFG_XRANDR" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRANDR"
[ "$CFG_XRENDER" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRENDER"
[ "$CFG_MITSHM" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_MITSHM"
[ "$CFG_XSHAPE" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SHAPE"
[ "$CFG_XVIDEO" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XVIDEO"
[ "$CFG_XSYNC" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XSYNC"
[ "$CFG_XINPUT" = "no" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XINPUT QT_NO_TABLET"

[ "$CFG_XCURSOR" = "runtime" ]   && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XCURSOR"
[ "$CFG_XINERAMA" = "runtime" ]  && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINERAMA"
[ "$CFG_XFIXES" = "runtime" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XFIXES"
[ "$CFG_XRANDR" = "runtime" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XRANDR"
[ "$CFG_XINPUT" = "runtime" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_RUNTIME_XINPUT"
[ "$CFG_ALSA" = "no" ]           && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ALSA"
[ "$CFG_PULSEAUDIO" = "no" ]          && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_PULSEAUDIO"
[ "$CFG_COREWLAN" = "no" ]       && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_COREWLAN"
[ "$CFG_ICD" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ICD"

# sort QCONFIG_FLAGS for neatness if we can
[ '!' -z "$AWK" ] && QCONFIG_FLAGS=`echo $QCONFIG_FLAGS | $AWK '{ gsub(" ", "\n"); print }' | sort | uniq`
QCONFIG_FLAGS=`echo $QCONFIG_FLAGS`

if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
    # Enable Symbian DLLs and export rules.
    # We cannot use Linux's default export rules since they export everything.
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_DLL"
    # Disable non-working features.
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT QT_NO_QFUTURE QT_NO_CRASHHANDLER QT_NO_PRINTER QT_NO_SYSTEMTRAYICON"
fi

if [ -n "$QCONFIG_FLAGS" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#ifndef QT_BOOTSTRAPPED

EOF
    for cfg in $QCONFIG_FLAGS; do
        cfgd=`echo $cfg | sed 's/=.*$//'` # trim pushed 'Foo=Bar' defines
        cfg=`echo $cfg | sed 's/=/ /'`    # turn first '=' into a space
        # figure out define logic, so we can output the correct
        # ifdefs to override the global defines in a project
        cfgdNeg=
        if [ true ] && echo "$cfgd" | grep 'QT_NO_' >/dev/null 2>&1; then
            # QT_NO_option can be forcefully turned on by QT_option
            cfgdNeg=`echo $cfgd | sed "s,QT_NO_,QT_,"`
        elif [ true ] && echo "$cfgd" | grep 'QT_' >/dev/null 2>&1; then
            # QT_option can be forcefully turned off by QT_NO_option
            cfgdNeg=`echo $cfgd | sed "s,QT_,QT_NO_,"`
        fi

        if [ -z $cfgdNeg ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#ifndef $cfgd
# define $cfg
#endif

EOF
        else
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#if defined($cfgd) && defined($cfgdNeg)
# undef $cfgd
#elif !defined($cfgd) && !defined($cfgdNeg)
# define $cfg
#endif

EOF
        fi
    done
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#endif // QT_BOOTSTRAPPED

EOF
fi

if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#define QT_VISIBILITY_AVAILABLE

EOF
fi

if [ -n "$QT_LIBINFIX" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#define QT_LIBINFIX "$QT_LIBINFIX"

EOF
fi

if [ -n "$CFG_RUNTIME_SYSTEM" ]; then
cat >>"$outpath/src/corelib/global/qconfig.h.new" << EOF
#define QT_DEFAULT_RUNTIME_SYSTEM "$CFG_RUNTIME_SYSTEM"

EOF
fi

# avoid unecessary rebuilds by copying only if qconfig.h has changed
if cmp -s "$outpath/src/corelib/global/qconfig.h" "$outpath/src/corelib/global/qconfig.h.new"; then
    rm -f "$outpath/src/corelib/global/qconfig.h.new"
else
    [ -f "$outpath/src/corelib/global/qconfig.h" ] && chmod +w "$outpath/src/corelib/global/qconfig.h"
    mv "$outpath/src/corelib/global/qconfig.h.new" "$outpath/src/corelib/global/qconfig.h"
    chmod -w "$outpath/src/corelib/global/qconfig.h"
    for conf in "$outpath/include/QtCore/qconfig.h" "$outpath/include/Qt/qconfig.h"; do
        if [ "$XPLATFORM_SYMBIAN_SBSV2" = "yes" ]; then
            [ -e "$conf" ] && rm -rf "$conf"
            cp -a "$outpath/src/corelib/global/qconfig.h" "$conf"
        elif [ '!' -f "$conf" ]; then
            ln -s "$outpath/src/corelib/global/qconfig.h" "$conf"
        fi
    done
fi
#-------------------------------------------------------------------------------
# save configuration into qconfig.pri
#-------------------------------------------------------------------------------

QTCONFIG="$outpath/mkspecs/qconfig.pri"
QTCONFIG_CONFIG="$QTCONFIG_CONFIG no_mocdepend"
[ -f "$QTCONFIG.tmp" ] && rm -f "$QTCONFIG.tmp"
if [ "$CFG_DEBUG" = "yes" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG debug"
    if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG release"
    fi
    QT_CONFIG="$QT_CONFIG debug"
elif [ "$CFG_DEBUG" = "no" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG release"
    if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
        QT_CONFIG="$QT_CONFIG debug"
    fi
    QT_CONFIG="$QT_CONFIG release"
fi
if [ "$CFG_STL" = "yes" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG stl"
fi
if [ "$CFG_FRAMEWORK" = "no" ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG qt_no_framework"
else
    QT_CONFIG="$QT_CONFIG qt_framework"
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG qt_framework"
fi
if [ "$PLATFORM_MAC" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG $CFG_MAC_ARCHS"
fi
if [ "$CFG_DEV" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG private_tests"
fi

if [ -z "$QT_CFLAGS_FPU" ]; then
    if echo "$XPLATFORM" | grep "symbian-sbsv2" > /dev/null 2>&1; then
        QT_CFLAGS_FPU=softvfp
    fi
fi

# Make the application arch follow the Qt arch for single arch builds.
# (for multiple-arch builds, set CONFIG manually in the application .pro file)
if [ `echo "$CFG_MAC_ARCHS" | wc -w` -eq 1 ]; then
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG $CFG_MAC_ARCHS"
fi

cat >>"$QTCONFIG.tmp" <<EOF
#configuration
CONFIG += $QTCONFIG_CONFIG
QT_ARCH = $CFG_ARCH
QT_EDITION = $Edition
QT_CONFIG += $QT_CONFIG

#versioning
QT_VERSION = $QT_VERSION
QT_MAJOR_VERSION = $QT_MAJOR_VERSION
QT_MINOR_VERSION = $QT_MINOR_VERSION
QT_PATCH_VERSION = $QT_PATCH_VERSION

#namespaces
QT_LIBINFIX = $QT_LIBINFIX
QT_NAMESPACE = $QT_NAMESPACE
QT_NAMESPACE_MAC_CRC = $QT_NAMESPACE_MAC_CRC

EOF
if [ "$CFG_RPATH" = "yes" ]; then
    echo "QMAKE_RPATHDIR += \"$QT_INSTALL_LIBS\"" >> "$QTCONFIG.tmp"
fi
if [ -n "$QT_GCC_MAJOR_VERSION" ]; then
    echo "QT_GCC_MAJOR_VERSION = $QT_GCC_MAJOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_GCC_MINOR_VERSION = $QT_GCC_MINOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_GCC_PATCH_VERSION = $QT_GCC_PATCH_VERSION" >> "$QTCONFIG.tmp"
fi
if [ -n "$QT_CFLAGS_FPU" ]; then
    echo "#Qt for symbian FPU settings" >> "$QTCONFIG.tmp"
    echo "MMP_RULES += \"ARMFPU $QT_CFLAGS_FPU\"" >> "$QTCONFIG.tmp"
fi

# replace qconfig.pri if it differs from the newly created temp file
if cmp -s "$QTCONFIG.tmp" "$QTCONFIG"; then
    rm -f "$QTCONFIG.tmp"
else
    mv -f "$QTCONFIG.tmp" "$QTCONFIG"
fi

#-------------------------------------------------------------------------------
# save configuration into .qmake.cache
#-------------------------------------------------------------------------------

CACHEFILE="$outpath/.qmake.cache"
[ -f "$CACHEFILE.tmp" ] && rm -f "$CACHEFILE.tmp"
cat >>"$CACHEFILE.tmp" <<EOF
CONFIG += $QMAKE_CONFIG dylib create_prl link_prl depend_includepath fix_output_dirs QTDIR_build
QT_SOURCE_TREE = \$\$quote($relpath)
QT_BUILD_TREE = \$\$quote($outpath)
QT_BUILD_PARTS = $CFG_BUILD_PARTS
QMAKE_ABSOLUTE_SOURCE_ROOT = \$\$QT_SOURCE_TREE
QMAKE_MOC_SRC    = \$\$QT_BUILD_TREE/src/moc

#local paths that cannot be queried from the QT_INSTALL_* properties while building QTDIR
QMAKE_MOC        = \$\$QT_BUILD_TREE/bin/moc
QMAKE_UIC        = \$\$QT_BUILD_TREE/bin/uic
QMAKE_UIC3       = \$\$QT_BUILD_TREE/bin/uic3
QMAKE_RCC        = \$\$QT_BUILD_TREE/bin/rcc
QMAKE_QDBUSXML2CPP = \$\$QT_BUILD_TREE/bin/qdbusxml2cpp
QMAKE_INCDIR_QT  = \$\$QT_BUILD_TREE/include
QMAKE_LIBDIR_QT  = \$\$QT_BUILD_TREE/lib

EOF

# Ensure we can link to uninistalled libraries
if [ "$XPLATFORM_MINGW" != "yes" ] && [ "$CFG_EMBEDDED" != "nacl" ] && linkerSupportsFlag -rpath-link "$outpath/lib"; then
    echo "QMAKE_LFLAGS    = -Wl,-rpath-link,\$\$QT_BUILD_TREE/lib \$\$QMAKE_LFLAGS" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_CFLAGS_PSQL" ]; then
    echo "QT_CFLAGS_PSQL   = $QT_CFLAGS_PSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_PSQL" ]; then
    echo "QT_LFLAGS_PSQL   = $QT_LFLAGS_PSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_CFLAGS_MYSQL" ]; then
    echo "QT_CFLAGS_MYSQL   = $QT_CFLAGS_MYSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_MYSQL" ]; then
    echo "QT_LFLAGS_MYSQL   = $QT_LFLAGS_MYSQL" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_CFLAGS_SQLITE" ]; then
    echo "QT_CFLAGS_SQLITE   = $QT_CFLAGS_SQLITE" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_SQLITE" ]; then
    echo "QT_LFLAGS_SQLITE   = $QT_LFLAGS_SQLITE" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_ODBC" ]; then
    echo "QT_LFLAGS_ODBC   = $QT_LFLAGS_ODBC" >> "$CACHEFILE.tmp"
fi
if [ -n "$QT_LFLAGS_TDS" ]; then
    echo "QT_LFLAGS_TDS   = $QT_LFLAGS_TDS" >> "$CACHEFILE.tmp"
fi

if [ "$QT_EDITION" != "QT_EDITION_OPENSOURCE" ]; then
    echo "DEFINES *= QT_EDITION=QT_EDITION_DESKTOP" >> "$CACHEFILE.tmp"
fi

#dump in the OPENSSL_LIBS info
if [ '!' -z "$OPENSSL_LIBS" ]; then
    echo "OPENSSL_LIBS = $OPENSSL_LIBS" >> "$CACHEFILE.tmp"
elif [ "$CFG_OPENSSL" = "linked" ]; then
    echo "OPENSSL_LIBS = -lssl -lcrypto" >> "$CACHEFILE.tmp"
fi

#dump in the SDK info
if [ '!' -z "$CFG_SDK" ]; then
   echo "QMAKE_MAC_SDK = $CFG_SDK" >> "$CACHEFILE.tmp"
fi

# mac gcc -Xarch support
if [ "$CFG_MAC_XARCH" = "no" ]; then
   echo "QMAKE_MAC_XARCH = no" >> "$CACHEFILE.tmp"
fi

#dump the qmake spec
if [ -d "$outpath/mkspecs/$XPLATFORM" ]; then
   echo "QMAKESPEC = \$\$QT_BUILD_TREE/mkspecs/$XPLATFORM" >> "$CACHEFILE.tmp"
else
   echo "QMAKESPEC = $XPLATFORM" >> "$CACHEFILE.tmp"
fi

# cmdline args
cat "$QMAKE_VARS_FILE" >> "$CACHEFILE.tmp"
rm -f "$QMAKE_VARS_FILE" 2>/dev/null

# incrementals
INCREMENTAL=""
[ "$CFG_INCREMENTAL" = "auto" ] && "$WHICH" p4 >/dev/null 2>&1 && [ "$CFG_DEV" = "yes" ] && CFG_INCREMENTAL="yes"
if [ "$CFG_INCREMENTAL" = "yes" ]; then
    find "$relpath" -perm u+w -mtime -3 | grep 'cpp$' | while read f; do
        # don't need to worry about generated files
        [ -r `echo $f | sed "s,cpp$,ui,"` ] && continue
        basename "$f" | grep '^moc_' >/dev/null 2>&1 && continue
        # done
        INCREMENTAL="$INCREMENTAL `basename \"$f\" | sed 's,.cpp,.o,'`"
    done
    [ '!' -z "$INCREMENTAL" ] && echo "QMAKE_INCREMENTAL += $INCREMENTAL" >> "$CACHEFILE.tmp"
    [ -r "$outpath/.qmake.incremental" ] && echo "include($outpath/.qmake.incremental)" >> "$CACHEFILE.tmp"
fi

# replace .qmake.cache if it differs from the newly created temp file
if cmp -s "$CACHEFILE.tmp" "$CACHEFILE"; then
    rm -f "$CACHEFILE.tmp"
else
    mv -f "$CACHEFILE.tmp" "$CACHEFILE"
fi

#-------------------------------------------------------------------------------
# give feedback on configuration
#-------------------------------------------------------------------------------

case "$COMPILER" in
g++*)
    if [ "$CFG_EXCEPTIONS" != "no" ]; then
        cat <<EOF

        This target is using the GNU C++ compiler ($PLATFORM).

        Recent versions of this compiler automatically include code for
        exceptions, which increase both the size of the Qt libraries and
        the amount of memory taken by your applications.

        You may choose to re-run `basename $0` with the -no-exceptions
        option to compile Qt without exceptions. This is completely binary
        compatible, and existing applications will continue to work.

EOF
    fi
    ;;
cc*)
    case "$PLATFORM" in
    irix-cc*)
        if [ "$CFG_EXCEPTIONS" != "no" ]; then
            cat <<EOF

        This target is using the MIPSpro C++ compiler ($PLATFORM).

        You may choose to re-run `basename $0` with the -no-exceptions
        option to compile Qt without exceptions. This will make the
        size of the Qt library smaller and reduce the amount of memory
        taken by your applications.

EOF
        fi
        ;;
    *) ;;
    esac
    ;;
*) ;;
esac

if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_MAC_DWARF2" = "no" ]  && [ "$CFG_WEBKIT" != "no" ] && [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
    cat <<EOF
        WARNING: DWARF2 debug symbols are not enabled. Linking webkit
        in debug mode will run out of memory on systems with 2GB or less.
        Install Xcode 2.4.1 or higher to enable DWARF2, or configure with
         -no-webkit or -release to skip webkit debug.
EOF
fi

echo
if [ "$XPLATFORM" = "$PLATFORM" ]; then
    echo "Build type:    $PLATFORM"
else
    echo "Building on:   $PLATFORM"
    echo "Building for:  $XPLATFORM"
fi

if [ "$PLATFORM_MAC" = "yes" ]; then
    echo "Architecture:  $CFG_ARCH ($CFG_MAC_ARCHS )"
else
    echo "Architecture:  $CFG_ARCH"
fi

if [ "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "yes" ]; then
    echo "Host architecture: $CFG_HOST_ARCH"
fi

if [ "$PLATFORM_MAC" = "yes" ]; then
    if [ "$CFG_MAC_COCOA" = "yes" ]; then
        if [ "$CFG_MAC_CARBON" = "yes" ]; then
            echo "Using framework: Carbon for 32-bit, Cocoa for 64-bit"
        else
            echo "Using framework: Cocoa"
        fi
    else
        echo "Using framework: Carbon"
    fi
fi

if [ -n "$PLATFORM_NOTES" ]; then
    echo "Platform notes:"
    echo "$PLATFORM_NOTES"
else
    echo
fi

if [ "$OPT_VERBOSE" = "yes" ]; then
    echo $ECHO_N "qmake vars .......... $ECHO_C"
    cat "$QMAKE_VARS_FILE" | tr '\n' ' '
    echo "qmake switches ......... $QMAKE_SWITCHES"
fi

[ "$CFG_INCREMENTAL" = "yes" ] && [ '!' -z "$INCREMENTAL" ] && echo "Incremental ............ $INCREMENTAL"
echo "Build .................. $CFG_BUILD_PARTS"
echo "Configuration .......... $QMAKE_CONFIG $QT_CONFIG"
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
   echo "Debug .................. yes (combined)"
   if [ "$CFG_DEBUG" = "yes" ]; then
       echo "Default Link ........... debug"
   else
       echo "Default Link ........... release"
   fi
else
   echo "Debug .................. $CFG_DEBUG"
fi
echo "Qt 3 compatibility ..... $CFG_QT3SUPPORT"
[ "$CFG_DBUS" = "no" ]     && echo "QtDBus module .......... no"
[ "$CFG_DBUS" = "yes" ]    && echo "QtDBus module .......... yes (run-time)"
[ "$CFG_DBUS" = "linked" ] && echo "QtDBus module .......... yes (linked)"
echo "QtConcurrent code ...... $CFG_CONCURRENT"
echo "QtGui module ........... $CFG_GUI"
echo "QtScript module ........ $CFG_SCRIPT"
echo "QtScriptTools module ... $CFG_SCRIPTTOOLS"
echo "QtXmlPatterns module ... $CFG_XMLPATTERNS"
echo "Phonon module .......... $CFG_PHONON"
echo "Multimedia module ...... $CFG_MULTIMEDIA"
echo "SVG module ............. $CFG_SVG"
case "$CFG_WEBKIT" in
    yes)   echo "WebKit module .......... yes" ;;
    debug) echo "WebKit module .......... yes (debug)" ;;
    no)    echo "WebKit module .......... no" ;;
esac
if [ "$CFG_WEBKIT" != "no" ]; then
    if [ "$CFG_JAVASCRIPTCORE_JIT" = "auto" ]; then
        echo "JavaScriptCore JIT ..... To be decided by JavaScriptCore"
    else
        echo "JavaScriptCore JIT ..... $CFG_JAVASCRIPTCORE_JIT"
    fi
fi
echo "Declarative module ..... $CFG_DECLARATIVE"
echo "Declarative debugging ...$CFG_DECLARATIVE_DEBUG"
echo "Support for S60 ........ $CFG_S60"
echo "Symbian DEF files ...... $CFG_SYMBIAN_DEFFILES"
echo "STL support ............ $CFG_STL"
echo "PCH support ............ $CFG_PRECOMPILE"
echo "MMX/3DNOW/SSE/SSE2/SSE3. ${CFG_MMX}/${CFG_3DNOW}/${CFG_SSE}/${CFG_SSE2}/${CFG_SSE3}"
echo "SSSE3/SSE4.1/SSE4.2..... ${CFG_SSSE3}/${CFG_SSE4_1}/${CFG_SSE4_2}"
echo "AVX..................... ${CFG_AVX}"
if [ "$CFG_ARCH" = "arm" ] || [ "$CFG_ARCH" = "armv6" ]; then
    echo "iWMMXt support ......... ${CFG_IWMMXT}"
    echo "NEON support ........... ${CFG_NEON}"
fi
[ "${PLATFORM_QWS}" != "yes" ] && echo "Graphics System ........ $CFG_GRAPHICS_SYSTEM"
echo "IPv6 support ........... $CFG_IPV6"
echo "IPv6 ifname support .... $CFG_IPV6IFNAME"
echo "getaddrinfo support .... $CFG_GETADDRINFO"
echo "getifaddrs support ..... $CFG_GETIFADDRS"
echo "Accessibility .......... $CFG_ACCESSIBILITY"
echo "NIS support ............ $CFG_NIS"
echo "CUPS support ........... $CFG_CUPS"
echo "Iconv support .......... $CFG_ICONV"
echo "Glib support ........... $CFG_GLIB"
echo "GStreamer support ...... $CFG_GSTREAMER"
echo "PulseAudio support ..... $CFG_PULSEAUDIO"
echo "Large File support ..... $CFG_LARGEFILE"
echo "GIF support ............ $CFG_GIF"
if [ "$CFG_TIFF" = "no" ]; then
    echo "TIFF support ........... $CFG_TIFF"
else
    echo "TIFF support ........... $CFG_TIFF ($CFG_LIBTIFF)"
fi
if [ "$CFG_JPEG" = "no" ]; then
    echo "JPEG support ........... $CFG_JPEG"
else
    echo "JPEG support ........... $CFG_JPEG ($CFG_LIBJPEG)"
fi
if [ "$CFG_PNG" = "no" ]; then
    echo "PNG support ............ $CFG_PNG"
else
    echo "PNG support ............ $CFG_PNG ($CFG_LIBPNG)"
fi
if [ "$CFG_MNG" = "no" ]; then
    echo "MNG support ............ $CFG_MNG"
else
    echo "MNG support ............ $CFG_MNG ($CFG_LIBMNG)"
fi
echo "zlib support ........... $CFG_ZLIB"
echo "Session management ..... $CFG_SM"
if [ "$PLATFORM_QWS" = "yes"  -o "$PLATFORM_QPA" = "yes" ]; then
    echo "Embedded support ....... $CFG_EMBEDDED"
    if [ "$CFG_QWS_FREETYPE" = "auto" ]; then
	echo "Freetype2 support ...... $CFG_QWS_FREETYPE ($CFG_LIBFREETYPE)"
    else
	echo "Freetype2 support ...... $CFG_QWS_FREETYPE"
    fi
    # Normalize the decoration output first
    CFG_GFX_ON=`echo ${CFG_GFX_ON}`
    CFG_GFX_PLUGIN=`echo ${CFG_GFX_PLUGIN}`
    echo "Graphics (qt) .......... ${CFG_GFX_ON}"
    echo "Graphics (plugin) ...... ${CFG_GFX_PLUGIN}"
    CFG_DECORATION_ON=`echo ${CFG_DECORATION_ON}`
    CFG_DECORATION_PLUGIN=`echo ${CFG_DECORATION_PLUGIN}`
    echo "Decorations (qt) ....... $CFG_DECORATION_ON"
    echo "Decorations (plugin) ... $CFG_DECORATION_PLUGIN"
    CFG_KBD_ON=`echo ${CFG_KBD_ON}`
    CFG_KBD_PLUGIN=`echo ${CFG_KBD_PLUGIN}`
    echo "Keyboard driver (qt) ... ${CFG_KBD_ON}"
    echo "Keyboard driver (plugin) .. ${CFG_KBD_PLUGIN}"
    CFG_MOUSE_ON=`echo ${CFG_MOUSE_ON}`
    CFG_MOUSE_PLUGIN=`echo ${CFG_MOUSE_PLUGIN}`
    echo "Mouse driver (qt) ...... $CFG_MOUSE_ON"
    echo "Mouse driver (plugin) .. $CFG_MOUSE_PLUGIN"
fi
if [ "$CFG_OPENGL" = "desktop" ]; then
    echo "OpenGL support ......... yes (Desktop OpenGL)"
elif [ "$CFG_OPENGL" = "es1" ]; then
    echo "OpenGL support ......... yes (OpenGL ES 1.x Common profile)"
elif [ "$CFG_OPENGL" = "es2" ]; then
    echo "OpenGL support ......... yes (OpenGL ES 2.x)"
else
    echo "OpenGL support ......... no"
fi
if [ "$CFG_EGL" != "no" ]; then
    if [ "$CFG_EGL_GLES_INCLUDES" != "no" ]; then
        echo "EGL support ............ yes <GLES/egl.h>"
    else
        echo "EGL support ............ yes <EGL/egl.h>"
    fi
fi
if [ "$CFG_OPENVG" ]; then
    if [ "$CFG_OPENVG_SHIVA" = "yes" ]; then
        echo "OpenVG support ......... ShivaVG"
    else
        echo "OpenVG support ......... $CFG_OPENVG"
    fi
fi
if [ "$PLATFORM_X11" = "yes" ]; then
    echo "NAS sound support ...... $CFG_NAS"
    echo "XShape support ......... $CFG_XSHAPE"
    echo "XVideo support ......... $CFG_XVIDEO"
    echo "XSync support .......... $CFG_XSYNC"
    echo "Xinerama support ....... $CFG_XINERAMA"
    echo "Xcursor support ........ $CFG_XCURSOR"
    echo "Xfixes support ......... $CFG_XFIXES"
    echo "Xrandr support ......... $CFG_XRANDR"
    echo "Xrender support ........ $CFG_XRENDER"
    echo "Xi support ............. $CFG_XINPUT"
    echo "MIT-SHM support ........ $CFG_MITSHM"
    echo "FontConfig support ..... $CFG_FONTCONFIG"
    echo "XKB Support ............ $CFG_XKB"
    echo "immodule support ....... $CFG_IM"
    echo "GTK theme support ...... $CFG_QGTKSTYLE"
fi
[ "$CFG_SQL_mysql" != "no" ] && echo "MySQL support .......... $CFG_SQL_mysql"
[ "$CFG_SQL_psql" != "no" ] && echo "PostgreSQL support ..... $CFG_SQL_psql"
[ "$CFG_SQL_odbc" != "no" ] && echo "ODBC support ........... $CFG_SQL_odbc"
[ "$CFG_SQL_oci" != "no" ] && echo "OCI support ............ $CFG_SQL_oci"
[ "$CFG_SQL_tds" != "no" ] && echo "TDS support ............ $CFG_SQL_tds"
[ "$CFG_SQL_db2" != "no" ] && echo "DB2 support ............ $CFG_SQL_db2"
[ "$CFG_SQL_ibase" != "no" ] && echo "InterBase support ...... $CFG_SQL_ibase"
[ "$CFG_SQL_sqlite2" != "no" ] && echo "SQLite 2 support ....... $CFG_SQL_sqlite2"
[ "$CFG_SQL_sqlite" != "no" ] && echo "SQLite support ......... $CFG_SQL_sqlite ($CFG_SQLITE)"

OPENSSL_LINKAGE=""
if [ "$CFG_OPENSSL" = "yes" ]; then
    OPENSSL_LINKAGE="(run-time)"
elif [ "$CFG_OPENSSL" = "linked" ]; then
    OPENSSL_LINKAGE="(linked)"
fi
echo "OpenSSL support ........ $CFG_OPENSSL $OPENSSL_LINKAGE"
echo "Alsa support ........... $CFG_ALSA"
if [ "$PLATFORM_MAC" = "yes" ]; then
    echo "CoreWlan support ....... $CFG_COREWLAN"
fi
echo "ICD support ............ $CFG_ICD"
echo

[ "$CFG_PTMALLOC" != "no" ] && echo "Use ptmalloc ........... $CFG_PTMALLOC"

# complain about not being able to use dynamic plugins if we are using a static build
if [ "$CFG_SHARED" = "no" ]; then
    echo
    echo "WARNING: Using static linking will disable the use of dynamically"
    echo "loaded plugins. Make sure to import all needed static plugins,"
    echo "or compile needed modules into the library."
    echo
fi
if [ "$CFG_OPENSSL" = "linked" ] && [ "$OPENSSL_LIBS" = "" ]; then
    echo
    echo "NOTE: When linking against OpenSSL, you can override the default"
    echo "library names through OPENSSL_LIBS."
    echo "For example:"
    echo "    OPENSSL_LIBS='-L/opt/ssl/lib -lssl -lcrypto' ./configure -openssl-linked"
    echo
fi
if [ "$PLATFORM_MAC" = "yes" ] && [ "$CFG_FRAMEWORK" = "yes" ] && [ "$CFG_DEBUG" = "yes" ] && [ "$CFG_DEBUG_RELEASE" = "no" ]; then
    echo
    echo "Error: debug-only framework builds are not supported. Configure with -no-framework"
    echo "if you want a pure debug build."
    echo
    exit 1
fi

sepath=`echo "$relpath" | sed -e 's/\\./\\\\./g'`
PROCS=1
EXEC=""


#-------------------------------------------------------------------------------
# build makefiles based on the configuration
#-------------------------------------------------------------------------------

echo "Finding project files. Please wait..."
if [ "$CFG_NOPROCESS" != "yes" ]; then
    "$outpath/bin/qmake" -prl -r "${relpath}/projects.pro"
    if [ -f "${relpath}/projects.pro" ]; then
        mkfile="${outpath}/Makefile"
        [ -f "$mkfile" ] && chmod +w "$mkfile"
        QTDIR="$outpath" "$outpath/bin/qmake" -spec "$XQMAKESPEC" "${relpath}/projects.pro" -o "$mkfile"
    fi
fi

# .projects      -> projects to process
# .projects.1    -> qt and moc
# .projects.2    -> subdirs and libs
# .projects.3    -> the rest
rm -f .projects .projects.1 .projects.2 .projects.3

QMAKE_PROJECTS=`find "$relpath/." -name '*.pro' -print | sed 's-/\./-/-'`
if [ -z "$AWK" ]; then
    for p in `echo $QMAKE_PROJECTS`; do
        echo "$p" >> .projects
    done
else
    cat >projects.awk <<EOF
BEGIN {
    files = 0
    target_file = ""
    input_file = ""

    first = "./.projects.1.tmp"
    second = "./.projects.2.tmp"
    third = "./.projects.3.tmp"
}

FNR == 1 {
    if ( input_file ) {
        if ( ! target_file )
            target_file = third
        print input_file >target_file
    }

    matched_target = 0
    template_lib = 0
    input_file = FILENAME
    target_file = ""
}

/^(TARGET.*=)/ {
    if ( \$3 == "moc" || \$3 ~ /^Qt/ ) {
        target_file = first
        matched_target = 1
    } else if ( \$3 == "lrelease" || \$3 == "qm_phony_target" ) {
        target_file = second
        matched_target = 1
    }
}

matched_target == 0 && /^(TEMPLATE.*=)/ {
    if ( \$3 == "subdirs" )
        target_file = second
    else if ( \$3 == "lib" )
        template_lib = 1
    else
        target_file = third
}

matched_target == 0 && template_lib == 1 && /^(CONFIG.*=)/ {
    if ( \$0 ~ /plugin/ )
        target_file = third
    else
        target_file = second
}

END {
    if ( input_file ) {
        if ( ! target_file )
            target_file = third
        print input_file >>target_file
    }
}

EOF

    rm -f .projects.all
    for p in `echo $QMAKE_PROJECTS`; do
       echo "$p" >> .projects.all
    done

    # if you get errors about the length of the command line to awk, change the -l arg
    # to split below
    split -l 100 .projects.all .projects.all.
    for p in .projects.all.*; do
       "$AWK" -f projects.awk `cat $p`
       [ -f .projects.1.tmp ] && cat .projects.1.tmp >> .projects.1
       [ -f .projects.2.tmp ] && cat .projects.2.tmp >> .projects.2
       [ -f .projects.3.tmp ] && cat .projects.3.tmp >> .projects.3
       rm -f .projects.1.tmp .projects.2.tmp .projects.3.tmp $p
    done
    rm -f .projects.all* projects.awk

    [ -f .projects.1 ] && cat .projects.1 >>.projects
    [ -f .projects.2 ] && cat .projects.2 >>.projects
    rm -f .projects.1 .projects.2
    if [ -f .projects.3 ] && [ "$OPT_FAST" = "no" ]; then
       cat .projects.3 >>.projects
       rm -f .projects.3
    fi
fi
# don't sort Qt and MOC in with the other project files
# also work around a segfaulting uniq(1)
if [ -f .sorted.projects.2 ]; then
    sort .sorted.projects.2 > .sorted.projects.2.new
    mv -f .sorted.projects.2.new .sorted.projects.2
    cat .sorted.projects.2 >> .sorted.projects.1
fi
[ -f .sorted.projects.1 ] && sort .sorted.projects.1 >> .sorted.projects
rm -f .sorted.projects.2 .sorted.projects.1

NORM_PROJECTS=0
FAST_PROJECTS=0
if [ -f .projects ]; then
   uniq .projects >.tmp
   mv -f .tmp .projects
   NORM_PROJECTS=`cat .projects | wc -l | sed -e "s, ,,g"`
fi
if [ -f .projects.3 ]; then
   uniq .projects.3 >.tmp
   mv -f .tmp .projects.3
   FAST_PROJECTS=`cat .projects.3 | wc -l | sed -e "s, ,,g"`
fi
echo "  `expr $NORM_PROJECTS + $FAST_PROJECTS` projects found."
echo

PART_ROOTS=
for part in $CFG_BUILD_PARTS; do
    case "$part" in
    tools) PART_ROOTS="$PART_ROOTS tools" ;;
    libs) PART_ROOTS="$PART_ROOTS src tools/linguist/lrelease" ;;
    translations) PART_ROOTS="$PART_ROOTS translations" ;;
    examples) PART_ROOTS="$PART_ROOTS examples demos" ;;
    *) ;;
    esac
done

if [ "$CFG_DEV" = "yes" ]; then
    PART_ROOTS="$PART_ROOTS tests"
fi

echo "Creating makefiles. Please wait..."
for file in .projects .projects.3; do
    [ '!' -f "$file" ] && continue
    for a in `cat $file`; do
        IN_ROOT=no
	for r in $PART_ROOTS; do
	    if echo "$a" | grep "^$r" >/dev/null 2>&1 || echo "$a" | grep "^$relpath/$r" >/dev/null 2>&1; then
		IN_ROOT=yes
		break
            fi
	done
        [ "$IN_ROOT" = "no" ] && continue

        case $a in
        *winmain/winmain.pro)
            if [ "$CFG_NOPROCESS" = "yes" ] || [ "$XPLATFORM_MINGW" != "yes" ]; then
                continue
            fi
            SPEC=$XQMAKESPEC ;;
        *s60main/s60main.pro)
            if [ "$CFG_NOPROCESS" = "yes" ] || [ "$XPLATFORM_SYMBIAN" != "yes" ]; then
                continue
            fi;;
        *examples/activeqt/*) continue ;;
        */qmake/qmake.pro) continue ;;
        *tools/bootstrap*|*tools/moc*|*tools/rcc*|*tools/uic*|*linguist/lrelease*) SPEC=$QMAKESPEC ;;
        *) if [ "$CFG_NOPROCESS" = "yes" ]; then
              continue
           else
              SPEC=$XQMAKESPEC
           fi;;
        esac
        dir=`dirname "$a" | sed -e "s;$sepath;.;g"`
        test -d "$dir" || mkdir -p "$dir"
        OUTDIR="$outpath/$dir"
        if [ -f "${OUTDIR}/Makefile" ] && [ "$OPT_FAST" = "yes" ]; then
            # fast configure - the makefile exists, skip it
            # since the makefile exists, it was generated by qmake, which means we
            # can skip it, since qmake has a rule to regenerate the makefile if the .pro
            # file changes...
            [ "$OPT_VERBOSE" = "yes" ] && echo "  skipping $a"
            continue;
        fi
        QMAKE_SPEC_ARGS="-spec $SPEC"
        echo $ECHO_N "  for $a$ECHO_C"

        QMAKE="$outpath/bin/qmake"
	QMAKE_ARGS="$QMAKE_SWITCHES $QMAKE_SPEC_ARGS"
        if [ "$file" = ".projects.3" ]; then
            echo " (fast)"

            cat >"${OUTDIR}/Makefile" <<EOF
# ${OUTDIR}/Makefile: generated by configure
#
# WARNING: This makefile will be replaced with a real makefile.
# All changes made to this file will be lost.
EOF
            [ "$CFG_DEBUG_RELEASE" = "no" ] && echo "first_target: first" >>${OUTDIR}/Makefile

            cat >>"${OUTDIR}/Makefile" <<EOF
QMAKE = "$QMAKE"
all clean install qmake first Makefile: FORCE
	\$(QMAKE) $QMAKE_ARGS -o "$OUTDIR" "$a"
	cd "$OUTDIR"
	\$(MAKE) \$@

FORCE:

EOF
        else
            if [ "$OPT_VERBOSE" = "yes" ]; then
                echo " (`basename $SPEC`)"
                echo "$QMAKE" $QMAKE_ARGS -o "$OUTDIR" "$a"
	    else
		echo
            fi

            [ -f "${OUTDIR}/Makefile" ] && chmod +w "${OUTDIR}/Makefile"
            QTDIR="$outpath" "$QMAKE" $QMAKE_ARGS -o "$OUTDIR" "$a"
       fi
    done
done
rm -f .projects .projects.3

#-------------------------------------------------------------------------------
# check for platforms that we don't yet know about
#-------------------------------------------------------------------------------
if [ "$CFG_ARCH" = "generic" ]; then
cat <<EOF

        NOTICE: Atomic operations are not yet supported for this
        architecture.

        Qt will use the 'generic' architecture instead, which uses a
        single pthread_mutex_t to protect all atomic operations. This
        implementation is the slow (but safe) fallback implementation
        for architectures Qt does not yet support.
EOF
fi

#-------------------------------------------------------------------------------
# check if the user passed the -no-zlib option, which is no longer supported
#-------------------------------------------------------------------------------
if [ -n "$ZLIB_FORCED" ]; then
    which_zlib="supplied"
    if [ "$CFG_ZLIB" = "system" ]; then
	which_zlib="system"
    fi

cat <<EOF

        NOTICE: The -no-zlib option was supplied but is no longer
        supported.

        Qt now requires zlib support in all builds, so the -no-zlib
        option was ignored. Qt will be built using the $which_zlib
        zlib.
EOF
fi

#-------------------------------------------------------------------------------
# finally save the executed command to another script
#-------------------------------------------------------------------------------
if [ `basename $0` != "config.status" ]; then
    CONFIG_STATUS="$relpath/$relconf $OPT_CMDLINE"

    # add the system variables
    for varname in $SYSTEM_VARIABLES; do
        cmd=`echo \
'if [ -n "\$'${varname}'" ]; then
    CONFIG_STATUS="'${varname}'='"'\\\$${varname}'"' \$CONFIG_STATUS"
fi'`
	eval "$cmd"
    done

    echo "$CONFIG_STATUS" | grep '\-confirm\-license' >/dev/null 2>&1 || CONFIG_STATUS="$CONFIG_STATUS -confirm-license"

    [ -f "$outpath/config.status" ] && rm -f "$outpath/config.status"
    echo "#!/bin/sh" > "$outpath/config.status"
    echo "if [ \"\$#\" -gt 0 ]; then" >> "$outpath/config.status"
    echo "  $CONFIG_STATUS \"\$@\"" >> "$outpath/config.status"
    echo "else" >> "$outpath/config.status"
    echo "  $CONFIG_STATUS" >> "$outpath/config.status"
    echo "fi" >> "$outpath/config.status"
    chmod +x "$outpath/config.status"
fi

if [ -n "$RPATH_MESSAGE" ]; then
    echo
    echo "$RPATH_MESSAGE"
fi

MAKE=`basename "$MAKE"`
echo
echo Qt is now configured for building. Just run \'$MAKE\'.
if [ "$relpath" = "$QT_INSTALL_PREFIX" ]; then
    echo Once everything is built, Qt is installed.
    echo You should not run \'$MAKE install\'.
else
    echo Once everything is built, you must run \'$MAKE install\'.
    echo Qt will be installed into $QT_INSTALL_PREFIX
fi
echo
echo To reconfigure, run \'$MAKE confclean\' and \'configure\'.
echo
Gitorious
