qt5base-lts/configure

#!/bin/sh
#############################################################################
##
## Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
## Copyright (C) 2013 Intel Corporation.
## Contact: http://www.qt-project.org/legal
##
## This file is the build configuration utility of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:LGPL$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and Digia.  For licensing terms and
## conditions see http://qt.digia.com/licensing.  For further information
## use the contact form at http://qt.digia.com/contact-us.
##
## 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, Digia gives you certain additional
## rights.  These rights are described in the Digia Qt LGPL Exception
## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3.0 as published by the Free Software
## Foundation and appearing in the file LICENSE.GPL included in the
## packaging of this file.  Please review the following information to
## ensure the GNU General Public License version 3.0 requirements will be
## met: http://www.gnu.org/copyleft/gpl.html.
##
##
## $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`

# where to find which..
unixtests="$relpath/config.tests/unix"
mactests="$relpath/config.tests/mac"
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 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

# do this early so we don't store it in config.status
CFG_TOPLEVEL=
if [ x"$1" = x"-top-level" ]; then
    CFG_TOPLEVEL=yes
    shift
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
DEVICE_VARS_FILE=.device.vars

:> "$QMAKE_VARS_FILE"
:> "$DEVICE_VARS_FILE"

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

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

shellQuoteLines()
{
    # The call of the outer echo makes the shell word-split the output of
    # the nested pipe, thus effectively converting newlines to spaces.
    echo `echo "$1" | sed 's,^[^ ]* .*$,"&",'`
}

# 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"
}

shellArgumentListToQMakeListHelper()
{
    local retval
    for arg in "$@"; do retval="$retval \"$arg\""; done
    echo "$retval"
}

# Convert a string usable on a shell command line into word-by-word quoted
# qmake list.
shellArgumentListToQMakeList()
{
    # eval is needed for the shell to interpret the backslash escape sequences
    eval shellArgumentListToQMakeListHelper "$@"
}

# Helper function for getQMakeConf. It parses include statements in
# qmake.conf and prints out the expanded file
expandQMakeConf()
{
    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
            expandQMakeConf "$conf_file"
        ;;
        *load\(device_config\)*)
            conf_file="$DEVICE_VARS_FILE"
            if [ ! -f  "$conf_file" ]; then
                echo "WARNING: Unable to find file $conf_file" >&2
                continue
            fi
            expandQMakeConf "$conf_file"
        ;;
        *)
            echo "$line"
        ;;
    esac; done < "$1"
}

extractQMakeVariables()
{
    $AWK '
BEGIN {
    values["LITERAL_WHITESPACE"] = " "
    values["LITERAL_DOLLAR"] = "$"
}
/^!?host_build:/ {
    scopeStart = index($0, ":") + 1
    condition = substr($0, 0, scopeStart - 2)
    if (condition != "'"$1"'") { next }
    $0 = substr($0, scopeStart)
}
/^[_A-Z0-9.]+[ \t]*\+?=/ {
    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)

    ovalue = ""
    while (match(value, /\$\$(\{[_A-Z0-9.]+\}|[_A-Z0-9.]+)/)) {
        ovalue = ovalue substr(value, 1, RSTART - 1)
        var = substr(value, RSTART + 2, RLENGTH - 2)
        value = substr(value, RSTART + RLENGTH)
        if (var ~ /^\{/) {
            var = substr(var, 2, length(var) - 2)
        }
        ovalue = ovalue values[var]
    }
    value = ovalue value

    ovalue = ""
    while (match(value, /\$\$system\(("[^"]*"|[^)]*)\)/)) {
        ovalue = ovalue substr(value, 1, RSTART - 1)
        cmd = substr(value, RSTART + 9, RLENGTH - 10)
        gsub(/^"|"$/, "", cmd)
        value = substr(value, RSTART + RLENGTH)
        while ((cmd | getline line) > 0) {
            ovalue = ovalue line
        }
        close(cmd)
    }
    value = ovalue value

    combinedValue = values[variable]
    if (append == 1 && length(combinedValue) > 0) {
        combinedValue = combinedValue " " value
    } else {
        combinedValue = value
    }
    values[variable] = combinedValue
}
END {
    for (var in values) {
        print var "=" values[var]
    }
}
'
}

getSingleQMakeVariable()
{
    echo "$2" | $AWK "/^($1)=/ { print substr(\$0, index(\$0, \"=\") + 1) }"
}

macSDKify()
{
    # Normally we take care of sysrootifying in sdk.prf, but configure extracts some
    # values before qmake is even built, so we have to duplicate the logic here.

    sdk=$(getSingleQMakeVariable "QMAKE_MAC_SDK" "$1")
    if [ -z "$sdk" ]; then echo "QMAKE_MAC_SDK must be set when building on Mac" >&2; exit 1; fi
    sysroot=$(/usr/bin/xcodebuild -sdk $sdk -version Path 2>/dev/null)
    if [ -z "$sysroot" ]; then echo "Failed to resolve SDK path for '$sdk'" >&2; exit 1; fi

    case "$sdk" in
        macosx*)
            version_min_flag="-mmacosx-version-min=$(getSingleQMakeVariable QMAKE_MACOSX_DEPLOYMENT_TARGET "$1")"
        ;;
        iphoneos*)
            version_min_flag="-miphoneos-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
        ;;
        iphonesimulator*)
            version_min_flag="-mios-simulator-version-min=$(getSingleQMakeVariable QMAKE_IOS_DEPLOYMENT_TARGET "$1")"
        ;;
        *)
        ;;
    esac

    echo "$1" | while read line; do
        case "$line" in
            QMAKE_CC=*|QMAKE_CXX=*|QMAKE_FIX_RPATH=*|QMAKE_AR=*|QMAKE_RANLIB=*|QMAKE_LINK=*|QMAKE_LINK_SHLIB=*)
                # Prefix tool with toolchain path
                var=$(echo "$line" | cut -d '=' -f 1)
                val=$(echo "$line" | cut -d '=' -f 2-)
                sdk_val=$(/usr/bin/xcrun -sdk $sdk -find $(echo $val | cut -d ' ' -f 1))
                val=$(echo $sdk_val $(echo $val | cut -s -d ' ' -f 2-))
                echo "$var=$val"
            ;;
            QMAKE_CFLAGS=*|QMAKE_CXXFLAGS=*|QMAKE_OBJECTIVE_CFLAGS=*)
                echo "$line -isysroot $sysroot $version_min_flag"
            ;;
            QMAKE_LFLAGS=*)
                echo "$line -Wl,-syslibroot,$sysroot $version_min_flag"
            ;;
            *)
                echo "$line"
            ;;
        esac
    done
}

# relies on $QMAKESPEC being set correctly. parses include statements in
# qmake.conf and prints out the expanded file
getQMakeConf()
{
    if [ -z "$specvals" ]; then
        specvals=`expandQMakeConf "$QMAKESPEC/qmake.conf" | extractQMakeVariables "host_build"`
        if [ "$BUILD_ON_MAC" = "yes" ]; then specvals=$(macSDKify "$specvals"); fi
    fi
    getSingleQMakeVariable "$1" "$specvals"
}

getXQMakeConf()
{
    if [ -z "$xspecvals" ]; then
        xspecvals=`expandQMakeConf "$XQMAKESPEC/qmake.conf" | extractQMakeVariables "!host_build"`
        if [ "$XPLATFORM_MAC" = "yes" ]; then xspecvals=$(macSDKify "$xspecvals"); fi
    fi
    getSingleQMakeVariable "$1" "$xspecvals"
}

compilerSupportsFlag()
{
    cat >conftest.cpp <<EOF
int main() { return 0; }
EOF
    "$@" -o conftest-out.o conftest.cpp
    ret=$?
    rm -f conftest.cpp conftest-out.o
    return $ret
}

linkerSupportsFlag()
{
    compiler=$1
    shift
    lflags=-Wl
    for flag
    do
	safe_flag=`shellEscape "$flag"`
	lflags=$lflags,$safe_flag
    done
    compilerSupportsFlag $compiler $lflags >/dev/null 2>&1
}

# $1: newline-separated list of default paths
# stdin: input path
# stdout: input path or nothing
filterDefaultPaths()
{
    local path
    path=`cat`
    echo "$1" | grep "^$path\$" > /dev/null || echo "$path"
}

filterIncludePath()
{
    filterDefaultPaths "$DEFAULT_INCDIRS"
}

filterLibraryPath()
{
    filterDefaultPaths "$DEFAULT_LIBDIRS"
}

filterPathOptionsHelper()
{
    local flag defpaths sep p path
    flag=$1; shift
    defpaths=$1; shift
    sep=
    for p in "$@"; do
        path=${p#$flag}
        if [ "x$path" != "x$p" ]; then
            path=`echo "$path" | filterDefaultPaths "$defpaths"`
            test -z "$path" && continue
        fi
        # Re-quote for shell & qmake
        p=`echo "$p" | sed 's,[^ ]* .*,"&",g'`
        printf "%s%s" "$sep" "$p"
        sep=" "
    done
    echo
}

# $1: flag
# $2: newline-separated list of default paths
# stdin: list of command line options
# sdout: stdin without the options naming default paths
filterPathOptions()
{
    # The eval does escape interpretation for us
    eval filterPathOptionsHelper $1 "\"$2\"" "`cat`"
}

filterIncludeOptions()
{
    filterPathOptions -I "$DEFAULT_INCDIRS"
}

filterLibraryOptions()
{
    filterPathOptions -L "$DEFAULT_LIBDIRS"
}

substPrefix()
{
    base=${1#$QT_SYSROOT_PREFIX}
    if [ x"$base" != x"$1" ]; then
        echo "$QT_EXT_PREFIX$base"
    else
        echo "$1"
    fi
}

#-------------------------------------------------------------------------------
# device options
#-------------------------------------------------------------------------------
DeviceVar()
{
    case "$1" in
        set)
            eq="="
            ;;
        *)
            echo >&2 "BUG: wrong command to QMakeVar: $1"
            ;;
    esac

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

resolveDeviceMkspec()
{
    result=$(find "$relpath/mkspecs/devices/" -type d -name "*$1*" | sed "s,^$relpath/mkspecs/,,")
    match_count=$(echo "$result" | wc -w)
    if [ "$match_count" -gt 1 ]; then
        echo >&2 "Error: Multiple matches for device '$1'. Candidates are:"
        tabbed_result=$(echo "$result" | sed 's,^,    ,')
        echo >&2 "$tabbed_result"
        echo "undefined"
    elif [ "$match_count" -eq 0 ]; then
        echo >&2 "Error: No device matching '$1'"
        echo "undefined"
    else
        echo "$result"
    fi
}

#-------------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------------

BUILD_ON_MAC=no
if [ -d /System/Library/Frameworks/Carbon.framework ]; then
    BUILD_ON_MAC=yes
fi
BUILD_ON_MSYS=no
HOST_DIRLIST_SEP=":"
DEV_NULL=/dev/null
if [ "$OSTYPE" = "msys" ]; then
    HOST_DIRLIST_SEP=";"
    BUILD_ON_MSYS=yes
    DEV_NULL=/tmp/empty-file
    echo "" > $DEV_NULL
    relpath=`(cd "$relpath"; pwd -W)`
    outpath=`pwd -W`
fi

#-------------------------------------------------------------------------------
# Verify Xcode installation on Mac OS
#-------------------------------------------------------------------------------

if [ "$BUILD_ON_MAC" = "yes" ]; then
    if ! /usr/bin/xcode-select --print-path >/dev/null 2>&1; then
        echo >&2
        echo "   No Xcode is selected. Use xcode-select -switch to choose an Xcode" >&2
        echo "   version. See the xcode-select man page for more information." >&2
        echo >&2
        exit 2
    fi

    if ! /usr/bin/xcrun -find xcrun >/dev/null 2>&1; then
        echo >&2
        echo "   Xcode not set up properly. You may need to confirm the license" >&2
        echo "   agreement by running /usr/bin/xcodebuild without arguments." >&2
        echo >&2
        exit 2
    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

#-------------------------------------------------------------------------------
# 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 "mac fusion windows"

# 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=1.2

# initalize internal variables
CFG_CONFIGURE_EXIT_ON_ERROR=yes
CFG_PROFILE=no
CFG_STRIP=yes
CFG_GUI=auto # (yes|no|auto)
CFG_WIDGETS=yes
CFG_QCONFIG=full
CFG_DEBUG=auto
CFG_MYSQL_CONFIG=
CFG_DEBUG_RELEASE=no
CFG_FORCEDEBUGINFO=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_MTDEV=auto
CFG_JOURNALD=no
CFG_SQLITE=qt
CFG_GIF=auto
CFG_PNG=yes
CFG_LIBPNG=auto
CFG_JPEG=auto
CFG_LIBJPEG=auto
CFG_XCURSOR=runtime
CFG_XRANDR=runtime
CFG_XRENDER=auto
CFG_MITSHM=auto
CFG_OPENGL=auto
CFG_OPENVG=auto
CFG_OPENVG_LC_INCLUDES=no
CFG_OPENVG_SHIVA=auto
CFG_OPENVG_ON_OPENGL=auto
CFG_EGL=auto
CFG_EGL_X=auto
CFG_FONTCONFIG=auto
CFG_FREETYPE=auto
CFG_HARFBUZZ=auto
CFG_SQL_AVAILABLE=
QT_ALL_BUILD_PARTS=" libs tools examples tests "
QT_DEFAULT_BUILD_PARTS="libs tools examples"
CFG_BUILD_PARTS=""
CFG_NOBUILD_PARTS=""
CFG_SKIP_MODULES=""
CFG_COMPILE_EXAMPLES=yes
CFG_RELEASE_QMAKE=no
CFG_AUDIO_BACKEND=auto
CFG_QML_DEBUG=yes
CFG_PKGCONFIG=auto
CFG_STACK_PROTECTOR_STRONG=auto
CFG_SLOG2=auto
CFG_PPS=auto
CFG_QNX_IMF=auto
CFG_LGMON=auto
CFG_SYSTEM_PROXIES=no

# Target architecture
CFG_ARCH=
CFG_CPUFEATURES=
# Host architecture, same as CFG_ARCH when not cross-compiling
CFG_HOST_ARCH=
CFG_HOST_CPUFEATURES=
# Set when the -arch or -host-arch arguments are used
OPT_OBSOLETE_HOST_ARG=no

CFG_USE_GNUMAKE=no
CFG_XINPUT2=auto
CFG_XINPUT=runtime
CFG_XKB=auto
CFG_XKBCOMMON=auto
CFG_XKB_CONFIG_ROOT=auto
CFG_XCB=auto
CFG_XCB_XLIB=auto
CFG_XCB_GLX=no
CFG_EGLFS=auto
CFG_DIRECTFB=auto
CFG_LINUXFB=auto
CFG_KMS=auto
CFG_LIBUDEV=auto
CFG_OBSOLETE_WAYLAND=no
CFG_EVDEV=auto
CFG_TSLIB=no
CFG_NIS=auto
CFG_CUPS=auto
CFG_ICONV=auto
CFG_DBUS=auto
CFG_GLIB=auto
CFG_QGTKSTYLE=auto
CFG_LARGEFILE=auto
CFG_OPENSSL=auto
CFG_PRECOMPILE=auto
CFG_SEPARATE_DEBUG_INFO=no
CFG_REDUCE_EXPORTS=auto
CFG_SSE2=auto
CFG_SSE3=auto
CFG_SSSE3=auto
CFG_SSE4_1=auto
CFG_SSE4_2=auto
CFG_AVX=auto
CFG_AVX2=auto
CFG_REDUCE_RELOCATIONS=auto
CFG_ACCESSIBILITY=auto
CFG_ACCESSIBILITY_ATSPI_BRIDGE=no # will be enabled depending on dbus and accessibility being enabled
CFG_IWMMXT=no
CFG_NEON=auto
CFG_MIPS_DSP=auto
CFG_MIPS_DSPR2=auto
CFG_CLOCK_GETTIME=auto
CFG_CLOCK_MONOTONIC=auto
CFG_POSIX_FALLOCATE=auto
CFG_MREMAP=auto
CFG_GETADDRINFO=auto
CFG_IPV6IFNAME=auto
CFG_GETIFADDRS=auto
CFG_INOTIFY=auto
CFG_EVENTFD=auto
CFG_RPATH=yes
CFG_FRAMEWORK=auto
DEFINES=
INCLUDES=
D_FLAGS=
I_FLAGS=
L_FLAGS=
RPATH_FLAGS=
W_FLAGS=
QCONFIG_FLAGS=
XPLATFORM=              # This seems to be the QMAKESPEC, like "linux-g++"
XPLATFORM_MAC=no
XPLATFORM_IOS=no
XPLATFORM_ANDROID=no
XPLATFORM_MINGW=no      # Whether target platform is MinGW (win32-g++*)
XPLATFORM_MAEMO=no
XPLATFORM_QNX=no
PLATFORM=$QMAKESPEC
QT_CROSS_COMPILE=no
OPT_CONFIRM_LICENSE=no
OPT_SHADOW=maybe
OPT_VERBOSE=no
OPT_HELP=
CFG_SILENT=no
CFG_ALSA=auto
CFG_PULSEAUDIO=auto
CFG_COREWLAN=auto
CFG_PROCESS=yes
CFG_ICU=auto
CFG_FORCE_ASSERTS=no
CFG_PCRE=auto
QPA_PLATFORM_GUARD=yes
CFG_CXX11=auto
CFG_DIRECTWRITE=no
CFG_WERROR=auto
CFG_QREAL=double
OPT_MAC_SDK=
COMMERCIAL_USER=ask
LICENSE_FILE=
CFG_DEV=no

# initalize variables used for installation
QT_INSTALL_PREFIX=
QT_INSTALL_DOCS=
QT_INSTALL_HEADERS=
QT_INSTALL_LIBS=
QT_INSTALL_BINS=
QT_INSTALL_LIBEXECS=
QT_INSTALL_PLUGINS=
QT_INSTALL_IMPORTS=
QT_INSTALL_QML=
QT_INSTALL_ARCHDATA=
QT_INSTALL_DATA=
QT_INSTALL_TRANSLATIONS=
QT_INSTALL_SETTINGS=
QT_INSTALL_EXAMPLES=
QT_INSTALL_TESTS=
CFG_SYSROOT=
CFG_GCC_SYSROOT="yes"
QT_HOST_PREFIX=
QT_HOST_BINS=
QT_HOST_LIBS=
QT_HOST_DATA=
QT_EXT_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=

# default qpa platform
QT_QPA_DEFAULT_PLATFORM=

# Android vars
CFG_DEFAULT_ANDROID_NDK_ROOT=$ANDROID_NDK_ROOT
CFG_DEFAULT_ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT
CFG_DEFAULT_ANDROID_PLATFORM=android-9
CFG_DEFAULT_ANDROID_TARGET_ARCH=armeabi-v7a
CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION=4.8
CFG_DEFAULT_ANDROID_NDK_HOST=$ANDROID_NDK_HOST

#-------------------------------------------------------------------------------
# check SQL drivers 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_IMAGEFORMAT_PLUGIN_AVAILABLE=
if [ -d "$relpath/src/plugins/imageformats" ]; then
    for a in "$relpath/src/plugins/imageformats/"*; do
        if [ -d "$a" ]; then
            base_a=`basename "$a"`
            CFG_IMAGEFORMAT_PLUGIN_AVAILABLE="${CFG_IMAGEFORMAT_PLUGIN_AVAILABLE} ${base_a}"
        fi
    done
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,'`
        ;;
    #Qt style no options
    -no-*)
        VAR=`echo $1 | sed 's,^-no-\(.*\),\1,'`
        VAL=no
        ;;
    #Qt style options that pass an argument
    -prefix| \
    -docdir| \
    -headerdir| \
    -plugindir| \
    -importdir| \
    -qmldir| \
    -archdatadir| \
    -datadir| \
    -libdir| \
    -bindir| \
    -libexecdir| \
    -translationdir| \
    -sysconfdir| \
    -examplesdir| \
    -testsdir| \
    -hostdatadir| \
    -hostbindir| \
    -hostlibdir| \
    -extprefix| \
    -sysroot| \
    -depths| \
    -make| \
    -nomake| \
    -skip| \
    -platform| \
    -xplatform| \
    -device| \
    -device-option| \
    -sdk| \
    -arch| \
    -host-arch| \
    -mysql_config| \
    -qpa| \
    -qconfig| \
    -qreal| \
    -xkb-config-root| \
    -android-sdk| \
    -android-ndk| \
    -android-ndk-platform| \
    -android-ndk-host| \
    -android-arch| \
    -android-toolchain-version)
        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,'`
        ;;
    -system-proxies)
        VAR=system-proxies
        VAL=yes
        ;;
    -no-system-proxies)
        VAR=system-proxies
        VAL=no
        ;;
    #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
        ;;
    -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
        ;;
    -qtnamespace)
        VAR="qtnamespace"
        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)  # -lfoo is handled differently
        VAR="add_link"
        shift
        VAL="$1"
        ;;
    -F?*|-F)
        VAR="add_fpath"
        if [ "$1" = "-F" ]; then
            shift
            VAL="$1"
        else
            VAL=`echo $1 | sed 's,-F,,'`
        fi
        ;;
    -fw)  # -fwfoo is handled differently
        VAR="add_framework"
        shift
        VAL="$1"
        ;;
    -W*)
        VAR="add_warn"
        VAL="$1"
        ;;
    #General options, including Qt style yes options
    -*)
        VAR=`echo $1 | sed 's,^-\(.*\),\1,'`
        VAL="yes"
        ;;
    *)
        UNKNOWN_ARG=yes
        ;;
    esac
    if [ "$UNKNOWN_ARG" = "yes" ]; then
        echo "$1: unknown argument"
        ERROR=yes
        shift
        continue
     fi
    shift

    UNKNOWN_OPT=no
    case "$VAR" in
    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"
	;;
    hostdatadir)
        QT_HOST_DATA="$VAL"
        ;;
    hostbindir)
        QT_HOST_BINS="$VAL"
        ;;
    hostlibdir)
        QT_HOST_LIBS="$VAL"
        ;;
    extprefix)
        QT_EXT_PREFIX="$VAL"
        ;;
    pkg-config)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PKGCONFIG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    force-pkg-config)
        CFG_PKGCONFIG="force"
        ;;
    docdir)
        QT_INSTALL_DOCS="$VAL"
        ;;
    headerdir)
        QT_INSTALL_HEADERS="$VAL"
        ;;
    plugindir)
        QT_INSTALL_PLUGINS="$VAL"
        ;;
    importdir)
        QT_INSTALL_IMPORTS="$VAL"
        ;;
    qmldir)
        QT_INSTALL_QML="$VAL"
        ;;
    archdatadir)
        QT_INSTALL_ARCHDATA="$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"
        ;;
    testsdir)
        QT_INSTALL_TESTS="$VAL"
        ;;
    qconfig)
        CFG_QCONFIG="$VAL"
        ;;
    qreal)
        CFG_QREAL="$VAL"
        ;;
    sysroot)
        CFG_SYSROOT="$VAL"
        ;;
    gcc-sysroot)
        CFG_GCC_SYSROOT="$VAL"
        ;;
    bindir)
        QT_INSTALL_BINS="$VAL"
        ;;
    libexecdir)
        QT_INSTALL_LIBEXECS="$VAL"
        ;;
    opengl)
        if  [ "$VAL" = "auto" ] || [ "$VAL" = "desktop" ] ||
            [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] ||
            [ "$VAL" = "es2" ]; then
            CFG_OPENGL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    openvg)
        if [ "$VAL" = "auto" ] || [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_OPENVG="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    nomake)
        if [ -n "${QT_ALL_BUILD_PARTS%%* $VAL *}" ]; then
            echo "Unknown part $VAL passed to -nomake." >&2
            exit 1
        fi
	CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS $VAL"
        ;;
    make)
        if [ "$VAL" = "no" ]; then
            UNKNOWN_OPT=yes
        else
            if [ -n "${QT_ALL_BUILD_PARTS%%* $VAL *}" ]; then
                echo "Unknown part $VAL passed to -make." >&2
                exit 1
            fi
            CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
        fi
        ;;
    skip)
        VAL=qt${VAL#qt}
        if ! [ -d $relpath/../$VAL ]; then
            echo "Attempting to skip non-existent module $VAL." >&2
            exit 1
        fi
        CFG_SKIP_MODULES="$CFG_SKIP_MODULES $VAL"
        ;;
    compile-examples)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_COMPILE_EXAMPLES="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    sdk)
        if [ "$BUILD_ON_MAC" = "yes" ]; then
            DeviceVar set !host_build:QMAKE_MAC_SDK "$VAL"
            OPT_MAC_SDK="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
	;;
    arch|host-arch)
        OPT_OBSOLETE_HOST_ARG=yes
        ;;
    harfbuzz)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_HARFBUZZ="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;

    framework)
        if [ "$BUILD_ON_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
        ;;
    strip)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_STRIP=$VAL
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    testcocoon)
        if [ "$VAL" = "yes" ]; then
            QTCONFIG_CONFIG="$QTCONFIG_CONFIG testcocoon"
        fi
        ;;
    gcov)
        if [ "$VAL" = "yes" ]; then
            QTCONFIG_CONFIG="$QTCONFIG_CONFIG gcov"
        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"
            fi
            ;;
        esac
        ;;
    xplatform)
        XPLATFORM="$VAL"
        case `basename "$XPLATFORM"` in win32-g++*)
            XPLATFORM_MINGW=yes
            CFG_RPATH=no
            CFG_REDUCE_EXPORTS=no
            ;;
        esac
        ;;
    device)
        XPLATFORM=`resolveDeviceMkspec $VAL`
        [ "$XPLATFORM" = "undefined" ] && exit 101
        ;;
    device-option)
        DEV_VAR=`echo $VAL | cut -d '=' -f 1`
        DEV_VAL=`echo $VAL | cut -d '=' -f 2-`
        DeviceVar set $DEV_VAR "$DEV_VAL"
        ;;
    qpa)
        QT_QPA_DEFAULT_PLATFORM="$VAL"
        ;;
    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
        ;;
    debug)
        CFG_DEBUG="$VAL"
        ;;
    force-debug-info)
        CFG_FORCEDEBUGINFO="$VAL"
        ;;
    developer-build)
        CFG_DEV="yes"
        ;;
    commercial)
        COMMERCIAL_USER="yes"
        ;;
    opensource)
        COMMERCIAL_USER="no"
        ;;
    static)
        if [ "$VAL" = "yes" ]; then
            CFG_SHARED=no
        elif [ "$VAL" = "no" ]; then
            CFG_SHARED=yes
        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
        ;;
     xinput2)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XINPUT2="$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"
            CFG_EGL_X="$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"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    reduce-exports)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_REDUCE_EXPORTS="$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
        ;;
    avx2)
        if [ "$VAL" = "no" ]; then
            CFG_AVX2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    iwmmxt)
	CFG_IWMMXT="yes"
	;;
    mips_dsp)
        if [ "$VAL" = "no" ]; then
            CFG_MIPS_DSP="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    mips_dspr2)
        if [ "$VAL" = "no" ]; then
            CFG_MIPS_DSPR2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    reduce-relocations)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_REDUCE_RELOCATIONS="$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
        ;;
    mtdev)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_MTDEV="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    journald)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_JOURNALD="$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
        ;;
    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
        ;;
    freetype)
        [ "$VAL" = "yes" ] && VAL=qt
        if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
            CFG_FREETYPE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xkb)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XKB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xkbcommon)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "qt" ] || [ "$VAL" = "system" ]; then
            CFG_XKBCOMMON="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xcb)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ] || [ "$VAL" = "qt" ]; then
            CFG_XCB="$VAL"
            if [ "$VAL" = "yes" ]; then
                CFG_XCB="system"
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xcb-xlib)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_XCB_XLIB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    wayland)
        CFG_OBSOLETE_WAYLAND=yes
        ;;
    eglfs)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_EGLFS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    directfb)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_DIRECTFB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    linuxfb)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_LINUXFB="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    kms)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_KMS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    libudev)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_LIBUDEV="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    evdev)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_EVDEV="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    tslib)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_TSLIB="$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
        ;;
    slog2)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SLOG2="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    imf)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_QNX_IMF="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    pps)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PPS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    lgmon)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_LGMON="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    pulseaudio)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_PULSEAUDIO="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    alsa)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ALSA="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gtkstyle)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_QGTKSTYLE="$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
        ;;
    widgets)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ]; then
            CFG_WIDGETS="yes"
        elif [ "$VAL" = "no" ]; then
            CFG_WIDGETS="no"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    qpa-platform-guard)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            QPA_PLATFORM_GUARD="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    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
        ;;
    qml-debug)
        if [ "$VAL" = "yes" ]; then
            CFG_QML_DEBUG="yes"
        else
            if [ "$VAL" = "no" ]; then
                CFG_QML_DEBUG="no"
            else
                UNKNOWN_OPT=yes
            fi
        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-*|imageformat-*)
        # 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"
            ;;
        imageformat)
            avail="$CFG_IMAGEFORMAT_PLUGIN_AVAILABLE"
            if [ "$OPT" != "plugin" ]; then
                # png is always built in
                avail="$avail png"
            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
        if [ "$found" != "yes" ]; then
            echo "$CURRENT_OPT: unknown argument"
            ERROR=yes
            continue
        fi

        if [ "$VAR" = "sql" ]; then
            # set the CFG_SQL_driver
            eval "CFG_SQL_$VAL=\$OPT"
            continue
        elif [ "$VAR" = "imageformat" ]; then
            [ "$OPT" = "qt" ] && OPT=yes
            VAL="`echo $VAL |tr a-z A-Z`"
            eval "CFG_$VAL=$OPT"
            continue
        fi

        if [ "$OPT" = "plugin" ] || [ "$OPT" = "qt" ]; then
            if [ "$OPT" = "plugin" ]; then
                VAR="${VAR}-${OPT}"
            fi
	    QMakeVar add "${VAR}s" "${VAL}"
        elif [ "$OPT" = "no" ]; then
            PLUG_VAR="${VAR}-plugin"
            IN_VAR="${VAR}"
	    QMakeVar del "${IN_VAR}s" "$VAL"
	    QMakeVar del "${PLUG_VAR}s" "$VAL"
        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
        ;;
    rpath)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_RPATH="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    add_define)
        DEFINES="$DEFINES \"$VAL\""
        D_FLAGS="$D_FLAGS -D\"$VAL\""
        ;;
    add_ipath)
        INCLUDES="$INCLUDES \"$VAL\""
        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 [ "$BUILD_ON_MAC" = "yes" ]; then
            L_FLAGS="$L_FLAGS -F\"${VAL}\""
            I_FLAGS="$I_FLAGS -F\"${VAL}\""
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    add_framework)
        if [ "$BUILD_ON_MAC" = "yes" ]; then
            L_FLAGS="$L_FLAGS -framework \"${VAL}\""
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    add_warn)
        W_FLAGS="$W_FLAGS \"${VAL}\""
        ;;
    silent)
        CFG_SILENT="$VAL"
        ;;
    dont-process)
        CFG_PROCESS=no
        ;;
    process)
        CFG_PROCESS=partial
        ;;
    fully-process)
        CFG_PROCESS=full
        ;;
    audio-backend)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_AUDIO_BACKEND="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    icu)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ICU="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    force-asserts)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_FORCE_ASSERTS="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    pcre)
        if [ "$VAL" = "qt" ] || [ "$VAL" = "system" ]; then
            CFG_PCRE="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    c++11)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_CXX11="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    system-proxies)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_SYSTEM_PROXIES="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    directwrite)
        if [ "$XPLATFORM_MINGW" = "yes" ] ; then
            if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
                CFG_DIRECTWRITE="$VAL"
            else
                UNKNOWN_OPT=yes
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    warnings-are-errors|Werror)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_WERROR="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    xkb-config-root)
        CFG_XKB_CONFIG_ROOT="$VAL"
        ;;
    android-sdk)
        CFG_DEFAULT_ANDROID_SDK_ROOT="$VAL"
        ;;
    android-ndk)
        CFG_DEFAULT_ANDROID_NDK_ROOT="$VAL"
        ;;
    android-ndk-platform)
        CFG_DEFAULT_ANDROID_PLATFORM="$VAL"
        ;;
    android-ndk-host)
        CFG_DEFAULT_ANDROID_NDK_HOST="$VAL"
        ;;
    android-arch)
        CFG_DEFAULT_ANDROID_TARGET_ARCH="$VAL"
        ;;
    android-toolchain-version)
        CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION="$VAL"
        ;;
    l*)  # -lfoo
        if [ "$VAL" = "yes" ]; then
            L_FLAGS="$L_FLAGS -l\"${VAR#l}\""
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    fw*)  # -fwfoo
        if [ "$VAL" = "yes" ]; then
            if [ "$BUILD_ON_MAC" = "yes" ]; then
                L_FLAGS="$L_FLAGS -framework \"${VAR#fw}\""
            else
                UNKNOWN_OPT=yes
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    *)
        UNKNOWN_OPT=yes
        ;;
    esac
    if [ "$UNKNOWN_OPT" = "yes" ]; then
        echo "${CURRENT_OPT}: invalid command-line switch"
        ERROR=yes
    fi
done
[ "x$ERROR" = "xyes" ] && exit 1

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

if [ "$OPT_HELP" = "yes" ]; then
    cat <<EOF
Usage:  $relconf [options]

Installation options:

 These are optional, but you may specify install directories.

    -prefix <dir> ...... This will install everything relative to <dir>
                         (default /usr/local/Qt-${QT_VERSION}, \$PWD if -developer-build is active)

    -extprefix <dir> ... When -sysroot is used, install everything to <dir>,
                         rather than into SYSROOT/PREFIX.

    -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.
                         (default EXTPREFIX)

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

    -bindir <dir> ......... User executables will be installed to <dir>
                            (default PREFIX/bin)
    -headerdir <dir> ...... Headers will be installed to <dir>
                            (default PREFIX/include)
    -libdir <dir> ......... Libraries will be installed to <dir>
                            (default PREFIX/lib)
    -archdatadir <dir> .... Arch-dependent data used by Qt will be installed to <dir>
                            (default PREFIX)
    -plugindir <dir> ...... Plugins will be installed to <dir>
                            (default ARCHDATADIR/plugins)
    -libexecdir <dir> ..... Program executables will be installed to <dir>
                            (default ARCHDATADIR/libexec, ARCHDATADIR/bin for MinGW)
    -importdir <dir> ...... Imports for QML1 will be installed to <dir>
                            (default ARCHDATADIR/imports)
    -qmldir <dir> ......... Imports for QML2 will be installed to <dir>
                            (default ARCHDATADIR/qml)
    -datadir <dir> ........ Arch-independent data used by Qt will be installed to <dir>
                            (default PREFIX)
    -docdir <dir> ......... Documentation will be installed to <dir>
                            (default DATADIR/doc)
    -translationdir <dir> . Translations of Qt programs will be installed to <dir>
                            (default DATADIR/translations)
    -sysconfdir <dir> ..... Settings used by Qt programs will be looked for in <dir>
                            (default PREFIX/etc/xdg)
    -examplesdir <dir> .... Examples will be installed to <dir>
                            (default PREFIX/examples)
    -testsdir <dir> ....... Tests will be installed to <dir>
                            (default PREFIX/tests)

    -hostbindir <dir> .. Host executables will be installed to <dir>
                         (default HOSTPREFIX/bin)
    -hostlibdir <dir> .. Host libraries will be installed to <dir>
                         (default HOSTPREFIX/lib)
    -hostdatadir <dir> . Data used by qmake will be installed to <dir>
                         (default HOSTPREFIX)

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).

    -force-debug-info .. Create symbol files for release builds.

    -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.

    -confirm-license ... Automatically acknowledge the license (use with
                         either -opensource or -commercial)

    -no-c++11 .......... Do not compile Qt with C++11 support enabled.
 +  -c++11 ............. Compile Qt with C++11 support enabled.

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

 *  -process ........... Generate only a top-level Makefile.
    -fully-process ..... Generate Makefiles for the entire Qt tree.
    -dont-process ...... Do not generate any Makefiles.

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

    -no-accessibility .. Do not compile Accessibility support.
                         Disabling accessibility is not recommended, as it will break QStyle
                         and may break other internal parts of Qt.
                         With this switch you create a source incompatible version of Qt,
                         which is unsupported.
 +  -accessibility ..... Compile Accessibility support.

    -no-sql-<driver> ... Disable SQL <driver> entirely.
    -qt-sql-<driver> ... Enable a SQL <driver> in the Qt SQL module, 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-qml-debug ...... Do not build the in-process QML debugging support.
 +  -qml-debug ......... Build the QML debugging support.

    -platform target ... The operating system and compiler you are building
                         on (default detected from host system).

                         See the README file for a list of supported
                         operating systems and compilers.

    -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-avx2 ........... Do not compile with use of AVX2 instructions.
    -no-mips_dsp ....... Do not compile with use of MIPS DSP instructions.
    -no-mips_dspr2 ..... Do not compile with use of MIPS DSP rev2 instructions.

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

    -testcocoon ........ Instrument Qt with the TestCocoon code coverage tool.
    -gcov .............. Instrument Qt with the GCov code coverage tool.

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

 +  -pkg-config ........ Use pkg-config to detect include and library paths. By default,
                         configure determines whether to use pkg-config or not with
                         some heuristics such as checking the environment variables.
    -no-pkg-config ..... Disable use of pkg-config.
    -force-pkg-config .. Force usage of pkg-config (skips pkg-config usability
                         detection heuristic).

    -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-mtdev .........  Do not compile mtdev support.
 +  -mtdev ............. Enable mtdev support.

 +  -no-journald ....... Do not send logging output to journald.
    -journald .......... Send logging output to journald.

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

    -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-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-freetype ....... Do not compile in Freetype2 support.
    -qt-freetype ....... Use the libfreetype bundled with Qt.
 +  -system-freetype.... Use the libfreetype provided by the system (enabled if -fontconfig is active).
                         See http://www.freetype.org

 *  -no-harfbuzz ....... Do not compile HarfBuzz-NG support.
    -qt-harfbuzz ....... (experimental) Use HarfBuzz-NG bundled with Qt
                         to do text shaping. It can still be disabled
                         by setting QT_HARFBUZZ environment variable to "old".
    -system-harfbuzz ... (experimental) Use HarfBuzz-NG from the operating system
                         to do text shaping. It can still be disabled
                         by setting QT_HARFBUZZ environment variable to "old".

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

    -qt-pcre ........... Use the PCRE library bundled with Qt.
 +  -system-pcre ....... Use the PCRE library from the operating system.

    -qt-xcb ............ Use xcb- libraries bundled with Qt.
                         (libxcb.so will still be used from operating system).
 +  -system-xcb ........ Use xcb- libraries from the operating system.

    -xkb-config-root ... Set default XKB config root. This option is used only together with -qt-xkbcommon.
    -qt-xkbcommon ...... Use the xkbcommon library bundled with Qt.
 +  -system-xkbcommon .. Use the xkbcommon library from the operating system.

    -no-xinput2 ........ Do not compile XInput2 support.
 *  -xinput2 ........... Compile XInput2 support.

    -no-xcb-xlib........ Do not compile Xcb-Xlib support.
 *  -xcb-xlib........... Compile Xcb-Xlib support.

    -no-glib ........... Do not compile Glib support.
 +  -glib .............. Compile Glib support.

    -no-pulseaudio ..... Do not compile PulseAudio support.
 +  -pulseaudio ........ Compile PulseAudio support.

    -no-alsa ........... Do not compile ALSA support.
 +  -alsa .............. Compile ALSA support.

    -no-gtkstyle ....... Do not compile GTK theme support.
 +  -gtkstyle .......... Compile GTK theme support.

Additional options:

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

    -skip <module> ..... Exclude an entire module from the build.

    -no-compile-examples ... Install only the sources of examples.

    -no-gui ............ Don't build the Qt GUI module and dependencies.
 +  -gui ............... Build the Qt GUI module and dependencies.

    -no-widgets ........ Don't build the Qt Widgets module and dependencies.
 +  -widgets ........... Build the Qt Widgets module and dependencies.

    -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-nis ............ Do not compile NIS support.
 *  -nis ............... Compile NIS support.

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

    -no-iconv .......... Do not compile support for iconv(3).
 *  -iconv ............. Compile support for iconv(3).

    -no-evdev .......... Do not compile support for evdev.
 *  -evdev ............. Compile support for evdev.

    -no-icu ............ Do not compile support for ICU libraries.
 +  -icu ............... Compile support for ICU libraries.

    -no-fontconfig ..... Do not compile FontConfig support.
 +  -fontconfig ........ Compile FontConfig support.

    -no-strip .......... Do not strip binaries and libraries of unneeded symbols.
 *  -strip ............. Strip binaries and libraries of unneeded symbols when installing.

 *  -no-pch ............ Do not use precompiled header support.
    -pch ............... Use precompiled header support.

    -no-dbus ........... Do not compile the Qt D-Bus module.
 +  -dbus .............. Compile the Qt D-Bus module and dynamically load libdbus-1.
    -dbus-linked ....... Compile the Qt D-Bus 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).

    -force-asserts ........ Force Q_ASSERT to be enabled even in release builds.

    -device <name> ............... Cross-compile for device <name> (experimental)
    -device-option <key=value> ... Add device specific options for the device mkspec
                                   (experimental)

    -no-separate-debug-info . Do not store debug information in a separate file.
 *  -separate-debug-info .... Strip debug information into a separate file.

    -no-xcb ............ Do not compile Xcb (X protocol C-language Binding) support.
 *  -xcb ............... Compile Xcb support.

    -no-eglfs .......... Do not compile EGLFS (EGL Full Screen/Single Surface) support.
 *  -eglfs ............. Compile EGLFS support.

    -no-directfb ....... Do not compile DirectFB support.
 *  -directfb .......... Compile DirectFB support.

    -no-linuxfb ........ Do not compile Linux Framebuffer support.
 *  -linuxfb ........... Compile Linux Framebuffer support.

    -no-kms ............ Do not compile KMS support.
 *  -kms ............... Compile KMS support (Requires EGL).

    -qpa <name> ......... Sets the default QPA platform (e.g xcb, cocoa, windows).

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

    -sysroot <dir> ...... Sets <dir> as the target compiler's and qmake's sysroot and also sets pkg-config paths.
    -no-gcc-sysroot ..... When using -sysroot, it disables the passing of --sysroot to the compiler

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

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

    -qreal [double|float] typedef qreal to the specified type. The default is double.
                          Note that changing this flag affects binary compatibility.

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

 *  -no-system-proxies .. Do not use system network proxies by default.
    -system-proxies ..... Use system network proxies by default.

    -no-warnings-are-errors Make warnings be treated normally
    -warnings-are-errors  Make warnings be treated as errors
                          (enabled if -developer-build is active)

QNX/Blackberry options:

    -no-slog2 .......... Do not compile with slog2 support.
    -slog2 ............. Compile with slog2 support.

    -no-pps ............ Do not compile with pps support.
    -pps ............... Compile with pps support.

    -no-imf ............ Do not compile with imf support.
    -imf ............... Compile with imf support.

    -no-lgmon .......... Do not compile with lgmon support.
    -lgmon ............. Compile with lgmon support.

MacOS/iOS options:

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

 *  -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.

    -sdk <sdk> ......... Build Qt using Apple provided SDK <sdk>. The argument should be
                         one of the available SDKs as listed by 'xcodebuild -showsdks'.
                         Note that the argument applies only to Qt libraries and applications built
                         using the target mkspec - not host tools such as qmake, moc, rcc, etc.

Android options:

    -android-sdk path .............. The Android SDK root path.
                                     (default \$ANDROID_SDK_ROOT)

    -android-ndk path .............. The Android NDK root path.
                                     (default \$ANDROID_NDK_ROOT)

    -android-ndk-platform .......... Sets the android platform
                                     (default $CFG_DEFAULT_ANDROID_PLATFORM)

    -android-ndk-host .............. Sets the android NDK host (linux-x86, linux-x86_64, etc.)
                                     (default \$ANDROID_NDK_HOST)

    -android-arch .................. Sets the android architecture (armeabi, armeabi-v7a, x86, mips)
                                     (default $CFG_DEFAULT_ANDROID_TARGET_ARCH)

    -android-toolchain-version ..... Sets the android toolchain version
                                     (default $CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION)
EOF

   exit 0
fi # Help

#-------------------------------------------------------------------------------
# platform detection
#-------------------------------------------------------------------------------

if [ -z "$PLATFORM" ]; then
    PLATFORM_NOTES=
    case "$UNAME_SYSTEM:$UNAME_RELEASE" in
     Darwin:*)
        # Select compiler. Use g++ unless we find a usable Clang version. Note that
        # we are checking the "Apple" clang/LLVM version number, not the actual
        # clang/LLVM version number that the Apple version was based on. We look
        # for Apple clang version 3.0 or higher, which was branched off LLVM 3.0
        # from SVN, and first included in Xcode 4.2. Also note that we do not care
        # about the OS version, since we're not using the clang version that comes
        # with the system. We use 'xcrun' to check the clang version that's part of
        # the Xcode installation.
        XCRUN=`/usr/bin/xcrun -sdk macosx clang -v 2>&1`
        CLANGVERSION=`echo "$XCRUN" | sed -n 's/.*version \([0-9]\).*/\1/p'`
        expr "$CLANGVERSION" : '[0-9]' > /dev/null || { echo "Unable to determine CLANG version from output of xcrun: $XCRUN" ; exit 2 ; }
        if [ "$CLANGVERSION" -ge 3 ]; then
            PLATFORM=macx-clang

            # Advertise g++ as an alternative on Lion and below
            if [ "$(uname -r | cut -d. -f1)" -le 11 ]; then
                PLATFORM_NOTES="\n    - Also available for Mac OS X: macx-g++\n"
            fi
        else
            PLATFORM=macx-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:*)
        PLATFORM=linux-g++
        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++
        ;;
     *)
            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
    esac
fi

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

case "$XPLATFORM" in
    *win32-g++*)
        XPLATFORM_MINGW=yes
        ;;
    *-maemo*)
        XPLATFORM_MAEMO=yes
        ;;
    *qnx-*|*blackberry-*)
        XPLATFORM_QNX=yes
        ;;
    *ios*)
        XPLATFORM_MAC=yes
        XPLATFORM_IOS=yes
        ;;
    *macx*)
        XPLATFORM_MAC=yes
        ;;
    # XPLATFORM_ANDROID should not be set for unsupported/android-g++
    *unsupported*)
        ;;
    *android-g++*)
        XPLATFORM_ANDROID=yes
        ;;
esac

#-------------------------------------------------------------------------------
# check the license
#-------------------------------------------------------------------------------

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 [ -f "$relpath"/LICENSE.PREVIEW.COMMERCIAL ] && [ $COMMERCIAL_USER = "yes" ]; then
    # Commercial preview release
    Licensee="Preview"
    Edition="Preview"
    EditionString="Technology Preview"
elif [ $COMMERCIAL_USER = "yes" ]; then
    if test -x "$relpath/bin/licheck"; then
        LicheckOutput=`$relpath/bin/licheck $OPT_CONFIRM_LICENSE $relpath $outpath\
                       $PLATFORM $XPLATFORM`
        if [ $? -ne 0 ]; then
            exit 1
        else
            eval "$LicheckOutput"
        fi
    else
        echo
        echo "Error: This is the Open Source version of Qt."
        echo "If you want to use Enterprise features of Qt,"
        echo "use the contact form at http://qt.digia.com/contact-us"
        echo "to purchase a license."
        echo
        exit 1
    fi
elif [ $COMMERCIAL_USER = "no" ]; then
    # Open Source edition - may only be used under the terms of the GPL or LGPL.
    Licensee="Open Source"
    Edition="OpenSource"
    EditionString="Open Source"
fi

if [ "$Edition" = "OpenSource" ] || [ "$Edition" = "Preview" ]; then
    echo
    echo "This is the Qt ${EditionString} Edition."
    echo
fi

if [ "$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.GPL" ]; 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 $EditionString license."
            acceptance=yes
        else
            if [ -f "$relpath/LICENSE.GPL" ]; 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.GPL"
        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 $EditionString 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
fi

#-------------------------------------------------------------------------------
# command line and environment validation
#-------------------------------------------------------------------------------

# update QT_CONFIG to show our current predefined configuration
CFG_QCONFIG_PATH=$relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h
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
    [ "$CFG_QCONFIG" = full ] && CFG_QCONFIG_PATH=
    ;;
*)
    # not known to be sufficient for anything
    if [ ! -f "$CFG_QCONFIG_PATH" ]; then
        CFG_QCONFIG_PATH=`"$relpath/config.tests/unix/makeabs" "${CFG_QCONFIG}"`
        if [ ! -f "$CFG_QCONFIG_PATH" ]; then
            echo >&2 "Error: configuration file not found:"
            echo >&2 "  $relpath/src/corelib/global/qconfig-${CFG_QCONFIG}.h"
            echo >&2 "  or"
            echo >&2 "  $CFG_QCONFIG_PATH"
            exit 1
        fi
    fi
esac

if [ "$XPLATFORM_MAC" = "no" -a "$CFG_DEBUG_RELEASE" = "yes" ]; then
    echo
    echo "WARNING: -debug-and-release is not supported outside of Mac OS X."
    echo "Qt can be built in release mode with separate debug information, so"
    echo "-debug-and-release is not necessary anymore"
    echo
fi

if ( [ "$CFG_XCB" = "system" ] || [ "$CFG_XCB" = "qt" ] ) && [ "$CFG_XKBCOMMON" = "no" ]; then
    echo "Error: -no-xkbcommon is not supported on XCB platform plugin."
    exit 101
fi

if [ "$XPLATFORM_ANDROID" = "yes" ]; then
    if [ -z "$CFG_DEFAULT_ANDROID_NDK_HOST" ]; then
        case $PLATFORM in
        linux-*)
            if [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/linux-x86" ]; then
                CFG_DEFAULT_ANDROID_NDK_HOST=linux-x86
            elif [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/linux-x86_64" ]; then
                CFG_DEFAULT_ANDROID_NDK_HOST=linux-x86_64
            fi
            ;;
        macx-*)
            CFG_DEFAULT_ANDROID_NDK_HOST=darwin-x86
            if [ ! -z "$NATIVE_64_ARCH" ] && [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/darwin-x86_64" ]; then
                CFG_DEFAULT_ANDROID_NDK_HOST=darwin-x86_64
            fi
            ;;
        win32-*)
            CFG_DEFAULT_ANDROID_NDK_HOST=windows
            if [ ! -z "$NATIVE_64_ARCH" ] && [ -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/windows-x86_64" ]; then
                CFG_DEFAULT_ANDROID_NDK_HOST=windows-x86_64
            fi
            ;;
        esac
    fi

        if [ -z "$CFG_DEFAULT_ANDROID_NDK_ROOT" ]; then
            echo
            echo "Can not find Android NDK. Please use -android-ndk option to specify one"
            exit 1
        fi
        if [ -z "$CFG_DEFAULT_ANDROID_SDK_ROOT" ]; then
            echo
            echo "Can not find Android SDK. Please use -android-sdk option to specify one"
            exit 1
        fi
        if [ -z "CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt" ]; then
            echo
            echo "Can not detect Android NDK toolchain. Please use -android-toolchain-version to specify"
            exit 1
        fi
        if [ -z "$CFG_DEFAULT_ANDROID_NDK_HOST" ] || [ ! -d "$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/$CFG_DEFAULT_ANDROID_NDK_HOST" ]; then
            echo
            echo "Can not detect the android host. Please use -android-ndk-host option to specify one"
            exit 1
        fi

        QT_QPA_DEFAULT_PLATFORM="android"
        CFG_LARGEFILE="no"

        DeviceVar set DEFAULT_ANDROID_SDK_ROOT "$CFG_DEFAULT_ANDROID_SDK_ROOT"
        DeviceVar set DEFAULT_ANDROID_NDK_ROOT "$CFG_DEFAULT_ANDROID_NDK_ROOT"
        DeviceVar set DEFAULT_ANDROID_PLATFORM "$CFG_DEFAULT_ANDROID_PLATFORM"
        DeviceVar set DEFAULT_ANDROID_NDK_HOST "$CFG_DEFAULT_ANDROID_NDK_HOST"
        DeviceVar set DEFAULT_ANDROID_TARGET_ARCH "$CFG_DEFAULT_ANDROID_TARGET_ARCH"
        DeviceVar set DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION "$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION"
fi

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"
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG cross_compile"
fi

if [ "$BUILD_ON_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-clang' or 'macx-g++', then use" >&2
      echo "   the 'macx-xcode' spec for your application, and it will link to" >&2
      echo "   the Qt/Mac build using the settings of the original mkspec." >&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 use the contact form at http://qt.digia.com/contact-us"
    echo
    exit 2
fi

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

# 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 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..."

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

    mkdir -p "$outpath/mkspecs"
fi

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

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

# detect build style
if [ "$CFG_DEBUG" = "auto" ]; then
    if [ "$XPLATFORM_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
    QT_CONFIG="$QT_CONFIG build_all debug_and_release"
fi

if [ "$CFG_FORCEDEBUGINFO" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG force_debug_info"
fi

if [ "$XPLATFORM_IOS" = "yes" ]; then
    CFG_RPATH="no"
    CFG_PKGCONFIG="no"
    CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS examples"
    CFG_SHARED="no" # iOS builds should be static to be able to submit to the App Store
    CFG_SKIP_MODULES="$CFG_SKIP_MODULES qtconnectivity qtdoc qtmacextras qtserialport qtwebkit qtwebkit-examples"

    # If the user passes -sdk on the command line we build a SDK-specific Qt build.
    # Otherwise we build a joined simulator and device build, which is the default.
    if [ -z "$OPT_MAC_SDK" ]; then
         QT_CONFIG="$QT_CONFIG build_all"
         QTCONFIG_CONFIG="$QTCONFIG_CONFIG iphonesimulator_and_iphoneos"
    fi
fi

# disable XCB and GTK support auto-detection on Mac
if [ "$XPLATFORM_MAC" = "yes" ]; then
    [ "$CFG_XCB" = "auto" ] && CFG_XCB=no
    [ "$CFG_QGTKSTYLE" = "auto" ] && CFG_QGTKSTYLE=no
fi

QMAKE_CONF_COMPILER=`getXQMakeConf QMAKE_CXX`

TEST_COMPILER=$QMAKE_CONF_COMPILER

if [ "$XPLATFORM_ANDROID" = "yes" ] ; then
    ANDROID_NDK_TOOLS_PREFIX=
    ANDROID_PLATFORM_ARCH=
    case $CFG_DEFAULT_ANDROID_TARGET_ARCH in
        armeabi*)
            ANDROID_NDK_TOOLS_PREFIX=arm-linux-androideabi
            ANDROID_PLATFORM_ARCH=arch-arm
            ;;
        x86)
            ANDROID_NDK_TOOLS_PREFIX=x86
            ANDROID_PLATFORM_ARCH=arch-x86
            ;;
        mips)
            ANDROID_NDK_TOOLS_PREFIX=mipsel-linux-android
            ANDROID_PLATFORM_ARCH=arch-mips
            ;;
        *)
            echo "ERROR: Unknown android arch $CFG_DEFAULT_ANDROID_TARGET_ARCH"
            exit 1
            ;;
    esac
    QMAKE_CONF_COMPILER=$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/$ANDROID_NDK_TOOLS_PREFIX-$CFG_DEFAULT_ANDROID_NDK_TOOLCHAIN_VERSION/prebuilt/$CFG_DEFAULT_ANDROID_NDK_HOST/bin/$ANDROID_NDK_TOOLS_PREFIX-g++
    TEST_COMPILER="$QMAKE_CONF_COMPILER --sysroot=$CFG_DEFAULT_ANDROID_NDK_ROOT/platforms/$CFG_DEFAULT_ANDROID_PLATFORM/$ANDROID_PLATFORM_ARCH/"
fi

if [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
    if [ -z "$TEST_COMPILER" ]; then
        echo "ERROR: Cannot set the compiler for the configuration tests"
        exit 1
    fi
fi
TEST_COMPILER_CXXFLAGS=`getXQMakeConf QMAKE_CXXFLAGS`

GCC_MACHINE_DUMP=
case "$TEST_COMPILER" in *g++) GCC_MACHINE_DUMP=$($TEST_COMPILER -dumpmachine);; esac
if [ -n "$GCC_MACHINE_DUMP" ]; then
    DeviceVar set GCC_MACHINE_DUMP $($TEST_COMPILER -dumpmachine)
fi

if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
    SYSROOT_FLAG="--sysroot=$CFG_SYSROOT"
else
    SYSROOT_FLAG=
fi
export SYSROOT_FLAG    # used by config.tests/unix/{compile.test,arch.test}

# auto-detect precompiled header support
if [ "$CFG_PRECOMPILE" = "auto" ]; then
    if "$unixtests/precomp.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
       CFG_PRECOMPILE=no
    else
       CFG_PRECOMPILE=yes
    fi
fi

# sanity-check for separate debug info
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
    if [ "$CFG_SHARED" = "no" ]; then
        echo "ERROR: -separate-debug-info is incompatible with -static"
        exit 1
    fi
    if [ "$CFG_DEBUG" = "no" -a "$CFG_DEBUG_RELEASE" = "no" -a "$CFG_FORCEDEBUGINFO" = "no" ]; then
        echo "ERROR: -separate-debug-info needs -debug, -debug-and-release, or -force-debug-info"
        exit 1
    fi
fi

# auto-detect -fvisibility support
if [ "$CFG_REDUCE_EXPORTS" != "no" ]; then
    if "$unixtests/fvisibility.test" "$TEST_COMPILER" "$OPT_VERBOSE"; then
       if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
           echo "-reduce-exports was requested but this compiler does not support it"
           echo "Re-run configure with -v for more information"
           exit 1
       fi
       CFG_REDUCE_EXPORTS=no
    else
       CFG_REDUCE_EXPORTS=yes
    fi
fi

# auto-detect -fstack-protector-strong support (for QNX only currently)
if [ "$XPLATFORM_QNX" = "yes" ]; then
    if compilerSupportsFlag $TEST_COMPILER -fstack-protector-strong; then
       CFG_STACK_PROTECTOR_STRONG=yes
    else
       CFG_STACK_PROTECTOR_STRONG=no
    fi
else
   CFG_STACK_PROTECTOR_STRONG=no
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
       if [ "$CFG_REDUCE_RELOCATIONS" = "yes" ]; then
           echo "-reduce-relocations was requested but this compiler does not support it"
           echo "Re-run configure with -v for more information"
           exit 1
       fi
        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

# find the default framework value
if [ "$XPLATFORM_MAC" = "yes" ]; 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

# Auto-detect default include and library search paths.

# Use intermediate variable to get around backtick/quote nesting problems.
awkprog='
BEGIN { ORS = ""; FS = "="; incs = 0; libs = 0; }

function normalize(dir)
{
    do {
        odir = dir
        sub(/\/[^\/]+\/\.\./, "", dir)
    } while (dir != odir);
    do {
        odir = dir
        gsub(/\/\./, "", dir)
    } while (dir != odir);
    sub("/$", "", dir);
    return dir;
}

# extract include paths from indented lines between
#   #include <...> search starts here:
# and
#   End of search list.
/^\#include </ { yup=1; print "DEFAULT_INCDIRS=\""; next }
/^End of search/ { yup=0; print "\"\n" }
/ \(framework directory\)$/ { next }
yup { print normalize(substr($0, 2)) "\n"; ++incs }

# extract from one line like LIBRARY_PATH=/one/path:/another/path:...
$1 == "LIBRARY_PATH" {
    libs = split($2, library_paths, ":");
    print "DEFAULT_LIBDIRS=\"";
    for (lib in library_paths) {
        dir = normalize(library_paths[lib]);
        if (!(dir in dirs)) {
            print dir "\n";
            dirs[dir] = 1;
        }
    }
    print "\"\n"
}

END {
    if (incs == 0)
        print "DEFAULT_INCDIRS=\"/usr/include\n/usr/local/include\"\n";
    if (libs == 0)
        print "DEFAULT_LIBDIRS=\"/lib\n/usr/lib\"\n";
}'

unset tty
[ "$OPT_VERBOSE" = "yes" ] && tty=/dev/stderr
eval "`LC_ALL=C $TEST_COMPILER $SYSROOT_FLAG $TEST_COMPILER_CXXFLAGS -xc++ -E -v - < /dev/null 2>&1 > /dev/null | $AWK "$awkprog" | tee $tty`"
unset tty

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

    # build tests by default, if a developer build
    if [ "$CFG_DEV" = "yes" ]; then
        CFG_BUILD_PARTS="$CFG_BUILD_PARTS tests"
    fi

    # 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
#-------------------------------------------------------------------------------

if [ -z "$QT_INSTALL_PREFIX" ]; then
    if [ "$CFG_DEV" = "yes" ]; then
        QT_INSTALL_PREFIX="$outpath" # In Development, we use sandboxed builds by default
    else
        QT_INSTALL_PREFIX="/usr/local/Qt-${QT_VERSION}" # the default install prefix is /usr/local/Qt-$QT_VERSION
    fi
fi
QT_INSTALL_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PREFIX"`

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

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

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

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

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

if [ "$XPLATFORM_MINGW" = "yes" ]; then
    QT_INSTALL_LIBEXECS_DIRNAME="bin"
else
    QT_INSTALL_LIBEXECS_DIRNAME="libexec"
fi

if [ -z "$QT_INSTALL_LIBEXECS" ]; then #default
    QT_INSTALL_LIBEXECS="$QT_INSTALL_ARCHDATA/$QT_INSTALL_LIBEXECS_DIRNAME" #fallback
fi
QT_INSTALL_LIBEXECS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBEXECS"`

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

if [ -z "$QT_INSTALL_PLUGINS" ]; then #default
    QT_INSTALL_PLUGINS="$QT_INSTALL_ARCHDATA/plugins" #fallback
fi
QT_INSTALL_PLUGINS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_PLUGINS"`

if [ -z "$QT_INSTALL_IMPORTS" ]; then #default
    QT_INSTALL_IMPORTS="$QT_INSTALL_ARCHDATA/imports" #fallback
fi
QT_INSTALL_IMPORTS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_IMPORTS"`

#qml
if [ -z "$QT_INSTALL_QML" ]; then #default
    QT_INSTALL_QML="$QT_INSTALL_ARCHDATA/qml" #fallback
fi
QT_INSTALL_QML=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_QML"`

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

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

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

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

#------- sysroot-external install paths --------

QT_SYSROOT_PREFIX=$QT_INSTALL_PREFIX
QT_SYSROOT_DOCS=$QT_INSTALL_DOCS
QT_SYSROOT_HEADERS=$QT_INSTALL_HEADERS
QT_SYSROOT_LIBS=$QT_INSTALL_LIBS
QT_SYSROOT_LIBEXECS=$QT_INSTALL_LIBEXECS
QT_SYSROOT_BINS=$QT_INSTALL_BINS
QT_SYSROOT_PLUGINS=$QT_INSTALL_PLUGINS
QT_SYSROOT_IMPORTS=$QT_INSTALL_IMPORTS
QT_SYSROOT_QML=$QT_INSTALL_QML
QT_SYSROOT_ARCHDATA=$QT_INSTALL_ARCHDATA
QT_SYSROOT_DATA=$QT_INSTALL_DATA
QT_SYSROOT_TRANSLATIONS=$QT_INSTALL_TRANSLATIONS
QT_SYSROOT_EXAMPLES=$QT_INSTALL_EXAMPLES
QT_SYSROOT_TESTS=$QT_INSTALL_TESTS
if [ -n "$QT_EXT_PREFIX" ]; then
    QT_INSTALL_PREFIX=$QT_EXT_PREFIX
    QT_INSTALL_DOCS=`substPrefix "$QT_INSTALL_DOCS"`
    QT_INSTALL_HEADERS=`substPrefix "$QT_INSTALL_HEADERS"`
    QT_INSTALL_LIBS=`substPrefix "$QT_INSTALL_LIBS"`
    QT_INSTALL_LIBEXECS=`substPrefix "$QT_INSTALL_LIBEXECS"`
    QT_INSTALL_BINS=`substPrefix "$QT_INSTALL_BINS"`
    QT_INSTALL_PLUGINS=`substPrefix "$QT_INSTALL_PLUGINS"`
    QT_INSTALL_IMPORTS=`substPrefix "$QT_INSTALL_IMPORTS"`
    QT_INSTALL_QML=`substPrefix "$QT_INSTALL_QML"`
    QT_INSTALL_ARCHDATA=`substPrefix "$QT_INSTALL_ARCHDATA"`
    QT_INSTALL_DATA=`substPrefix "$QT_INSTALL_DATA"`
    QT_INSTALL_TRANSLATIONS=`substPrefix "$QT_INSTALL_TRANSLATIONS"`
    QT_INSTALL_EXAMPLES=`substPrefix "$QT_INSTALL_EXAMPLES"`
    QT_INSTALL_TESTS=`substPrefix "$QT_INSTALL_TESTS"`
fi

#------- host paths --------

if [ -z "$QT_HOST_PREFIX" ]; then
    QT_HOST_PREFIX=$QT_INSTALL_PREFIX
    haveHpx=false
else
    QT_HOST_PREFIX=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_PREFIX"`
    haveHpx=true
fi

if [ -z "$QT_HOST_BINS" ]; then #default
    if $haveHpx; then
        QT_HOST_BINS="$QT_HOST_PREFIX/bin" #fallback
    else
        QT_HOST_BINS="$QT_INSTALL_BINS"
    fi
fi
QT_HOST_BINS=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_BINS"`

if [ -z "$QT_HOST_LIBS" ]; then #default
    if $haveHpx; then
        QT_HOST_LIBS="$QT_HOST_PREFIX/lib" #fallback
    else
        QT_HOST_LIBS="$QT_INSTALL_LIBS"
    fi
fi
QT_HOST_LIBS=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_LIBS"`

if [ -z "$QT_HOST_DATA" ]; then #default
    if $haveHpx; then
        QT_HOST_DATA="$QT_HOST_PREFIX"
    else
        QT_HOST_DATA="$QT_INSTALL_ARCHDATA"
    fi
else
    QT_HOST_DATA=`"$relpath/config.tests/unix/makeabs" "$QT_HOST_DATA"`
fi

if [ "$CFG_COMPILE_EXAMPLES" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG compile_examples"
fi

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

shortxspec=`echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
shortspec=`echo $QMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`

if [ -z "$QT_EXT_PREFIX" ]; then
    QMAKE_SYSROOTIFY=y
else
    QMAKE_SYSROOTIFY=n
fi

cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* License Info */
static const char qt_configure_licensee_str          [256 + 12] = "qt_lcnsuser=$Licensee";
static const char qt_configure_licensed_products_str [256 + 12] = "qt_lcnsprod=$Edition";

/* Installation date */
static const char qt_configure_installation          [12+11]    = "qt_instdate=`date +%Y-%m-%d`";

/* Installation Info */
static const char qt_configure_prefix_path_strs[][256 + 12] = {
#ifndef QT_BUILD_QMAKE
    "qt_prfxpath=$QT_SYSROOT_PREFIX",
    "qt_docspath=$QT_SYSROOT_DOCS",
    "qt_hdrspath=$QT_SYSROOT_HEADERS",
    "qt_libspath=$QT_SYSROOT_LIBS",
    "qt_lbexpath=$QT_SYSROOT_LIBEXECS",
    "qt_binspath=$QT_SYSROOT_BINS",
    "qt_plugpath=$QT_SYSROOT_PLUGINS",
    "qt_impspath=$QT_SYSROOT_IMPORTS",
    "qt_qml2path=$QT_SYSROOT_QML",
    "qt_adatpath=$QT_SYSROOT_ARCHDATA",
    "qt_datapath=$QT_SYSROOT_DATA",
    "qt_trnspath=$QT_SYSROOT_TRANSLATIONS",
    "qt_xmplpath=$QT_SYSROOT_EXAMPLES",
    "qt_tstspath=$QT_SYSROOT_TESTS",
#else
    "qt_prfxpath=$QT_INSTALL_PREFIX",
    "qt_docspath=$QT_INSTALL_DOCS",
    "qt_hdrspath=$QT_INSTALL_HEADERS",
    "qt_libspath=$QT_INSTALL_LIBS",
    "qt_lbexpath=$QT_INSTALL_LIBEXECS",
    "qt_binspath=$QT_INSTALL_BINS",
    "qt_plugpath=$QT_INSTALL_PLUGINS",
    "qt_impspath=$QT_INSTALL_IMPORTS",
    "qt_qml2path=$QT_INSTALL_QML",
    "qt_adatpath=$QT_INSTALL_ARCHDATA",
    "qt_datapath=$QT_INSTALL_DATA",
    "qt_trnspath=$QT_INSTALL_TRANSLATIONS",
    "qt_xmplpath=$QT_INSTALL_EXAMPLES",
    "qt_tstspath=$QT_INSTALL_TESTS",
    "qt_ssrtpath=$CFG_SYSROOT",
    "qt_hpfxpath=$QT_HOST_PREFIX",
    "qt_hbinpath=$QT_HOST_BINS",
    "qt_hlibpath=$QT_HOST_LIBS",
    "qt_hdatpath=$QT_HOST_DATA",
    "qt_targspec=$shortxspec",
    "qt_hostspec=$shortspec",
#endif
};
static const char qt_configure_settings_path_str[256 + 12] = "qt_stngpath=$QT_INSTALL_SETTINGS";

#ifdef QT_BUILD_QMAKE
static const char qt_sysrootify_prefix[] = "qt_ssrtfpfx=$QMAKE_SYSROOTIFY";
#endif
EOF

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_SETTINGS_PATH qt_configure_settings_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


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

# symlink includes
if [ -e "$relpath/.git" ]; then
    if [ -z "$PERL" ]; then
        echo
        echo "You need perl in your PATH to make a build from GIT."
        echo "Cannot proceed."
        exit 1
    fi

    "$relpath/bin/syncqt.pl" -minimal -module QtCore "$relpath" || exit 1
fi

# $1: input variable name (awk regexp)
# $2: optional output variable name
# $3: optional value transformation (sed command)
# relies on $QMAKESPEC, $COMPILER_CONF and $mkfile being set correctly, as the latter
# is where the resulting variable is written to
setBootstrapVariable()
{
    getQMakeConf "$1" | echo ${2-$1} = `if [ -n "$3" ]; then sed "$3"; else cat; fi` >> "$mkfile"
}

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

    mkdir -p "$outpath/qmake" || exit
    # 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) \$(QMAKE_CFLAGS_SPLIT_SECTIONS)"
        EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS) \$(QMAKE_CXXFLAGS_SPLIT_SECTIONS)"
        EXTRA_LFLAGS="\$(QMAKE_LFLAGS) \$(QMAKE_LFLAGS_GCSECTIONS)"

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

        [ "$CFG_SILENT" = "yes" ] && CC_TRANSFORM='s,^,\@,' || CC_TRANSFORM=
        setBootstrapVariable QMAKE_CC CC "$CC_TRANSFORM"
        setBootstrapVariable QMAKE_CXX CXX "$CC_TRANSFORM"
        setBootstrapVariable QMAKE_CFLAGS
        setBootstrapVariable QMAKE_CFLAGS_SPLIT_SECTIONS
        setBootstrapVariable QMAKE_CXXFLAGS
        setBootstrapVariable QMAKE_CXXFLAGS_SPLIT_SECTIONS
        setBootstrapVariable QMAKE_LFLAGS
        setBootstrapVariable QMAKE_LFLAGS_GCSECTIONS

        if [ "$CFG_RELEASE_QMAKE" = "yes" ]; then
            setBootstrapVariable QMAKE_CFLAGS_RELEASE
            setBootstrapVariable QMAKE_CXXFLAGS_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
            EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
            EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
        fi

        if [ -n "$RPATH_FLAGS" ] && [ -n "`getQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; then
            setBootstrapVariable "QMAKE_(LFLAGS_)?RPATH" QMAKE_LFLAGS_RPATH
            for rpath in $RPATH_FLAGS; do
                EXTRA_LFLAGS="\$(QMAKE_LFLAGS_RPATH)\"$rpath\" $EXTRA_LFLAGS"
            done
        fi
        if [ "$BUILD_ON_MSYS" = "yes" ]; then
            EXTRA_CFLAGS="-DUNICODE"
            EXTRA_CXXFLAGS="-DUNICODE"
            EXTRA_OBJS="qfilesystemengine_win.o \
                        qfilesystemiterator_win.o \
                        qfsfileengine_win.o \
                        qlocale_win.o \
                        qsettings_win.o \
                        qsystemlibrary.o \
                        registry.o"
            EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/corelib/io/qfilesystemengine_win.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_win.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_win.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/io/qsettings_win.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/tools/qlocale_win.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/plugin/qsystemlibrary.cpp\" \
                        \"\$(SOURCE_PATH)/tools/shared/windows/registry.cpp\""
            EXTRA_LFLAGS="-static -s -lole32 -luuid -ladvapi32 -lkernel32"
            EXEEXT=".exe"
        else
            EXTRA_OBJS="qfilesystemengine_unix.o \
                        qfilesystemiterator_unix.o \
                        qfsfileengine_unix.o \
                        qlocale_unix.o"
            EXTRA_SRCS="\"\$(SOURCE_PATH)/src/corelib/io/qfilesystemengine_unix.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/io/qfilesystemiterator_unix.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/io/qfsfileengine_unix.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/tools/qlocale_unix.cpp\""
            EXEEXT=
        fi
        if [ "$BUILD_ON_MAC" = "yes" ]; then
            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="$EXTRA_OBJS \
                        qsettings_mac.o \
                        qcore_mac.o"
            EXTRA_SRCS="$EXTRA_SRCS \
                        \"\$(SOURCE_PATH)/src/corelib/io/qsettings_mac.cpp\" \
                        \"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac.cpp\""
        fi
        if [ '!' -z "$D_FLAGS" ]; then
            EXTRA_CFLAGS="$EXTRA_CFLAGS $D_FLAGS"
        fi
        echo >>"$mkfile"
	adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
	adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
	adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`

        echo "BUILD_PATH = $adjoutpath" >> "$mkfile"
        echo "SOURCE_PATH = $adjrelpath" >> "$mkfile"
        if [ -e "$relpath/.git" ]; then
            echo 'INC_PATH = $(BUILD_PATH)/include' >> "$mkfile"
        else
            echo 'INC_PATH = $(SOURCE_PATH)/include' >> "$mkfile"
        fi
        echo "QMAKESPEC = $adjqmakespec" >> "$mkfile"
        echo "QT_VERSION = $QT_VERSION" >> "$mkfile"
        echo "EXTRA_CFLAGS = $EXTRA_CFLAGS" >> "$mkfile"
        echo "EXTRA_CXXFLAGS = $EXTRA_CXXFLAGS" >> "$mkfile"
        echo "QTOBJS =" $EXTRA_OBJS >> "$mkfile"
        echo "QTSRCS =" $EXTRA_SRCS >> "$mkfile"
        echo "LFLAGS = $EXTRA_LFLAGS" >> "$mkfile"
        echo "EXEEXT = $EXEEXT" >> "$mkfile"
        echo "RM_F = rm -f" >> "$mkfile"
        echo "RM_RF = rm -rf" >> "$mkfile"

        if [ "$BUILD_ON_MAC" = "yes" ]; then
            echo "EXTRA_CXXFLAGS += -MMD" >> "$mkfile"
            cat "$in_mkfile" >> "$mkfile"
            echo "-include \$(notdir \$(DEPEND_SRC:%.cpp=%.d))" >> "$mkfile"
        else
            cat "$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
        fi
    done

    (cd "$outpath/qmake"; "$MAKE") || exit 2
fi # Build qmake

echo "Running configuration tests..."

#-------------------------------------------------------------------------------
# create a qt.conf for the Qt build tree itself
#-------------------------------------------------------------------------------

QTCONFFILE="$outpath/bin/qt.conf"
cat > "$QTCONFFILE" <<EOF
[EffectivePaths]
Prefix=..
EOF
if [ x"$relpath" != x"$outpath" ]; then
    cat >> "$QTCONFFILE" <<EOF
[EffectiveSourcePaths]
Prefix=$relpath
EOF
fi

#-------------------------------------------------------------------------------
# write out device config before we run the test.
#-------------------------------------------------------------------------------
DEVICE_VARS_OUTFILE="$outpath/mkspecs/qdevice.pri"
if cmp -s "$DEVICE_VARS_FILE" "$DEVICE_VARS_OUTFILE"; then
    rm -f "$DEVICE_VARS_FILE"
else
    mv -f $DEVICE_VARS_FILE "$DEVICE_VARS_OUTFILE"
    DEVICE_VARS_FILE="$DEVICE_VARS_OUTFILE"
fi

#-------------------------------------------------------------------------------
# Verify makespec
#-------------------------------------------------------------------------------
QMAKE_OUTPUT=`$outpath/bin/qmake -E -nocache -spec "$XQMAKESPEC" "QT=" $DEV_NULL 2>&1`
if [ $? != "0" ]; then
    echo "Failed to process makespec for platform '$XPLATFORM'"
    if [ "$OPT_VERBOSE" = "yes" ]; then
        echo "$QMAKE_OUTPUT"
    else
        echo "Turn on verbose messaging (-v) to see the final report."
    fi
    exit 101
fi

#-------------------------------------------------------------------------------
# Detect pkg-config
#-------------------------------------------------------------------------------
if [ -z "$PKG_CONFIG" ]; then
    # See if PKG_CONFIG is set in the mkspec:
    PKG_CONFIG="`"$outpath/bin/qmake" -E -nocache -spec "$XQMAKESPEC" "CONFIG=" $DEV_NULL 2>&1 | sed -n -e 's,^PKG_CONFIG = \(.*\),\1,p'`"
fi
if [ -z "$PKG_CONFIG" ]; then
    PKG_CONFIG=`"$WHICH" pkg-config 2>/dev/null`
fi

if [ "$CFG_PKGCONFIG" = "no" ]; then
    PKG_CONFIG=
elif [ "$CFG_PKGCONFIG" = "force" ]; then
    echo >&2 ""
    echo >&2 "You have asked to use pkg-config. Please make sure you have"
    echo >&2 "a correctly setup pkg-config environment!"
    echo >&2 ""
elif [ -n "$PKG_CONFIG" ]; then
    # found a pkg-config
    if [ "$QT_CROSS_COMPILE" = "yes" ]; then
        # when xcompiling, check environment to see if it's actually usable
        if [ -z "$PKG_CONFIG_LIBDIR" ]; then
            if [ -n "$CFG_SYSROOT" ] && [ -d "$CFG_SYSROOT/usr/lib/pkgconfig" ]; then
                PKG_CONFIG_LIBDIR=$CFG_SYSROOT/usr/lib/pkgconfig:$CFG_SYSROOT/usr/share/pkgconfig
                if [ -n "$GCC_MACHINE_DUMP" ]; then
                    PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR:$CFG_SYSROOT/usr/lib/$GCC_MACHINE_DUMP/pkgconfig
                fi
                export PKG_CONFIG_LIBDIR
                echo >&2 "Note: PKG_CONFIG_LIBDIR automatically set to $PKG_CONFIG_LIBDIR"
            elif [ "$CFG_PKGCONFIG" = "yes" ]; then
                echo >&2 "Error: PKG_CONFIG_LIBDIR has not been set. This could mean"
                echo >&2 "the host's .pc files will be used (even if you set PKG_CONFIG_PATH)."
                echo >&2 "Set this variable to the directory that contains target .pc files"
                echo >&2 "for pkg-config to function correctly when cross-compiling or"
                echo >&2 "use -force-pkg-config to override this test."
                exit 101
            else
                PKG_CONFIG=
                echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_LIBDIR is not set."
            fi
        fi
        if [ -z "$PKG_CONFIG_SYSROOT_DIR" ]; then
            if [ -n "$CFG_SYSROOT" ]; then
                PKG_CONFIG_SYSROOT_DIR=$CFG_SYSROOT
                export PKG_CONFIG_SYSROOT_DIR
                echo >&2 "Note: PKG_CONFIG_SYSROOT_DIR automatically set to $PKG_CONFIG_SYSROOT_DIR"
            elif [ "$CFG_PKGCONFIG" = "yes" ]; then
                echo >&2 "Error: PKG_CONFIG_SYSROOT_DIR has not been set. Set this variable"
                echo >&2 "to your sysroot for pkg-config to function correctly when cross-compiling"
                echo >&2 "or use -force-pkg-config to override this test."
                exit 101
            else
                PKG_CONFIG=
                echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_SYSROOT_DIR is not set."
            fi
        fi
    fi
elif [ "$CFG_PKGCONFIG" = "yes" ]; then
    echo >&2 "Could not detect pkg-config from mkspec or PATH."
    exit 101
fi

if [ -z "$PKG_CONFIG" ]; then
    QT_CONFIG="$QT_CONFIG no-pkg-config"
fi

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

# parameters: path, name, extra args
compileTest()
{
    path=config.tests/$1
    name=$2
    shift 2
    "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" "$path" "$name" $I_FLAGS $D_FLAGS $L_FLAGS "$@"
}

#-------------------------------------------------------------------------------
# determine the target and host architectures
#-------------------------------------------------------------------------------

# Use config.tests/arch/arch.pro to have the compiler tell us what the target architecture is
OUTFILE=$outpath/arch.result
"$unixtests/arch.test" "$XQMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath" "$OUTFILE" "target" $I_FLAGS $D_FLAGS $L_FLAGS
if [ $? -eq 0 ]; then
    eval `cat "$OUTFILE"`
else
    echo
    echo "Could not determine the target architecture!"
    echo "Turn on verbose messaging (-v) to see the final report."
fi
rm -f "$OUTFILE" 2>/dev/null
[ -z "$CFG_ARCH" ] && CFG_ARCH="unknown"

if [ "$QMAKESPEC" != "$XQMAKESPEC" ]; then
    # Do the same test again, using the host compiler
    SYSROOT_FLAG= "$unixtests/arch.test" "$QMAKESPEC" $OPT_VERBOSE "$relpath" "$outpath" "$OUTFILE" "host" $I_FLAGS $D_FLAGS $L_FLAGS
    if [ $? -eq 0 ]; then
        eval `cat "$OUTFILE"`
    else
        echo
        echo "Could not determine the host architecture!"
        echo "Turn on verbose messaging (-v) to see the final report."
    fi
    rm -f "$OUTFILE" 2>/dev/null
    [ -z "$CFG_HOST_ARCH" ] && CFG_HOST_ARCH="unknown"
else
    # not cross compiling, host == target
    CFG_HOST_ARCH="$CFG_ARCH"
    CFG_HOST_CPUFEATURES="$CFG_CPUFEATURES"
fi
unset OUTFILE

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

#-------------------------------------------------------------------------------
# functionality tests
#-------------------------------------------------------------------------------

# Detect objcopy support
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
    if ! compileTest unix/objcopy "objcopy"; then
        echo "ERROR: -separate-debug-info was requested but this binutils does not support it."
        echo "Re-run configure with -v for more information"
        exit 1
    fi
fi

# Detect C++11 support
if [ "$CFG_CXX11" != "no" ]; then
    # Configure detects compiler features based on cross compiler, so we need
    # to explicitly disable C++11 on Mac to avoid breaking builds where the
    # host compiler does not support it.
    if [ "$BUILD_ON_MAC" = "yes" ] && [ "$XPLATFORM_ANDROID" = "yes" ]; then
        CFG_CXX11="no"
    elif compileTest common/c++11 "C++11"; then
        CFG_CXX11="yes"
    elif [ "$CFG_CXX11" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
        echo "C++11 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_CXX11="no"
    fi
fi

# detect availability of float math.h functions
if compileTest unix/floatmath "floatmath"; then
    CFG_USE_FLOATMATH=yes
else
    CFG_USE_FLOATMATH=no
fi

# detect sse2 support
if [ "${CFG_SSE2}" = "auto" ]; then
    if compileTest common/sse2 "sse2"; then
       CFG_SSE2=yes
    else
       CFG_SSE2=no
    fi
fi

# detect sse3 support
if [ "${CFG_SSE2}" = "no" ]; then
    CFG_SSE3=no
fi
if [ "${CFG_SSE3}" = "auto" ]; then
    if compileTest common/sse3 "sse3"; then
       CFG_SSE3=yes
    else
       CFG_SSE3=no
    fi
fi

# detect ssse3 support
if [ "${CFG_SSE3}" = "no" ]; then
    CFG_SSSE3=no
fi
if [ "${CFG_SSSE3}" = "auto" ]; then
    if compileTest common/ssse3 "ssse3"; then
       CFG_SSSE3=yes
    else
       CFG_SSSE3=no
    fi
fi

# detect sse4.1 support
if [ "${CFG_SSSE3}" = "no" ]; then
    CFG_SSE4_1=no
fi
if [ "${CFG_SSE4_1}" = "auto" ]; then
    if compileTest common/sse4_1 "sse4_1"; then
       CFG_SSE4_1=yes
    else
       CFG_SSE4_1=no
    fi
fi

# detect sse4.2 support
if [ "${CFG_SSE4_1}" = "no" ]; then
    CFG_SSE4_2=no
fi
if [ "${CFG_SSE4_2}" = "auto" ]; then
    if compileTest common/sse4_2 "sse4_2"; then
       CFG_SSE4_2=yes
    else
       CFG_SSE4_2=no
    fi
fi

# detect avx support
if [ "${CFG_SSE4_2}" = "no" ]; then
    CFG_AVX=no
fi
if [ "${CFG_AVX}" = "auto" ]; then
    if compileTest common/avx "avx"; then
       case "$XQMAKESPEC" in
           *g++*|*-clang*)
               # Some clang versions produce internal compiler errors compiling Qt AVX code
               case `$TEST_COMPILER --version` in
                   Apple\ clang\ version\ [23]*)
                       CFG_AVX=no
                       if [ "$OPT_VERBOSE" = "yes" ]; then
                           echo 'AVX support disabled for blacklisted clang compiler'
                       fi
                       ;;
                   *)
                       CFG_AVX=yes
                       ;;
               esac
               ;;
           *)
               CFG_AVX=yes
               ;;
       esac
    else
       CFG_AVX=no
    fi
fi

# detect avx2 support
if [ "${CFG_AVX}" = "no" ]; then
    CFG_AVX2=no
fi
if [ "${CFG_AVX2}" = "auto" ]; then
    if compileTest common/avx2 "avx2"; then
       CFG_AVX2=yes
    else
       CFG_AVX2=no
    fi
fi

# check iWMMXt support
if [ "$CFG_IWMMXT" = "yes" ]; then
    compileTest unix/iwmmxt "iwmmxt"
    if [ $? != "0" ]; then
        echo "The iWMMXt functionality test failed!"
	echo " Please make sure your compiler supports iWMMXt intrinsics!"
	exit 1
    fi
fi

# detect mips_dsp support
if [ "$CFG_ARCH" = "mips" ] && [ "${CFG_MIPS_DSP}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mips_dsp "mips_dsp" $L_FLAGS $I_FLAGS $D_FLAGS $l_FLAGS; then
        CFG_MIPS_DSP=yes
    else
        CFG_MIPS_DSP=no
    fi
elif [ "$CFG_ARCH" != "mips" ]; then
    CFG_MIPS_DSP=no
fi

# detect mips_dspr2 support
if [ "$CFG_ARCH" = "mips" ] && [ "${CFG_MIPS_DSPR2}" = "auto" ]; then
    if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/mips_dspr2 "mips_dspr2" $L_FLAGS $I_FLAGS $D_FLAGS $l_FLAGS; then
        CFG_MIPS_DSPR2=yes
    else
        CFG_MIPS_DSPR2=no
    fi
elif [ "$CFG_ARCH" != "mips" ]; then
    CFG_MIPS_DSPR2=no
fi

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

# 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 [ "$XPLATFORM_QNX" = "yes" ]; then
    if [ "$CFG_SLOG2" != "no" ]; then
        if compileTest unix/slog2 "slog2"; then
            CFG_SLOG2=yes
            QMAKE_CONFIG="$QMAKE_CONFIG slog2"
        else
            CFG_SLOG2=no
        fi
    fi
    if [ "$CFG_QNX_IMF" != "no" ]; then
        if compileTest unix/qqnx_imf "qqnx_imf"; then
            CFG_QNX_IMF=yes
            QMAKE_CONFIG="$QMAKE_CONFIG qqnx_imf"
        else
            CFG_QNX_IMF=no
        fi
    fi
    if [ "$CFG_PPS" != "no" ]; then
        if compileTest unix/pps "pps"; then
            CFG_PPS=yes
            QMAKE_CONFIG="$QMAKE_CONFIG qqnx_pps"
        else
            CFG_PPS=no
        fi
    fi

    if [ "$CFG_LGMON" != "no" ]; then
        if compileTest unix/lgmon "lgmon"; then
            CFG_LGMON=yes
            QMAKE_CONFIG="$QMAKE_CONFIG lgmon"
        else
            CFG_LGMON=no
        fi
    fi
fi

if [ "$CFG_ZLIB" = "auto" ]; then
    if compileTest unix/zlib "zlib"; then
       CFG_ZLIB=system
    else
       CFG_ZLIB=yes
    fi
fi

if [ "$CFG_MTDEV" != "no" ]; then
    if compileTest unix/mtdev "mtdev"; then
        CFG_MTDEV=yes
    else
        CFG_MTDEV=no
    fi
fi
if [ "$CFG_MTDEV" = "no" ]; then
    QMakeVar add DEFINES QT_NO_MTDEV
fi

if [ "$CFG_JOURNALD" != "no" ]; then
    if compileTest unix/journald "journald"; then
        CFG_JOURNALD=yes
        QMAKE_CONFIG="$QMAKE_CONFIG journald"
    else
        if [ "$CFG_JOURNALD" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "journald 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_JOURNALD=no
        fi
    fi
fi

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

if [ "$CFG_GUI" = "no" ]; then
    QPA_PLATFORM_GUARD=no
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 compileTest unix/libjpeg "libjpeg"; 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 png
if [ "$CFG_LIBPNG" = "auto" ]; then
    if compileTest unix/libpng "libpng"; then
       CFG_LIBPNG=system
    else
       CFG_LIBPNG=qt
    fi
fi

if [ "$CFG_EGLFS" = "yes" ]; then
    if [ "$CFG_EGL" = "no" ]; then
        echo "The EGLFS plugin requires EGL support and cannot be built"
        exit 101
    fi
    CFG_EGL=yes
fi

if [ "$CFG_KMS" = "yes" ]; then
    if [ "$CFG_EGL" = "no" ]; then
        echo "The KMS plugin requires EGL support and cannot be built"
        exit 101
    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 | filterIncludeOptions`
                    QT_LFLAGS_MYSQL_R=`$CFG_MYSQL_CONFIG --libs_r 2>/dev/null | filterLibraryOptions`
                    QT_LFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --libs 2>/dev/null | filterLibraryOptions`
		    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 compileTest unix/mysql_r "MySQL (thread-safe)" $QT_LFLAGS_MYSQL_R $QT_CFLAGS_MYSQL; 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 compileTest unix/mysql "MySQL (thread-unsafe)" $QT_LFLAGS_MYSQL $QT_CFLAGS_MYSQL; 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 | filterIncludePath`
                    QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null | filterLibraryPath`
                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 compileTest unix/psql "PostgreSQL" $QT_LFLAGS_PSQL $QT_CFLAGS_PSQL; 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 [ "$XPLATFORM_MAC" != "yes" ] && compileTest unix/odbc "ODBC"; then
                    if [ "$CFG_SQL_odbc" = "auto" ]; then
                        CFG_SQL_odbc=plugin
                    fi
                else
                    if compileTest unix/iodbc "iODBC"; 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 compileTest unix/oci "OCI"; 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 compileTest unix/tds "TDS" $QT_LFLAGS_TDS; 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 compileTest unix/db2 "DB2"; 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 compileTest unix/ibase "InterBase"; 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 compileTest unix/sqlite2 "SQLite2"; 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" != "no" ]; then
                SQLITE_AUTODETECT_FAILED="no"
                if [ "$CFG_SQLITE" = "system" ]; then
                    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists sqlite3 2>/dev/null; then
                        QT_CFLAGS_SQLITE=`$PKG_CONFIG --cflags sqlite3 2>/dev/null`
                        QT_LFLAGS_SQLITE=`$PKG_CONFIG --libs sqlite3 2>/dev/null`
                    else
                        QT_CFLAGS_SQLITE=
                        QT_LFLAGS_SQLITE="-lsqlite3 -lz"
                    fi
                    if compileTest unix/sqlite "SQLite" $QT_LFLAGS_SQLITE $QT_CFLAGS_SQLITE; 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 compileTest unix/nis "NIS"; 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 compileTest unix/cups "Cups"; 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 [ "$XPLATFORM_MINGW" = "yes" ]; then
        CFG_ICONV=no
    elif compileTest unix/iconv "POSIX iconv"; then
        CFG_ICONV=yes
    elif compileTest unix/sun-libiconv "SUN libiconv"; then
        CFG_ICONV=sun
    elif compileTest unix/gnu-libiconv "GNU libiconv"; 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 compileTest unix/dbus "D-Bus" $QT_CFLAGS_DBUS $QT_LIBS_DBUS; 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 Qt D-Bus 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

# 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 compileTest unix/glib "Glib" $QT_CFLAGS_GLIB $QT_LIBS_GLIB; 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

# auto-detect GTK style support
if [ "$CFG_GLIB" = "yes" -a "$CFG_QGTKSTYLE" != "no" ]; then
    if [ -n "$PKG_CONFIG" ]; then
        QT_CFLAGS_QGTK2=`$PKG_CONFIG --cflags gtk+-2.0 ">=" 2.18 atk 2>/dev/null`
        QT_LIBS_QGTK2=`$PKG_CONFIG --libs gtk+-2.0 2>/dev/null`
        QT_LIBS_QGOBJECT=`$PKG_CONFIG --libs gobject-2.0 2>/dev/null`
    fi
    if [ -n "$QT_CFLAGS_QGTK2" ] ; then
        CFG_QGTKSTYLE=yes
        QT_CONFIG="$QT_CONFIG gtk2 gtkstyle"
        QMakeVar set QT_CFLAGS_QGTKSTYLE "$QT_CFLAGS_QGTK2"
        QMakeVar set QT_LIBS_QGTKSTYLE "$QT_LIBS_QGOBJECT"
        QMakeVar set QT_CFLAGS_QGTK2 "$QT_CFLAGS_QGTK2"
        QMakeVar set QT_LIBS_QGTK2 "$QT_LIBS_QGTK2"
    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 fin  al 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

# auto-detect libicu support
if [ "$CFG_ICU" != "no" ]; then
    if compileTest unix/icu "ICU"; then
        [ "$CFG_ICU" = "auto" ] && CFG_ICU=yes
    else
        if [ "$CFG_ICU" = "auto" ]; then
            CFG_ICU=no
        elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            # CFG_ICU is "yes"

            echo "The ICU library support cannot be enabled."
            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

# 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 compileTest unix/pulseaudio "PulseAudio" $QT_CFLAGS_PULSEAUDIO $QT_LIBS_PULSEAUDIO; 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

# X11/MINGW OpenGL
if [ "$XPLATFORM_MINGW" = "yes" ]; then
    # auto-detect OpenGL support (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 compileTest x11/opengl "OpenGL"; then
            CFG_OPENGL=desktop
        elif compileTest unix/opengles2 "OpenGL ES 2.x"; then
            CFG_OPENGL=es2
        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
                compileTest x11/glxfbconfig "OpenGL"
                if [ $? != "0" ]; then
                    QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
                fi
            fi
            ;;
        *)
            ;;
        esac
    elif [ "$CFG_OPENGL" = "es2" ]; then
        #OpenGL ES 2.x
        compileTest unix/opengles2 "OpenGL ES 2.x"
        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
        compileTest x11/opengl "OpenGL"
        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.
            compileTest x11/glxfbconfig "OpenGL"
            if [ $? != "0" ]; then
                QMakeVar add DEFINES QT_DEFINE_GLXFBCONFIG_STRUCT
            fi
            ;;
        *)
            ;;
        esac
    fi
fi # X11/MINGW OpenGL

if [ "$XPLATFORM_MAC" = "yes" ]; then
    if [ "$CFG_COREWLAN" = "auto" ]; then
        if compileTest mac/corewlan "CoreWlan"; then
            CFG_COREWLAN=yes
        else
            CFG_COREWLAN=no
        fi
    fi
fi

# auto-detect OpenGL support (es2 = OpenGL ES 2.x)
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
    if compileTest unix/opengldesktop "OpenGL"; then
        CFG_OPENGL=desktop
    elif compileTest unix/opengles2 "OpenGL ES 2.x"; then
        CFG_OPENGL=es2
    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" = "es2" ]; then
    #OpenGL ES 2.x
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists glesv2 2>/dev/null; then
        QMAKE_INCDIR_OPENGL_ES2=`$PKG_CONFIG --cflags-only-I glesv2 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
        QMAKE_LIBDIR_OPENGL_ES2=`$PKG_CONFIG --libs-only-L glesv2 2>/dev/null | sed -e 's,^-L,,g' -e 's, -L, ,g'`
        QMAKE_LIBS_OPENGL_ES2=`$PKG_CONFIG --libs glesv2 2>/dev/null`
        QMAKE_CFLAGS_OPENGL_ES2=`$PKG_CONFIG --cflags glesv2 2>/dev/null`
        QMakeVar set QMAKE_INCDIR_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_INCDIR_OPENGL_ES2"`"
        QMakeVar set QMAKE_LIBDIR_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_LIBDIR_OPENGL_ES2"`"
        QMakeVar set QMAKE_LIBS_OPENGL_ES2 "`shellArgumentListToQMakeList "$QMAKE_LIBS_OPENGL_ES2"`"
    fi

    compileTest unix/opengles2 "OpenGL ES 2.x" $QMAKE_LIBS_OPENGL_ES2 $QMAKE_CFLAGS_OPENGL_ES2
    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
    compileTest unix/opengldesktop "OpenGL"
    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 compileTest unix/fontconfig "FontConfig" $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_FONTCONFIG=yes
        CFG_FREETYPE=system
    else
        CFG_FONTCONFIG=no
    fi

fi

# Save these for a check later
ORIG_CFG_XCB="$CFG_XCB"
ORIG_CFG_EGLFS="$CFG_EGLFS"
ORIG_CFG_DIRECTFB="$CFG_DIRECTFB"
ORIG_CFG_LINUXFB="$CFG_LINUXFB"
ORIG_CFG_KMS="$CFG_KMS"

if [ "$CFG_LIBUDEV" != "no" ]; then
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists libudev 2>/dev/null; then
        QMAKE_INCDIR_LIBUDEV=`$PKG_CONFIG --cflags-only-I libudev 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
        QMAKE_LIBS_LIBUDEV=`$PKG_CONFIG --libs libudev 2>/dev/null`
        QMakeVar set QMAKE_INCDIR_LIBUDEV "$QMAKE_INCDIR_LIBUDEV"
        QMakeVar set QMAKE_LIBS_LIBUDEV "$QMAKE_LIBS_LIBUDEV"
    fi
    if compileTest unix/libudev "libudev" $QMAKE_INCDIR_LIBUDEV $QMAKE_LIBS_LIBUDEV; then
        CFG_LIBUDEV=yes
        QT_CONFIG="$QT_CONFIG libudev"
    elif [ "$CFG_LIBUDEV" = "yes" ]; then
        echo "The libudev functionality test failed!"
        exit 1
    else
        CFG_LIBUDEV=no
    fi
fi
if [ "$CFG_LIBUDEV" = "no" ]; then
    QMakeVar add DEFINES QT_NO_LIBUDEV
fi

if [ "$CFG_EVDEV" != "no" ]; then
    if compileTest unix/evdev "evdev"; then
        CFG_EVDEV=yes
        QT_CONFIG="$QT_CONFIG evdev"
    elif [ "$CFG_EVDEV" = "yes" ]; then
        echo "The evdev functionality test failed!"
        exit 1
    else
        CFG_EVDEV=no
    fi
fi
if [ "$CFG_EVDEV" = "no" ]; then
    QMakeVar add DEFINES QT_NO_EVDEV
fi

if [ "$CFG_TSLIB" != "no" ]; then
    if compileTest unix/tslib "tslib"; then
        CFG_TSLIB=yes
        QT_CONFIG="$QT_CONFIG tslib"
    elif [ "$CFG_TSLIB" = "yes" ]; then
        echo "The tslib functionality test failed!"
        exit 1
    else
        CFG_TSLIB=no
    fi
fi

# Check we actually have X11 :-)
if compileTest x11/xlib "XLib"; then
    QT_CONFIG="$QT_CONFIG xlib"
fi

# auto-detect Xrender support
if [ "$CFG_XRENDER" != "no" ]; then
    if compileTest x11/xrender "Xrender"; then
        CFG_XRENDER=yes
        QT_CONFIG="$QT_CONFIG xrender"
    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

# auto-detect XInput2 support
if [ "$CFG_XINPUT2" != "no" ]; then
    if compileTest x11/xinput2 "XInput2"; then
        CFG_XINPUT2=yes
        CFG_XINPUT=no
    else
        if [ "$CFG_XINPUT2" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "XInput2 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_XINPUT2=no
        fi
    fi
fi

if [ "$CFG_XCB" != "no" ]; then
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xcb >= 1.5" 2>/dev/null; then
        QMAKE_CFLAGS_XCB="`$PKG_CONFIG --cflags xcb 2>/dev/null`"
        QMAKE_LIBS_XCB="`$PKG_CONFIG --libs xcb 2>/dev/null`"
    fi
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "x11" 2> /dev/null; then
        QMAKE_X11_PREFIX="`$PKG_CONFIG --variable=prefix x11`"
    else
        # default to LSB prefix
        QMAKE_X11_PREFIX="/usr"
    fi
    QMakeVar set QMAKE_X11_PREFIX "$QMAKE_X11_PREFIX"

    if [ "$CFG_XKBCOMMON" != no ] && compileTest qpa/xcb "xcb" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
        QT_CONFIG="$QT_CONFIG xcb-plugin"

        if [ "$CFG_XCB" = "qt" ]; then
            QT_CONFIG="$QT_CONFIG xcb-qt"
        else
            CFG_XCB="system"
            if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xcb >= 1.5" 2>/dev/null; then
                XCB_PACKAGES="xcb xcb-shm xcb-sync xcb-xfixes xcb-randr xcb-image xcb-keysyms xcb-icccm xcb-shape"
                QMAKE_CFLAGS_XCB="`$PKG_CONFIG --cflags $XCB_PACKAGES 2>/dev/null`"
                QMAKE_LIBS_XCB="`$PKG_CONFIG --libs $XCB_PACKAGES 2>/dev/null`"
            fi

            # libxcb version 1.10 was the first version that enables xcb-xkb by default,
            # therefore the minimal xcb-xkb version we support is 1.10
            CFG_XKB=no
            if $PKG_CONFIG --exists "xcb-xkb >= 1.10" 2>/dev/null; then
                QMAKE_CFLAGS_XKB="`$PKG_CONFIG --cflags xcb xcb-xkb 2>/dev/null`"
                QMAKE_LIBS_XKB="`$PKG_CONFIG --libs xcb xcb-xkb 2>/dev/null`"
                if compileTest qpa/xcb-xkb "xcb-xkb" $QMAKE_CFLAGS_XKB $QMAKE_LIBS_XKB; then
                    CFG_XKB=yes
                fi
            fi
            if [ "$CFG_XKB" = "no" ]; then
                QMakeVar add DEFINES QT_NO_XKB
            fi

            if compileTest qpa/xcb-syslibs "xcb-syslibs" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
                if compileTest qpa/xcb-render "xcb-render" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
                    QT_CONFIG="$QT_CONFIG xcb-render"
                fi

                if compileTest qpa/xcb-glx "xcb-glx" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
                    CFG_XCB_GLX=yes
                    QT_CONFIG="$QT_CONFIG xcb-glx"
                fi
            else
                echo "The test for linking against libxcb and support libraries failed!"
                echo " You might need to install dependency packages, or pass -qt-xcb."
                echo " See src/plugins/platforms/xcb/README."
                exit 1
            fi
        fi

        if [ "$CFG_XCB_XLIB" != "no" ]; then
            if compileTest qpa/xcb-xlib "xcb-xlib" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
                QT_CONFIG="$QT_CONFIG xcb-xlib"
                CFG_XCB_XLIB=yes
            else
                CFG_XCB_XLIB=no
            fi
        fi

        if [ "$CFG_SM" != "no" ] && [ -n "$PKG_CONFIG" ]; then
            if $PKG_CONFIG --exists "sm" 2>/dev/null && $PKG_CONFIG --exists "ice" 2>/dev/null; then
                QT_CONFIG="$QT_CONFIG xcb-sm"
            fi
        fi
    else
        if [ "$CFG_XCB" != "auto" ]; then
            echo "The test for linking against libxcb failed!"
            echo " You might need to install dependency packages for libxcb."
            echo " See src/plugins/platforms/xcb/README."
            exit 1
        fi
        CFG_XCB=no
    fi
fi

if [ "$CFG_DIRECTFB" != "no" ]; then
    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists directfb 2>/dev/null; then
        QMAKE_CFLAGS_DIRECTFB=`$PKG_CONFIG --cflags directfb 2>/dev/null`
        QMAKE_LIBS_DIRECTFB=`$PKG_CONFIG --libs directfb 2>/dev/null`
        if compileTest qpa/directfb "DirectFB" $QMAKE_CFLAGS_DIRECTFB $QMAKE_LIBS_DIRECTFB; then
            CFG_DIRECTFB=yes
        elif [ "$CFG_DIRECTFB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo " DirectFB 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_DIRECTFB=no
        fi
    else
        CFG_DIRECTFB=no
    fi
fi

if [ "$CFG_LINUXFB" != "no" ]; then
    if compileTest qpa/linuxfb "LinuxFB"; then
        CFG_LINUXFB=yes
    elif [ "$CFG_LINUXFB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
        echo " Linux Framebuffer 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_LINUXFB=no
    fi
fi

if [ "$CFG_KMS" != "no" ]; then
    if compileTest qpa/kms "KMS"; then
        CFG_KMS=yes
    elif [ "$CFG_KMS" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
        echo " KMS 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_KMS=no
    fi
fi

# Detect libxkbcommon
MIN_REQ_XKBCOMMON="0.4.1"
ORIG_CFG_XKBCOMMON="$CFG_XKBCOMMON"
# currently only xcb platform plugin supports building xkbcommon
if [ "$CFG_XCB" != "no" ]; then
    if [ "$CFG_XKBCOMMON" = "auto" ] || [ "$CFG_XKBCOMMON" = "system" ]; then
        if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xkbcommon xkbcommon-x11 >= $MIN_REQ_XKBCOMMON" 2>/dev/null; then
            QMAKE_CFLAGS_XKBCOMMON="`$PKG_CONFIG --cflags xkbcommon xkbcommon-x11 2>/dev/null`"
            QMAKE_LIBS_XKBCOMMON="`$PKG_CONFIG --libs xkbcommon xkbcommon-x11 2>/dev/null`"

            QMakeVar set QMAKE_CFLAGS_XKBCOMMON "$QMAKE_CFLAGS_XKBCOMMON"
            QMakeVar set QMAKE_LIBS_XKBCOMMON "$QMAKE_LIBS_XKBCOMMON"
            CFG_XKBCOMMON=system
        else
            # use the bundled version instead
            CFG_XKBCOMMON=qt
        fi
    fi
    if [ "$CFG_XKBCOMMON" = "qt" ]; then
        QT_CONFIG="$QT_CONFIG xkbcommon-qt"
        # detect XKB config root
        if [ "$CFG_XKB_CONFIG_ROOT" = "auto" ]; then
            if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "xkeyboard-config" 2> /dev/null; then
                CFG_XKB_CONFIG_ROOT="`$PKG_CONFIG --variable=xkb_base xkeyboard-config`"
            else
                # search for xkb configs in most probable locations
                if [ -d "/usr/share/X11/xkb" ]; then
                    # Linux
                    CFG_XKB_CONFIG_ROOT="/usr/share/X11/xkb"
                elif [ -d "/usr/local/share/X11/xkb" ]; then
                    # BSD UNIX
                    CFG_XKB_CONFIG_ROOT="/usr/local/share/X11/xkb"
                fi
            fi
        fi
        QMakeVar set QMAKE_XKB_CONFIG_ROOT "$CFG_XKB_CONFIG_ROOT"
        if [ "$CFG_XKB_CONFIG_ROOT" = "auto" ]; then
            CFG_XKB_CONFIG_ROOT="not found"
        fi
    fi
else
    CFG_XKBCOMMON=no
fi

# EGL Support
if [ "$CFG_EGL" != "no" ]; then
    if [ "$CFG_EGL" = "yes" ] && [ "$CFG_OPENGL" = "no" ]; then
        echo "EGL support was requested but OpenGL support is disabled."
        echo "Either disable EGL support or enable OpenGL support."
        exit 101
    fi

    if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists egl 2>/dev/null; then
        QMAKE_INCDIR_EGL=`$PKG_CONFIG --cflags-only-I egl 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
        QMAKE_LIBS_EGL=`$PKG_CONFIG --libs egl 2>/dev/null`
        QMAKE_CFLAGS_EGL=`$PKG_CONFIG --cflags egl 2>/dev/null`
        QMakeVar set QMAKE_INCDIR_EGL "$QMAKE_INCDIR_EGL"
        QMakeVar set QMAKE_LIBS_EGL "$QMAKE_LIBS_EGL"
        QMakeVar set QMAKE_CFLAGS_EGL "`echo " $QMAKE_CFLAGS_EGL " | sed -e 's, -I[^ ]* , ,g;s,^ ,,;s, $,,'`"
    fi       # detect EGL support
    if compileTest qpa/egl "EGL" $QMAKE_CFLAGS_EGL $QMAKE_LIBS_EGL; then
        CFG_EGL=yes
        if compileTest qpa/egl-x11 "EGL-X11" $QMAKE_CFLAGS_EGL $QMAKE_LIBS_EGL; then
            CFG_EGL_X=yes
        else
            CFG_EGL_X=no
        fi
    elif [ "$CFG_EGL" = "yes" ]; then
        echo " The EGL functionality test failed; EGL is required by some QPA plugins 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 ${XQMAKESPEC}."
        exit 1
    else
        CFG_EGL=no
        CFG_EGL_X=no
    fi
fi

if [ "$CFG_EGLFS" != "no" ]; then
    if [ "$XPLATFORM_QNX" = "no" ] && [ "$CFG_OPENGL" != "no" ]; then
        CFG_EGLFS="$CFG_EGL"
    else
        CFG_EGLFS="no"
    fi
fi

if [ "$CFG_KMS" = "yes" ]; then
    if [ "$CFG_EGL" = "yes" ]; then
        CFG_KMS="yes"
    else
        CFG_KMS="no"
    fi
fi

# Detect accessibility support
if [ "$CFG_ACCESSIBILITY" = "no" ]; then
    echo >&2 "Warning: Disabling Accessibility. This version of Qt is unsupported."
else
    CFG_ACCESSIBILITY=yes

    # linux/xcb accessibility bridge needs dbus
    if [ "$CFG_XCB" != "no" ]; then
        if [ "$CFG_DBUS" != "no" ]; then
            CFG_ACCESSIBILITY_ATSPI_BRIDGE=yes
            QT_CONFIG="$QT_CONFIG accessibility-atspi-bridge"
        else
            echo >&2 "Warning: Disabling Linux Accessibility Bridge: DBus is missing."
            QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ACCESSIBILITY_ATSPI_BRIDGE"
        fi
    fi
fi

# Determine the default QPA platform
if [ -z "$QT_QPA_DEFAULT_PLATFORM" ]; then
    # check the mkspec
    QT_QPA_DEFAULT_PLATFORM=`getXQMakeConf QT_QPA_DEFAULT_PLATFORM`
    if [ -z "$QT_QPA_DEFAULT_PLATFORM" ]; then
        if [ "$XPLATFORM_MINGW" = "yes" ]; then
            QT_QPA_DEFAULT_PLATFORM="windows"
        elif [ "$XPLATFORM_MAC" = "yes" ]; then
            QT_QPA_DEFAULT_PLATFORM="cocoa"
        elif [ "$UNAME_SYSTEM" = "QNX" ]; then
            QT_QPA_DEFAULT_PLATFORM="qnx"
        else
            QT_QPA_DEFAULT_PLATFORM="xcb"
        fi
    fi
fi

if [ -n "$QMAKE_CFLAGS_XCB" ] || [ -n "$QMAKE_LIBS_XCB" ]; then
    QMakeVar set QMAKE_CFLAGS_XCB "$QMAKE_CFLAGS_XCB"
    QMakeVar set QMAKE_LIBS_XCB "$QMAKE_LIBS_XCB"
fi

if [ "$CFG_DIRECTFB" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG directfb"
    QMakeVar set QMAKE_CFLAGS_DIRECTFB "$QMAKE_CFLAGS_DIRECTFB"
    QMakeVar set QMAKE_LIBS_DIRECTFB "$QMAKE_LIBS_DIRECTFB"
fi
if [ "$CFG_LINUXFB" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG linuxfb"
fi
if [ "$CFG_KMS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG kms"
fi

if [ "$XPLATFORM_MAC" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] && [ "$XPLATFORM_QNX" = "no" ] && [ "$XPLATFORM_ANDROID" = "no" ]; then
    if [ "$CFG_XCB" = "no" ] && [ "$CFG_EGLFS" = "no" ] && [ "$CFG_DIRECTFB" = "no" ] && [ "$CFG_LINUXFB" = "no" ] && [ "$CFG_KMS" = "no" ]; then
        if [ "$QPA_PLATFORM_GUARD" = "yes" ] &&
            ( [ "$ORIG_CFG_XCB" = "auto" ] || [ "$ORIG_CFG_EGLFS" = "auto" ] || [ "$ORIG_CFG_DIRECTFB" = "auto" ] || [ "$ORIG_CFG_LINUXFB" = "auto" ] || [ "$ORIG_CFG_KMS" = "auto" ] ); then
        echo "No QPA platform plugin enabled!"
        echo " If you really want to build without a QPA platform plugin you must pass"
        echo " -no-qpa-platform-guard to configure. Doing this will"
        echo " produce a Qt that can not run GUI applications."
        echo " The dependencies needed for xcb to build are listed in"
        echo " src/plugins/platforms/xcb/README"
        exit 1
    fi
fi
    fi

# freetype support
[ "$XPLATFORM_MINGW" = "yes" ] && [ "$CFG_FREETYPE" = "auto" ] && CFG_FREETYPE=no
if [ "$CFG_FREETYPE" = "auto" ]; then
    if compileTest unix/freetype "FreeType"; then
        CFG_FREETYPE=system
    else
        CFG_FREETYPE=yes
    fi
fi

# harfbuzz support
[ "$XPLATFORM_MAC" = "yes" ] && [ "$CFG_HARFBUZZ" = "auto" ] && CFG_HARFBUZZ=yes
[ "$CFG_HARFBUZZ" = "auto" ] && CFG_HARFBUZZ=no # disable auto-detection on non-Mac for now
if [ "$CFG_HARFBUZZ" = "auto" ]; then
    if compileTest unix/harfbuzz "HarfBuzz"; then
        CFG_HARFBUZZ=system
    else
        CFG_HARFBUZZ=yes
    fi
fi
if [ "$XPLATFORM_MAC" = "yes" -a "$CFG_HARFBUZZ" = "system" ]; then
    echo
    echo "WARNING: AAT is not supported with -system-harfbuzz on Mac OS X."
    echo
fi

if ! compileTest unix/stl "STL" &&
    [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
    echo "STL functionality check failed! Cannot build Qt with this STL library."
    echo " Turn on verbose messaging (-v) to $0 to see the final report."
    exit 101
fi


# detect POSIX clock_gettime()
if [ "$CFG_CLOCK_GETTIME" = "auto" ]; then
    if compileTest unix/clock-gettime "POSIX clock_gettime()"; 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 compileTest unix/clock-monotonic "POSIX Monotonic Clock"; then
	CFG_CLOCK_MONOTONIC=yes
    else
	CFG_CLOCK_MONOTONIC=no
    fi
elif [ "$CFG_CLOCK_GETTIME" = "no" ]; then
    CFG_CLOCK_MONOTONIC=no
fi

# detect posix_fallocate
if [ "$CFG_POSIX_FALLOCATE" = "auto" ]; then
    if compileTest unix/posix_fallocate "posix_fallocate"; then
        CFG_POSIX_FALLOCATE=yes
    else
        CFG_POSIX_FALLOCATE=no
    fi
fi

# detect mremap
if [ "$CFG_MREMAP" = "auto" ]; then
    if compileTest unix/mremap "mremap"; 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 compileTest unix/getaddrinfo "getaddrinfo"; 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 compileTest unix/inotify "inotify"; 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 eventfd
if [ "$CFG_EVENTFD" != "no" ]; then
    if compileTest unix/eventfd "eventfd"; then
        CFG_EVENTFD=yes
    else
        if [ "$CFG_EVENTFD" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "eventfd 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_EVENTFD=no
        fi
    fi
fi

# find if the platform provides if_nametoindex (ipv6 interface name support)
if [ "$CFG_IPV6IFNAME" != "no" ]; then
    if compileTest unix/ipv6ifname "IPv6 interface name"; 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 compileTest unix/getifaddrs "getifaddrs"; 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" ]; then
    if compileTest unix/openssl "OpenSSL"; then
        if [ "$CFG_OPENSSL" = "auto" ]; then
            CFG_OPENSSL=yes
        fi
    else
        if ( [ "$CFG_OPENSSL" = "yes" ] || [ "$CFG_OPENSSL" = "linked" ] ) && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]  && [ "$XPLATFORM_ANDROID" = "no" ]; 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
fi

# detect PCRE
if [ "$CFG_PCRE" != "qt" ]; then
    if compileTest unix/pcre "PCRE"; then
        CFG_PCRE=system
    else
        if [ "$CFG_PCRE" = "system" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
            echo "PCRE 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_PCRE=qt
        fi
    fi
fi

# detect OpenVG support
if [ "$CFG_OPENVG" != "no" ]; then
    if compileTest unix/openvg "OpenVG"; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
    elif compileTest unix/openvg "OpenVG" -config openvg_on_opengl; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
        CFG_OPENVG_ON_OPENGL=yes
    elif compileTest unix/openvg "OpenVG (lc includes)" -config lower_case_includes; then
        if [ "$CFG_OPENVG" = "auto" ]; then
            CFG_OPENVG=yes
        fi
        CFG_OPENVG_LC_INCLUDES=yes
    elif compileTest unix/openvg "OpenVG (lc includes)" -config "openvg_on_opengl lower_case_includes"; 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" ] && compileTest unix/shivavg "ShivaVG"; then
        CFG_OPENVG_SHIVA=yes
    fi
fi

if [ "$CFG_ALSA" = "auto" ]; then
    if compileTest unix/alsa "alsa"; then
        CFG_ALSA=yes
    else
        CFG_ALSA=no
    fi
fi

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

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

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

[ "$CFG_CXX11" = "yes" ] && QT_CONFIG="$QT_CONFIG c++11"

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

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

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

# enable egl on X
if [ "$CFG_EGL_X" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG egl_x11"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGL_X11"
fi

# enable eglfs
if [ "$CFG_EGLFS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG eglfs"
else
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EGLFS"
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

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

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

if [ "$CFG_SHARED" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG shared"
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG shared"
elif [ "$CFG_SHARED" = "no" ]; then
    QT_CONFIG="$QT_CONFIG static"
    QTCONFIG_CONFIG="$QTCONFIG_CONFIG static"
fi

#FIXME: qpa is implicit this should all be removed
QMAKE_CONFIG="$QMAKE_CONFIG qpa"
QT_CONFIG="$QT_CONFIG qpa"
QTCONFIG_CONFIG="$QTCONFIG_CONFIG qpa"

if [ "$CFG_LARGEFILE" = "yes" ] && [ "$XPLATFORM_MINGW" != "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG largefile"
fi
if [ "$CFG_USE_GNUMAKE" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG GNUmake"
fi
[ "$CFG_REDUCE_EXPORTS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_exports"
[ "$CFG_STACK_PROTECTOR_STRONG" = "yes" ] && QT_CONFIG="$QT_CONFIG stack-protector-strong"
[ "$CFG_REDUCE_RELOCATIONS" = "yes" ] && QT_CONFIG="$QT_CONFIG reduce_relocations"
[ "$CFG_STRIP" = "no" ] && QMAKE_CONFIG="$QMAKE_CONFIG nostrip"
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG separate_debug_info"
fi
[ "$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_AVX2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG avx2"
[ "$CFG_IWMMXT" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG iwmmxt"
if [ "$CFG_ARCH" = "mips" ]; then
    [ "$CFG_MIPS_DSP" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG mips_dsp"
    [ "$CFG_MIPS_DSPR2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG mips_dspr2"
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_POSIX_FALLOCATE" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG posix_fallocate"
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_EVENTFD" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG eventfd"
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_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_FREETYPE" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-freetype"
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
elif [ "$CFG_FREETYPE" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-freetype"
else
    QT_CONFIG="$QT_CONFIG freetype"
fi
if [ "$CFG_HARFBUZZ" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-harfbuzz"
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_HARFBUZZ"
elif [ "$CFG_HARFBUZZ" = "system" ]; then
    QT_CONFIG="$QT_CONFIG system-harfbuzz"
else
    QT_CONFIG="$QT_CONFIG harfbuzz"
fi
if [ "$CFG_GUI" = "auto" ]; then
    CFG_GUI="yes"
fi
if [ "$CFG_GUI" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-gui"
    CFG_WIDGETS="no"
fi
if [ "$CFG_WIDGETS" = "no" ]; then
    QT_CONFIG="$QT_CONFIG no-widgets"
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_WIDGETS"
fi

if [ "$XPLATFORM_MAC" = "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

[ "$CFG_MTDEV" = "yes" ] && QT_CONFIG="$QT_CONFIG mtdev"
[ "$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_DBUS" = "yes" ] && QT_CONFIG="$QT_CONFIG dbus"
[ "$CFG_DBUS" = "linked" ] && QT_CONFIG="$QT_CONFIG dbus dbus-linked"
[ "$CFG_OPENSSL" = "yes" ] && QT_CONFIG="$QT_CONFIG openssl"
[ "$CFG_OPENSSL" = "linked" ] && QT_CONFIG="$QT_CONFIG openssl-linked"
[ "$CFG_XCB" != "no" ] && QT_CONFIG="$QT_CONFIG xcb"
[ "$CFG_XINPUT2" = "yes" ] && QT_CONFIG="$QT_CONFIG xinput2"
[ "$CFG_SYSTEM_PROXIES" = "yes" ] && QT_CONFIG="$QT_CONFIG system-proxies"
[ "$CFG_DIRECTWRITE" = "yes" ] && QT_CONFIG="$QT_CONFIG directwrite"

[ '!' -z "$DEFINES" ] && QMakeVar add DEFINES "$DEFINES"
[ '!' -z "$INCLUDES" ] && QMakeVar add INCLUDEPATH "$INCLUDES"
[ '!' -z "$L_FLAGS" ] && QMakeVar add LIBS "$L_FLAGS"

if [ "$XPLATFORM_MAC" = "yes" ] && [ "$QT_CROSS_COMPILE" = "no" ]; then
    if [ "$CFG_RPATH" = "yes" ]; then
       QMAKE_CONFIG="$QMAKE_CONFIG absolute_library_soname"
    fi
elif [ -z "`getXQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; 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 [ -n "$RPATH_FLAGS" ]; then
        # add the user defined rpaths
	QMakeVar add QMAKE_RPATHDIR "$RPATH_FLAGS"
    fi
fi
if [ "$CFG_RPATH" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG rpath"
fi

if [ '!' -z "$W_FLAGS" ]; then
    # add the user defined warning flags
    QMakeVar add QMAKE_CFLAGS_WARN_ON "$W_FLAGS"
    QMakeVar add QMAKE_CXXFLAGS_WARN_ON "$W_FLAGS"
    QMakeVar add QMAKE_OBJECTIVE_CFLAGS_WARN_ON "$W_FLAGS"
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_ICU" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG icu"
fi

if [ "$CFG_FORCE_ASSERTS" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG force_asserts"
fi

if [ "$CFG_PCRE" = "qt" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG pcre"
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.
#
canBuildQtConcurrent="yes"

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"
	;;
esac

if [ "$CFG_GUI" = "no" ]; then
    # WebKit requires Qt GUI
    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"
else
    QT_CONFIG="$QT_CONFIG concurrent"
fi

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

# ### Vestige
if [ "$CFG_WEBKIT" = "debug" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG webkit-debug"
fi

# ### Vestige
if [ "$CFG_QML_DEBUG" = "no" ]; then
    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QML_NO_DEBUGGER"
fi

case "$QMAKE_CONF_COMPILER" in
*clang*)
    # Clang
    COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -v 2>&1 | sed -n -E '
/^Apple (clang|LLVM) version /{s///; s/^([0-9]*)\.([0-9]*).*$/QT_APPLE_CLANG_MAJOR_VERSION=\1; QT_APPLE_CLANG_MINOR_VERSION=\2/;p;q;}
/^clang version /{s///; s/^([0-9]*)\.([0-9]*).*$/QT_CLANG_MAJOR_VERSION=\1; QT_CLANG_MINOR_VERSION=\2/;p;q;}'`
    eval "$COMPILER_VERSION"
    ;;
*icpc)
    # Intel CC
    COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -v 2>&1 | sed -n '
s/icpc version \([0-9]*\)\.\([0-9]*\)\.\([0-9]*\) .*$/QT_ICC_MAJOR_VERSION=\1; QT_ICC_MINOR_VERSION=\2; QT_ICC_PATCH_VERSION=\3/p'`
    eval "$COMPILER_VERSION"
    ;;
*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

    ;;
*)
    #
    ;;
esac

#-------------------------------------------------------------------------------
# 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"
    cat "$CFG_QCONFIG_PATH" >>"$tmpconfig"
    echo "#endif" >>"$tmpconfig"
    ;;
esac

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_SHARED" = "no" ]; then
    cat >>"$outpath/src/corelib/global/qconfig.h.new" <<EOF
/* Qt was configured for a static build */
#if !defined(QT_SHARED) && !defined(QT_STATIC)
# define QT_STATIC
#endif

EOF
fi

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

if [ "$CFG_QREAL" != double ]; then
    echo "#define QT_COORD_TYPE $CFG_QREAL" >>"$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 [ "$XPLATFORM_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

#REDUCE_RELOCATIONS is a elf/unix only thing, so not in windows configure.exe
if [ "$CFG_REDUCE_RELOCATIONS" = "yes" ]; then
    echo "#define QT_REDUCE_RELOCATIONS" >>"$outpath/src/corelib/global/qconfig.h.new"
fi

# Add compiler sub-architecture support
echo "" >>"$outpath/src/corelib/global/qconfig.h.new"
echo "// Compiler sub-arch support" >>"$outpath/src/corelib/global/qconfig.h.new"
for SUBARCH in SSE2 SSE3 SSSE3 SSE4_1 SSE4_2 AVX AVX2 \
    IWMMXT \
    MIPS_DSP MIPS_DSPR2; do
    eval "VAL=\$CFG_$SUBARCH"
    case "$VAL" in
        yes)
            echo "#define QT_COMPILER_SUPPORTS_$SUBARCH" \
                >>"$outpath/src/corelib/global/qconfig.h.new"
            ;;
    esac
done

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

# Add QPA to config.h
QCONFIG_FLAGS="$QCONFIG_FLAGS"

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_PNG" != "yes" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
[ "$CFG_JPEG" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
[ "$CFG_ZLIB" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ZLIB"
[ "$CFG_DBUS" = "no" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DBUS"

# 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_EVDEV" = "no" ]      && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EVDEV"
[ "$CFG_GLIB" != "yes" ]     && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_GLIB"
[ "$CFG_QGTKSTYLE" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_STYLE_GTK"
[ "$CFG_CLOCK_MONOTONIC" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CLOCK_MONOTONIC"
[ "$CFG_POSIX_FALLOCATE" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_POSIX_FALLOCATE"
[ "$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_EVENTFD" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_EVENTFD"
[ "$CFG_NIS" = "no" ]        && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NIS"
[ "$CFG_OPENSSL" = "no" ]    && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENSSL QT_NO_SSL"
[ "$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"

# 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 [ -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

echo "#define QT_QPA_DEFAULT_PLATFORM_NAME \"$QT_QPA_DEFAULT_PLATFORM\"" >>"$outpath/src/corelib/global/qconfig.h.new"

# 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
    mv -f "$outpath/src/corelib/global/qconfig.h.new" "$outpath/src/corelib/global/qconfig.h"
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_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 [ "$CFG_DEV" = "yes" ]; then
    QT_CONFIG="$QT_CONFIG private_tests"
    if [ "$CFG_WERROR" != "no" ]; then
        QMAKE_CONFIG="$QMAKE_CONFIG warnings_are_errors"
    fi
elif [ "$CFG_WERROR" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG warnings_are_errors"
fi

cat >>"$QTCONFIG.tmp" <<EOF
#configuration
CONFIG += $QTCONFIG_CONFIG
host_build {
    QT_ARCH = $CFG_HOST_ARCH
    QT_TARGET_ARCH = $CFG_ARCH
} else {
    QT_ARCH = $CFG_ARCH
    QMAKE_DEFAULT_LIBDIRS = `shellQuoteLines "$DEFAULT_LIBDIRS"`
    QMAKE_DEFAULT_INCDIRS = `shellQuoteLines "$DEFAULT_INCDIRS"`
}
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

EOF

if [ "$CFG_SHARED" = "no" ]; then
    echo "QT_DEFAULT_QPA_PLUGIN = q$QT_QPA_DEFAULT_PLATFORM" >> "$QTCONFIG.tmp"
    echo >> "$QTCONFIG.tmp"
fi

if [ -n "$PKG_CONFIG_SYSROOT_DIR" ] || [ -n "$PKG_CONFIG_LIBDIR" ]; then
    echo "# pkgconfig" >> "$QTCONFIG.tmp"
    echo "PKG_CONFIG_SYSROOT_DIR = $PKG_CONFIG_SYSROOT_DIR" >> "$QTCONFIG.tmp"
    echo "PKG_CONFIG_LIBDIR = $PKG_CONFIG_LIBDIR" >> "$QTCONFIG.tmp"
    echo >> "$QTCONFIG.tmp"
fi

if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
    echo "# sysroot" >>"$QTCONFIG.tmp"
    echo "!host_build {" >>"$QTCONFIG.tmp"
    echo "    QMAKE_CFLAGS    += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
    echo "    QMAKE_CXXFLAGS  += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
    echo "    QMAKE_LFLAGS    += --sysroot=\$\$[QT_SYSROOT]" >>"$QTCONFIG.tmp"
    echo "}" >> "$QTCONFIG.tmp"
    echo >> "$QTCONFIG.tmp"
fi
if [ -n "$RPATH_FLAGS" ]; then
    echo "QMAKE_RPATHDIR += $RPATH_FLAGS" >> "$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_ICC_MAJOR_VERSION" ]; then
    echo "QT_ICC_MAJOR_VERSION = $QT_ICC_MAJOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_ICC_MINOR_VERSION = $QT_ICC_MINOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_ICC_PATCH_VERSION = $QT_ICC_PATCH_VERSION" >> "$QTCONFIG.tmp"
fi
if [ -n "$QT_CLANG_MAJOR_VERSION" ]; then
    echo "QT_CLANG_MAJOR_VERSION = $QT_CLANG_MAJOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_CLANG_MINOR_VERSION = $QT_CLANG_MINOR_VERSION" >> "$QTCONFIG.tmp"
fi
if [ -n "$QT_APPLE_CLANG_MAJOR_VERSION" ]; then
    echo "QT_APPLE_CLANG_MAJOR_VERSION = $QT_APPLE_CLANG_MAJOR_VERSION" >> "$QTCONFIG.tmp"
    echo "QT_APPLE_CLANG_MINOR_VERSION = $QT_APPLE_CLANG_MINOR_VERSION" >> "$QTCONFIG.tmp"
fi

if [ -n "$QMAKE_INCDIR_OPENGL_ES2" ]; then
    echo "#Qt opengl include path" >> "$QTCONFIG.tmp"
    echo "QMAKE_INCDIR_OPENGL_ES2 = `shellArgumentListToQMakeList "$QMAKE_INCDIR_OPENGL_ES2"`" >> "$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 qmodule.pri
#-------------------------------------------------------------------------------
QTMODULE="$outpath/mkspecs/qmodule.pri"

echo "CONFIG += $QMAKE_CONFIG" >> "$QTMODULE.tmp"
echo "QT_BUILD_PARTS += $CFG_BUILD_PARTS" >> "$QTMODULE.tmp"
if [ -n "$CFG_SKIP_MODULES" ]; then
    echo "QT_SKIP_MODULES += $CFG_SKIP_MODULES" >> "$QTMODULE.tmp"
fi
DISABLED_FEATURES=
for cfg in $QCONFIG_FLAGS; do
    ncfg=${cfg#QT_NO_}
    if [ x$ncfg != x$cfg ]; then
        DISABLED_FEATURES="$DISABLED_FEATURES $ncfg"
    fi
done
if [ -n "$DISABLED_FEATURES" ]; then
    echo "QT_NO_DEFINES = $DISABLED_FEATURES" >> "$QTMODULE.tmp"
fi
echo "QT_QCONFIG_PATH = ${CFG_QCONFIG_PATH#$relpath/src/corelib/global/}" >> "$QTMODULE.tmp"

cat >>"$QTMODULE.tmp" <<EOF
host_build {
    QT_CPU_FEATURES.$CFG_HOST_ARCH = $CFG_HOST_CPUFEATURES
} else {
    QT_CPU_FEATURES.$CFG_ARCH = $CFG_CPUFEATURES
}
EOF
echo "QT_COORD_TYPE = $CFG_QREAL" >> "$QTMODULE.tmp"

if [ -n "$QT_CFLAGS_PSQL" ]; then
    echo "QT_CFLAGS_PSQL   = $QT_CFLAGS_PSQL" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_LFLAGS_PSQL" ]; then
    echo "QT_LFLAGS_PSQL   = $QT_LFLAGS_PSQL" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_CFLAGS_MYSQL" ]; then
    echo "QT_CFLAGS_MYSQL   = $QT_CFLAGS_MYSQL" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_LFLAGS_MYSQL" ]; then
    echo "QT_LFLAGS_MYSQL   = $QT_LFLAGS_MYSQL" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_CFLAGS_SQLITE" ]; then
    echo "QT_CFLAGS_SQLITE   = $QT_CFLAGS_SQLITE" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_LFLAGS_SQLITE" ]; then
    echo "QT_LFLAGS_SQLITE   = $QT_LFLAGS_SQLITE" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_LFLAGS_ODBC" ]; then
    echo "QT_LFLAGS_ODBC   = $QT_LFLAGS_ODBC" >> "$QTMODULE.tmp"
fi
if [ -n "$QT_LFLAGS_TDS" ]; then
    echo "QT_LFLAGS_TDS   = $QT_LFLAGS_TDS" >> "$QTMODULE.tmp"
fi

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

# cmdline args
cat "$QMAKE_VARS_FILE" >> "$QTMODULE.tmp"
# QMAKE_VARS_FILE will be still needed for a status message.

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

#-------------------------------------------------------------------------------
# give feedback on configuration
#-------------------------------------------------------------------------------
exec 3>&1 1>$outpath/config.summary # redirect output temporarily to config.summary

report_support()
{
    case "$#,$2" in
        2,auto)
            # 2 arguments and the result is "auto", so just say "yes"
            # this is usually an error in the configure script, but oh well..
            echo "$1 yes"
            return
            ;;
        [012],* | *,no*)
            # 0, 1 or 2 arguments, or anything starting with "no"
            # print just the first part of the argument (before the dash)
            echo "$1 ${2%%-*}"
            return
            :;
    esac
    heading=$1
    shift

    value=$1
    shift

    while [ $# -gt 0 ]; do
        if [ "$value" = "$1" ]; then
            echo "$heading yes ($2)"
            return
        fi
        shift
        shift
    done
    echo "$heading $value"
}

report_support_plugin()
{
    report_support "$1" "$2-$3" \
        yes-qt "in $4, using bundled copy" \
        yes-system "in $4, using system library" \
        plugin-qt "plugin, using bundled copy" \
        plugin-system "plugin, using system library"
}

echo
echo "   Configure summary"
echo
if [ "$XPLATFORM" = "$PLATFORM" ]; then
    # the missing space before $CFG_FEATURES is intentional
    echo "Build type:    $PLATFORM ($CFG_ARCH, CPU features:${CFG_CPUFEATURES- none detected})"
else
    echo "Building on:   $PLATFORM ($CFG_HOST_ARCH, CPU features:${CFG_HOST_CPUFEATURES- none detected})"
    echo "Building for:  $XPLATFORM ($CFG_ARCH, CPU features:${CFG_CPUFEATURES- none detected})"
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"
    echo
fi

# Build configuration
echo "Build options:"
echo $ECHO_N "  Configuration .......... $ECHO_C"
echo $QMAKE_CONFIG $QT_CONFIG | tr ' ' '\n' | sort | tr '\n' ' '
echo
echo "  Build parts ............ $CFG_BUILD_PARTS"
release="release"
[ "$CFG_FORCEDEBUGINFO" = "yes" ] && release="release (with debug info)"
[ "$CFG_DEBUG" = "yes" ] && build_mode="debug" || build_mode=$release
if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
   echo "  Mode ................... debug and $release; default link: $build_mode"
else
   echo "  Mode ................... $build_mode"
fi
unset build_mode release
echo "  Using C++11 ............ $CFG_CXX11"
echo "  Using PCH .............. $CFG_PRECOMPILE"
echo "  Target compiler supports:"
if [ "$CFG_ARCH" = "i386" -o "$CFG_ARCH" = "x86_64" ]; then
    echo "    SSE2/SSE3/SSSE3 ...... ${CFG_SSE2}/${CFG_SSE3}/${CFG_SSSE3}"
    echo "    SSE4.1/SSE4.2 ........ ${CFG_SSE4_1}/${CFG_SSE4_2}"
    echo "    AVX/AVX2 ............. ${CFG_AVX}/${CFG_AVX2}"
elif [ "$CFG_ARCH" = "arm" ]; then
    echo "    iWMMXt/Neon .......... ${CFG_IWMMXT}/${CFG_NEON}"
elif [ "$CFG_ARCH" = "mips" ]; then
    echo "    DSP/DSPr2 ............ ${CFG_MIPS_DSP}/${CFG_MIPS_DSPR2}"
fi

# Qt modules
echo
echo "Qt modules and options:"
report_support "  Qt D-Bus ..............." "$CFG_DBUS" yes "loading dbus-1 at runtime" linked "linked to dbus-1"
report_support "  Qt Concurrent .........." "$CFG_CONCURRENT"
report_support "  Qt GUI ................." "$CFG_GUI"
report_support "  Qt Widgets ............." "$CFG_WIDGETS"
report_support "  Large File ............." "$CFG_LARGEFILE"
report_support "  QML debugging .........." "$CFG_QML_DEBUG"
report_support "  Use system proxies ....." "$CFG_SYSTEM_PROXIES"

# Other things
# Please keep sorted and properly grouped! The output is quite long, so it's
# hard to find something you're searching for if it's not sorted.
echo
echo "Support enabled for:"
report_support "  Accessibility .........." "$CFG_ACCESSIBILITY"
report_support "  ALSA ..................." "$CFG_ALSA"
report_support "  CUPS ..................." "$CFG_CUPS"
[ "$XPLATFORM_MINGW" = "yes" ] && \
    report_support "  DirectWrite ............" "$CFG_DIRECTWRITE"
report_support "  Evdev .................." "$CFG_EVDEV"
report_support "  FontConfig ............." "$CFG_FONTCONFIG"
report_support "  FreeType ..............." "$CFG_FREETYPE" system "system library" yes "bundled copy"
report_support "  Glib ..................." "$CFG_GLIB"
report_support "  GTK theme .............." "$CFG_QGTKSTYLE"
report_support "  HarfBuzz ..............." "$CFG_HARFBUZZ"
report_support "  Iconv .................." "$CFG_ICONV"
report_support "  ICU ...................." "$CFG_ICU"
report_support "  Image formats:"
report_support_plugin "    GIF .................." "$CFG_GIF" qt QtGui
report_support_plugin "    JPEG ................." "$CFG_JPEG" "$CFG_LIBJPEG" QtGui
report_support_plugin "    PNG .................." "$CFG_PNG" "$CFG_LIBPNG" QtGui
report_support "  journald ..............." "$CFG_JOURNALD"
report_support "  mtdev .................." "$CFG_MTDEV" yes "system library"
report_support "  Networking:"
[ "$XPLATFORM_MAC" = "yes" ] && \
    report_support "    CoreWlan ............." "$CFG_COREWLAN"
report_support "    getaddrinfo .........." "$CFG_GETADDRINFO"
report_support "    getifaddrs ..........." "$CFG_GETIFADDRS"
report_support "    IPv6 ifname .........." "$CFG_IPV6IFNAME"
report_support "    OpenSSL .............." "$CFG_OPENSSL" yes "loading libraries at run-time" linked "linked to the libraries"
report_support "  NIS ...................." "$CFG_NIS"
report_support "  OpenGL / OpenVG:"
report_support "    EGL .................." "$CFG_EGL"
report_support "    OpenGL ..............." "$CFG_OPENGL" yes "Desktop OpenGL" es2 "OpenGL ES 2.x"
report_support "    OpenVG ..............." "$CFG_OPENVG-$CFG_OPENVG_SHIVA" yes-yes "ShivaVG" yes-no "native"
report_support "  PCRE ..................." "$CFG_PCRE" yes "system library" qt "bundled copy"
if [ -n "$PKG_CONFIG" ]; then
    report_support "  pkg-config ............. yes"
else
    report_support "  pkg-config ............. no"
fi
report_support "  PulseAudio ............." "$CFG_PULSEAUDIO"
report_support "  QPA backends:"
report_support "    DirectFB ............." "$CFG_DIRECTFB"
report_support "    EGLFS ................" "$CFG_EGLFS"
report_support "    KMS .................." "$CFG_KMS"
report_support "    LinuxFB .............." "$CFG_LINUXFB"
report_support "    XCB .................." "$CFG_XCB" system "system library" qt "bundled copy"
if [ "$CFG_XCB" != "no" ]; then
    report_support "      EGL on X ..........." "$CFG_EGL_X"
    report_support "      GLX ................" "$CFG_XCB_GLX"
    report_support "      MIT-SHM ............" "$CFG_MITSHM"
    report_support "      Xcb-Xlib ..........." "$CFG_XCB_XLIB"
    report_support "      Xcursor ............" "$CFG_XCURSOR" runtime "loaded at runtime"
    report_support "      Xfixes ............." "$CFG_XFIXES" runtime "loaded at runtime"
    report_support "      Xi ................." "$CFG_XINPUT" runtime "loaded at runtime"
    report_support "      Xi2 ................" "$CFG_XINPUT2" runtime "loaded at runtime"
    report_support "      Xinerama ..........." "$CFG_XINERAMA" runtime "loaded at runtime"
    report_support "      Xrandr ............." "$CFG_XRANDR" runtime "loaded at runtime"
    report_support "      Xrender ............" "$CFG_XRENDER"
    report_support "      XKB ................" "$CFG_XKB"
    report_support "      XShape ............." "$CFG_XSHAPE"
    report_support "      XSync .............." "$CFG_XSYNC"
    report_support "      XVideo ............." "$CFG_XVIDEO"
fi
report_support "  Session management ....." "$CFG_SM"
if [ "$XPLATFORM_QNX" = "yes" ]; then
    report_support "  SLOG2 .................." "$CFG_SLOG2"
    report_support "  IMF ...................." "$CFG_QNX_IMF"
    report_support "  PPS ...................." "$CFG_PPS"
    report_support "  LGMON .................." "$CFG_LGMON"
fi
report_support "  SQL drivers:"
report_support "    DB2 .................." "$CFG_SQL_db2" plugin "plugin" yes "built into QtSql"
report_support "    InterBase ............" "$CFG_SQL_ibase" plugin "plugin" yes "built into QtSql"
report_support "    MySQL ................" "$CFG_SQL_mysql" plugin "plugin" yes "built into QtSql"
report_support "    OCI .................." "$CFG_SQL_oci" plugin "plugin" yes "built into QtSql"
report_support "    ODBC ................." "$CFG_SQL_odbc" plugin "plugin" yes "built into QtSql"
report_support "    PostgreSQL ..........." "$CFG_SQL_psql" plugin "plugin" yes "built into QtSql"
report_support "    SQLite 2 ............." "$CFG_SQL_sqlite2" plugin "plugin" yes "built into QtSql"
report_support_plugin "    SQLite ..............." "$CFG_SQL_sqlite" "$CFG_SQLITE" QtSql
report_support "    TDS .................." "$CFG_SQL_tds" plugin "plugin" yes "built into QtSql"
report_support "  udev ..................." "$CFG_LIBUDEV"
report_support "  xkbcommon .............." "$CFG_XKBCOMMON" system "system library" qt "bundled copy, XKB config root: $CFG_XKB_CONFIG_ROOT"
report_support "  zlib ..................." "$CFG_ZLIB" system "system library" yes "bundled copy"

echo

# 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 [ "$ORIG_CFG_XKBCOMMON" != qt ] && [ "$CFG_XKBCOMMON" = qt ]; then
    echo "NOTE: libxkbcommon and libxkbcommon-x11 $MIN_REQ_XKBCOMMON or higher not found on the system, will use "
    echo "the bundled version from 3rd party directory."
fi
if [ "$CFG_XKBCOMMON" = "qt" ] && [ "$CFG_XKB_CONFIG_ROOT" = "not found" ]; then
    echo "WARNING: Could not find XKB config root, use -xkb-config-root to set a path to "
    echo "XKB configuration data. This is required for keyboard input support."
fi
if [ "$CFG_QREAL" = double ] && [ "$CFG_ARCH" = arm ]; then
    echo "NOTE: Qt is using double for qreal on this system. This is binary incompatible against Qt 5.1."
    echo "Configure with '-qreal float' to create a build that is binary compatible with 5.1."
fi

exec 1>&3 3>&- # restore stdout
cat $outpath/config.summary # display config feedback to user

if [ "$XPLATFORM_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=""

rm -f "$QMAKE_VARS_FILE" 2>/dev/null

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

if [ "$CFG_PROCESS" != "no" ]; then
(   # fork to make the cd stay local

    relpathMangled=$relpath
    if [ -n "$CFG_TOPLEVEL" ]; then
        relpathMangled=`dirname "$relpath"`
        cd ..
    fi

    if [ "$CFG_PROCESS" = "full" ]; then
        echo "Creating makefiles. Please wait..."
        "$outpath/bin/qmake" -r "$relpathMangled"
        echo "Done"
    else
        "$outpath/bin/qmake" "$relpathMangled"
    fi

)
fi

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

        NOTICE: configure was unable to determine the architecture
        for the $XQMAKESPEC target.

        Qt will not use a specialized implementation for any atomic
        operations. Instead a generic implemention based on either GCC
        intrinsics or C++11 std::atomic<T> will be used (when
        available). The generic implementations are generally as fast
        as and always as safe as a specialized implementation.

        If no generic implementation is available, Qt will use a
        fallback UNIX implementation 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

#-------------------------------------------------------------------------------
# check if the user passed the obsoleted -wayland or -no-wayland flag
#-------------------------------------------------------------------------------
if [ "$CFG_OBSOLETE_WAYLAND" = "yes" ]; then
cat <<EOF

        NOTICE: The -wayland and -no-wayland flags are now obsolete

        All configuring of QtWayland plugin and QtCompositor happens in the module
EOF
fi

#-------------------------------------------------------------------------------
# check if the user passed the obsoleted -arch or -host-arch options
#-------------------------------------------------------------------------------
if [ "$OPT_OBSOLETE_HOST_ARG" = "yes" ]; then
cat <<EOF

        NOTICE: The -arch and -host-arch options are obsolete.

        Qt now detects the target and host architectures based on compiler
        output. Qt will be built using $CFG_ARCH for the target architecture
        and $CFG_HOST_ARCH for the host architecture (note that these two
        will be the same unless you are cross-compiling).
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"
    [ -n "$PKG_CONFIG_SYSROOT_DIR" ] && \
        echo "export PKG_CONFIG_SYSROOT_DIR=$PKG_CONFIG_SYSROOT_DIR" >> "$outpath/config.status"
    [ -n "$PKG_CONFIG_LIBDIR" ] && \
        echo "export PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR" >> "$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 [ "$outpath" = "$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 Prior to reconfiguration, make sure you remove any leftovers from
echo the previous build.
echo