qt5base-lts/configure
Lars Knoll f7e29f07ff Generate correct output for doubleconversion support in qconfig.pri
Setting doubleconversion if Qt is configured with -no-doubleconversion
doesn't make sense. This also brings the output of configure and
configure.exe in line with each other.

Change-Id: I8424cc45b1b69fdb0d074e76868e83544cf5eb38
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2016-05-31 11:45:19 +00:00

6661 lines
211 KiB
Bash
Executable File

#!/bin/sh
#############################################################################
##
## Copyright (C) 2016 The Qt Company Ltd.
## Copyright (C) 2016 Intel Corporation.
## Contact: https://www.qt.io/licensing/
##
## This file is the build configuration utility of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
## 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 The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3 as published by the Free Software
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-3.0.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=
for i in "$@"; do
if [ "x$i" != "x-v" ]; then
[ -z "${i##* *}" ] && i="'$i'"
OPT_CMDLINE="$OPT_CMDLINE $i"
fi
done
# initialize global variables
CONFIG_SEPARATORS=`printf ' \t'`
QMAKE_SWITCHES=
QMAKE_VARS=
QMAKE_CONFIG=
QTCONFIG_CONFIG=
QT_CONFIG=
SUPPORTED=
QMAKE_VARS_FILE=.qmake.vars
DEVICE_VARS_FILE=.device.vars
HOST_VARS_FILE=.host.vars
:> "$QMAKE_VARS_FILE"
:> "$DEVICE_VARS_FILE"
:> "$HOST_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,^[^ ]* .*$,"&",'`
}
makeabs()
{
local FILE="$1"
local RES="$FILE"
if [ -z "${FILE##/*}" ]; then
true
elif [ "$OSTYPE" = "msys" -a -z "${FILE##[a-zA-Z]:[/\\]*}" ]; then
true
else
RES=$PWD/$FILE
fi
RES=$RES/
while true; do
nres=`echo "$RES" | sed 's,/[^/][^/]*/\.\./,/,g; s,/\./,/,g'`
test x"$nres" = x"$RES" && break
RES=$nres
done
echo "$RES" | sed 's,//,/,g; 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" "$2"
;;
*load\(device_config\)*)
conf_file="$2"
if [ ! -f "$conf_file" ]; then
echo "WARNING: Unable to find file $conf_file" >&2
continue
fi
expandQMakeConf "$conf_file" "$2"
;;
*)
echo "$line"
;;
esac; done < "$1"
}
extractQMakeVariables()
{
LC_ALL=C $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")"
;;
appletvos*)
version_min_flag="-mappletvos-version-min=$(getSingleQMakeVariable QMAKE_TVOS_DEPLOYMENT_TARGET "$1")"
;;
appletvsimulator*)
version_min_flag="-mtvos-simulator-version-min=$(getSingleQMakeVariable QMAKE_TVOS_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=*)
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" "$HOST_VARS_FILE" | 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" "$DEVICE_VARS_FILE" | extractQMakeVariables "!host_build"`
if [ "$XPLATFORM_MAC" = "yes" ]; then xspecvals=$(macSDKify "$xspecvals"); fi
fi
getSingleQMakeVariable "$1" "$xspecvals"
}
testXConfig()
{
# Put a space on each end of the CONFIG value so that searching for the
# target with whitespace on either side will work even when it's the
# first/last/only item in the CONFIG value.
case \ `getXQMakeConf CONFIG`\ in
*[${CONFIG_SEPARATORS}]$1[${CONFIG_SEPARATORS}]*)
return 0
;;
*)
return 1
;;
esac
}
compilerSupportsFlag()
{
cat >conftest.cpp <<EOF
int main() { return 0; }
EOF
if [ "$OPT_VERBOSE" = "yes" ]; then
"$@" -o conftest-out conftest.cpp
else
"$@" -o conftest-out conftest.cpp >/dev/null 2>&1
fi
ret=$?
rm -f conftest.cpp conftest-out
return $ret
}
linkerSupportsFlag()
{
compiler=$1
shift
lflags=-Wl
for flag
do
safe_flag=`shellEscape "$flag"`
lflags=$lflags,$safe_flag
done
if [ $CFG_USE_GOLD_LINKER = yes ]; then
lflags="-fuse-ld=gold $lflags"
fi
compilerSupportsFlag $compiler $lflags
}
# $1: newline-separated list of default paths
# stdin: input path
# stdout: input path or nothing
filterDefaultPaths()
{
local path
path=`cat`
path=`makeabs "$path"`
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"
}
#-------------------------------------------------------------------------------
# device options
#-------------------------------------------------------------------------------
DeviceVar()
{
case "$1" in
set)
eq="="
;;
*)
echo >&2 "BUG: wrong command to DeviceVar: $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
}
#-------------------------------------------------------------------------------
# Host options
#-------------------------------------------------------------------------------
HostVar()
{
case "$1" in
set)
eq="="
;;
*)
echo >&2 "BUG: wrong command to HostVar: $1"
;;
esac
echo "$2" "$eq" "$3" >> "$HOST_VARS_FILE"
}
#-------------------------------------------------------------------------------
# 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
HOST_DIRLIST_SEP=":"
DEV_NULL=/dev/null
if [ "$OSTYPE" = "msys" ]; then
HOST_DIRLIST_SEP=";"
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=
QT_MAJOR_VERSION=
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
eval `sed -n -e 's/^MODULE_VERSION = \(\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*\)$/QT_VERSION=\1\
QT_MAJOR_VERSION=\2\
QT_MINOR_VERSION=\3\
QT_PATCH_VERSION=\4/p' < "$relpath"/.qmake.conf`
if [ -z "$QT_MAJOR_VERSION" ]; then
echo "Cannot process version from .qmake.conf"
echo "Cannot proceed."
exit 1
fi
#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------
SYSTEM_VARIABLES="AR RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS"
for varname in $SYSTEM_VARIABLES; do
qmakevarname="${varname}"
qmakecmdargs=""
# use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS
if [ "${varname}" = "LDFLAGS" ]; then
qmakevarname="LFLAGS"
elif [ "${varname}" = "LD" ]; then
qmakevarname="LINK"
elif [ "${varname}" = "AR" ]; then
# QMAKE_AR needs to be set to "/path/to/ar cqs" but the
# environment variable will be set to the command only so we
# need to append " cqs" for autoconf compatibility
qmakecmdargs=" cqs"
fi
cmd=`echo \
'if [ -n "\$'${varname}'" ]; then
QMakeVar set QMAKE_'${qmakevarname}' "\$'${varname}${qmakecmdargs}'"
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_DEBUG=auto
CFG_MYSQL_CONFIG=
CFG_PSQL_CONFIG=
CFG_DEBUG_RELEASE=no
CFG_FORCEDEBUGINFO=no
CFG_RELEASE_TOOLS=no
CFG_SHARED=yes
CFG_SM=auto
CFG_SYSTEM_ZLIB=auto
CFG_MTDEV=auto
CFG_JOURNALD=no
CFG_SYSLOG=no
CFG_SQLITE=qt
CFG_GIF=yes
CFG_PNG=yes
CFG_LIBPNG=auto
CFG_JPEG=yes
CFG_LIBJPEG=auto
CFG_XRENDER=auto
CFG_OPENGL=auto
CFG_EGL=auto
CFG_EGL_X=auto
CFG_DOUBLECONVERSION=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_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=yes
CFG_ANDROID_STYLE_ASSETS=yes
CFG_GSTREAMER=auto
CFG_GSTREAMER_VERSION=""
CFG_STD_ATOMIC64=auto
# Target architecture
CFG_ARCH=
CFG_CPUFEATURES=
# Host architecture, same as CFG_ARCH when not cross-compiling
CFG_HOST_ARCH=
CFG_HOST_CPUFEATURES=
CFG_USE_GNUMAKE=no
CFG_XINPUT2=auto
CFG_XKB=auto
CFG_XKBCOMMON=yes
CFG_XKBCOMMON_EVDEV=auto
CFG_XKB_CONFIG_ROOT=auto
CFG_XCB=auto
CFG_XCB_XLIB=auto
CFG_XCB_GLX=no
CFG_EGLFS=auto
CFG_EGLFS_BRCM=no
CFG_EGLFS_EGLDEVICE=no
CFG_EGLFS_MALI=no
CFG_EGLFS_VIV=no
CFG_EGLFS_VIV_WL=no
CFG_DIRECTFB=no
CFG_GBM=auto
CFG_LINUXFB=auto
CFG_INTEGRITYFB=no
CFG_KMS=auto
CFG_MIRCLIENT=auto
CFG_LIBUDEV=auto
CFG_LIBINPUT=auto
CFG_EVDEV=auto
CFG_TSLIB=auto
CFG_NIS=auto
CFG_CUPS=auto
CFG_ICONV=auto
CFG_DBUS=auto
CFG_GLIB=auto
CFG_GTK=auto
CFG_LARGEFILE=yes
CFG_OPENSSL=auto
CFG_LIBPROXY=no
CFG_SECURETRANSPORT=auto
CFG_PRECOMPILE=auto
CFG_LTCG=no
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_AVX512=auto
CFG_REDUCE_RELOCATIONS=auto
CFG_ACCESSIBILITY=auto
CFG_ACCESSIBILITY_ATSPI_BRIDGE=no # will be enabled depending on dbus and accessibility being enabled
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_CLOEXEC=no
CFG_POLL=auto
CFG_RPATH=yes
CFG_FRAMEWORK=auto
CFG_USE_GOLD_LINKER=auto
CFG_ENABLE_NEW_DTAGS=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 # Whether target platform is OS X, iOS or tvOS
XPLATFORM_IOS=no # Whether target platform is iOS
XPLATFORM_TVOS=no # Whether target platform is tvOS
XPLATFORM_ANDROID=no
XPLATFORM_MINGW=no # Whether target platform is MinGW (win32-g++*)
XPLATFORM_QNX=no
XPLATFORM_HAIKU=no
XPLATFORM_INTEGRITY=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_ICU=auto
CFG_FORCE_ASSERTS=no
CFG_SANITIZERS=none
CFG_SANITIZE_ADDRESS=no
CFG_SANITIZE_THREAD=no
CFG_SANITIZE_MEMORY=no
CFG_SANITIZE_UNDEFINED=no
CFG_PCRE=auto
CFG_STDCXX=auto
CFG_DIRECTWRITE=no
CFG_DIRECTWRITE2=auto
CFG_WERROR=auto
CFG_HEADERSCLEAN=auto
CFG_QREAL=double
OPT_MAC_SDK=
COMMERCIAL_USER=ask
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
QMAKE_CFLAGS_PSQL=
QMAKE_LIBS_PSQL=
QMAKE_CFLAGS_MYSQL=
QMAKE_LIBS_MYSQL=
QMAKE_LIBS_MYSQL_R=
QMAKE_CFLAGS_SQLITE=
QMAKE_LIBS_SQLITE=
QMAKE_LIBS_ODBC="-lodbc"
QMAKE_LIBS_TDS=
# flags for libdbus-1
QMAKE_CFLAGS_DBUS=
QMAKE_LIBS_DBUS=
# flags for Glib (X11 only)
QMAKE_CFLAGS_GLIB=
QMAKE_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.9
CFG_DEFAULT_ANDROID_NDK_HOST=$ANDROID_NDK_HOST
#-------------------------------------------------------------------------------
# check SQL drivers available in this package
#-------------------------------------------------------------------------------
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
#-------------------------------------------------------------------------------
# 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| \
-external-hostbindir| \
-depths| \
-make| \
-nomake| \
-skip| \
-platform| \
-xplatform| \
-device| \
-device-option| \
-host-option| \
-sdk| \
-arch| \
-host-arch| \
-c++std | \
-mysql_config| \
-psql_config| \
-qpa| \
-qconfig| \
-qreal| \
-sanitize| \
-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
;;
-gstreamer)
VAR=gstreamer
# 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
;;
-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
;;
gnumake)
CFG_USE_GNUMAKE="$VAL"
;;
mysql_config)
CFG_MYSQL_CONFIG="$VAL"
;;
psql_config)
CFG_PSQL_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="yes"
;;
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"
;;
qreal)
CFG_QREAL="$VAL"
if [ "$CFG_QREAL" = "float" ]; then
CFG_QREAL_STRING="\"float\""
elif [ "$CFG_QREAL" != "double" ]; then
if [ -z "$PERL" ]; then
echo "configure needs perl in \$PATH if the -qreal option is used with" >&2
echo "a value different from \"float\"" >&2
exit 1
fi
CFG_QREAL_STRING=`perl -e '$_ = $ARGV[0];
s/ +/ /g; s/^ +//; s/ +$//;
while (/(.)/g) {
$c = $1;
if ($c =~ /[a-zA-Z0-9]/) { $result .= $c; }
else { $result .= "_" . unpack("H*", $c); }
}
print "\"$result\"";' "$CFG_QREAL"`
fi
;;
sanitize)
if [ "$VAL" = "address" ]; then
CFG_SANITIZE_ADDRESS=yes
elif [ "$VAL" = "thread" ]; then
CFG_SANITIZE_THREAD=yes
elif [ "$VAL" = "memory" ]; then
CFG_SANITIZE_MEMORY=yes
elif [ "$VAL" = "undefined" ]; then
CFG_SANITIZE_UNDEFINED=yes
else
echo "Unknown sanitizer: '$VAL'"
ERROR=true
fi
if [ "$CFG_SANITIZERS" = "none" ]; then
CFG_SANITIZERS=$VAL
else
CFG_SANITIZERS="$CFG_SANITIZERS $VAL"
fi
;;
sysroot)
CFG_SYSROOT="$VAL"
;;
gcc-sysroot)
CFG_GCC_SYSROOT="$VAL"
;;
external-hostbindir)
CFG_HOST_QT_TOOLS_PATH="$VAL"
HostVar set HOST_QT_TOOLS "$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
;;
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
;;
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"
;;
xplatform)
XPLATFORM="$VAL"
case `basename "$XPLATFORM"` in win32-g++*)
XPLATFORM_MINGW=yes
CFG_RPATH=no
CFG_REDUCE_EXPORTS=no
CFG_ICU=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"
;;
host-option)
HOST_VAR=`echo $VAL | cut -d '=' -f 1`
HOST_VAL=`echo $VAL | cut -d '=' -f 2-`
HostVar set $HOST_VAR "$HOST_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
;;
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"
;;
optimized-qmake|optimized-tools)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_RELEASE_TOOLS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
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 grep "^Feature: *${FEATURE} *\$" "$relpath"/src/corelib/global/qfeatures.txt >/dev/null 2>&1; then
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
else
echo "ERROR: Unknown feature $FEATURE"
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
;;
xinput2)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XINPUT2="$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
;;
ltcg)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_LTCG="$VAL"
else
UNKNOWN_OPT=no
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
;;
avx512)
if [ "$VAL" = "no" ]; then
CFG_AVX512=""
else
UNKNOWN_OPT=yes
fi
;;
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
;;
use-gold-linker)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_USE_GOLD_LINKER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
zlib)
if [ "$VAL" = "system" ]; then
CFG_SYSTEM_ZLIB="yes"
elif [ "$VAL" = "qt" ]; then
CFG_SYSTEM_ZLIB="no"
else
UNKNOWN_OPT=yes
fi
;;
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
;;
syslog)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SYSLOG="$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
;;
xrender)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XRENDER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
doubleconversion)
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_DOUBLECONVERSION="$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-evdev)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_XKBCOMMON_EVDEV="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
xkbcommon|xkbcommon-x11)
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
;;
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
;;
gbm)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GBM="$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
;;
mirclient)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_MIRCLIENT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libudev)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_LIBUDEV="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libinput)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_LIBINPUT="$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
;;
gstreamer)
if [ "$VAL" = "auto" ] || [ "$VAL" = "yes" ] ||
[ "$VAL" = "0.10" ] || [ "$VAL" = "1.0" ] ||
[ "$VAL" = "no" ]; then
CFG_GSTREAMER="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
gtk)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_GTK="$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
echo "WARNING: The [-no]-qpa-platform-guard argument is deprecated and has no effect."
else
UNKNOWN_OPT=yes
fi
;;
dbus)
if [ "$VAL" = "no" ] || [ "$VAL" = "linked" ] || [ "$VAL" = "runtime" ]; then
CFG_DBUS="$VAL"
elif [ "$VAL" = "yes" ]; then
# keep as auto, we'll auto-detect whether to go linked or runtime later
CFG_DBUS=auto
else
UNKNOWN_OPT=yes
fi
;;
dbus-linked)
if [ "$VAL" = "yes" ]; then
CFG_DBUS="linked"
else
UNKNOWN_OPT=yes
fi
;;
dbus-runtime)
if [ "$VAL" = "yes" ]; then
CFG_DBUS="runtime"
else
UNKNOWN_OPT=yes
fi
;;
nis)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_NIS="$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
;;
securetransport)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_SECURETRANSPORT="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
libproxy)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_LIBPROXY="$VAL"
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-*)
# if Qt style options were used, $VAL can be "no", "yes", or "plugin", plugin for backwards compatibility
[ "$VAL" = "plugin" ] && VAL=yes
# now $VAL should be "yes" or "no"... double-check
if [ "$VAL" != "no" ] && [ "$VAL" != "yes" ]; 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,'`
# Check that that user's value is available.
found=no
for d in $CFG_SQL_AVAILABLE; do
if [ "$VAL" = "$d" ]; then
found=yes
break
fi
done
if [ "$found" != "yes" ]; then
echo "$CURRENT_OPT: unknown argument"
ERROR=yes
continue
fi
# set the CFG_SQL_driver
eval "CFG_SQL_$VAL=\$OPT"
;;
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"
;;
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++std)
case "$VAL" in
c++11|c++14|c++1z|auto)
CFG_STDCXX="$VAL"
;;
11|14|1z)
CFG_STDCXX="c++$VAL"
;;
1y|c++1y)
CFG_STDCXX="c++14"
;;
*)
echo >&2 "Invalid C++ edition: $VAL; valid options are: c++11 c++14 c++1z auto"
ERROR=yes
;;
esac
;;
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
;;
headersclean)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_HEADERSCLEAN="$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"
;;
android-style-assets)
if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
CFG_ANDROID_STYLE_ASSETS="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
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 $relpath/config_help.txt
exit 0
fi
#-------------------------------------------------------------------------------
# platform detection
#-------------------------------------------------------------------------------
if [ -z "$PLATFORM" ]; then
PLATFORM_NOTES=
case "$UNAME_SYSTEM:$UNAME_RELEASE" in
Darwin:*)
PLATFORM=macx-clang
;;
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-clang
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-clang 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
;;
*qnx-*)
XPLATFORM_QNX=yes
;;
*haiku-*)
XPLATFORM_HAIKU=yes
;;
*ios*)
XPLATFORM_MAC=yes
XPLATFORM_IOS=yes
;;
*tvos*)
XPLATFORM_MAC=yes
XPLATFORM_TVOS=yes
;;
*macx*)
XPLATFORM_MAC=yes
;;
*integrity*)
XPLATFORM_INTEGRITY=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 [ $UNAME_SYSTEM = "Linux" ]; then
case "$PLATFORM" in
*-32)
Licheck=licheck32
;;
*-64)
Licheck=licheck64
;;
*)
if file -L /bin/sh | grep -q "64-bit" ; then
Licheck=licheck64
else
Licheck=licheck32
fi
;;
esac
elif [ $UNAME_SYSTEM = "Darwin" ]; then
Licheck=licheck_mac
else
echo >&2 "Host operating system not supported by this edition of Qt."
exit 1
fi
if [ -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://www.qt.io/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 LGPLv3 or GPLv2.
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
if [ "$CFG_ANDROID_STYLE_ASSETS" = "no" ] || [ "$XPLATFORM_ANDROID" = "no" ]; then
echo "You are licensed to use this software under the terms of"
echo "the GNU Lesser General Public License (LGPL) versions 3."
echo "You are also licensed to use this software under the terms of"
echo "the GNU General Public License (GPL) versions 2."
affix="either"
showGPL2="yes"
else
echo "You are licensed to use this software under the terms of"
echo "the GNU Lesser General Public License (LGPL) versions 3."
showGPL2="no"
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.LGPL3" ]; then
echo "Type 'L' to view the GNU Lesser General Public License version 3."
fi
if [ "$showGPL2" = "yes" ]; then
echo "Type 'G' to view the GNU General Public License version 2."
fi
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" = "L" ]; then
more "$relpath/LICENSE.LGPL3"
elif [ "$acceptance" = "G" ] && [ "$showGPL2" = "yes" ]; then
more "$relpath/LICENSE.GPL2"
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
#-------------------------------------------------------------------------------
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-x11 is not supported on XCB platform plugin."
exit 101
fi
if [ "$XPLATFORM_ANDROID" = "yes" ]; then
if [ "$CFG_DBUS" = "auto" ]; then
CFG_DBUS="no"
fi
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 [ -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 [ -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 information use the contact form at http://www.qt.io/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
# 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 [ "$CFG_RELEASE_TOOLS" = "yes" ]; then
QT_CONFIG="$QT_CONFIG release_tools"
fi
if [ "$XPLATFORM_MAC" = "yes" ]; then
[ "$CFG_PKGCONFIG" = "auto" ] && CFG_PKGCONFIG="no"
fi
if [ "$XPLATFORM_IOS" = "yes" ] || [ "$XPLATFORM_TVOS" = "yes" ]; then
CFG_RPATH="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 qtdoc qtmacextras qtserialport qtwebkit qtwebkit-examples"
CFG_PRECOMPILE="no" # Precompiled headers not supported with multiple -arch arguments
if [ "$XPLATFORM_TVOS" = "yes" ]; then
CFG_SKIP_MODULES="$CFG_SKIP_MODULES qtscript"
CFG_WIDGETS="no"
fi
# 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 simulator_and_device"
fi
fi
# disable XCB and GTK support auto-detection on Mac
if [ "$XPLATFORM_MAC" = "yes" ]; then
[ "$CFG_XCB" = "auto" ] && CFG_XCB=no
[ "$CFG_GTK" = "auto" ] && CFG_GTK=no
fi
QMAKE_CONF_COMPILER=`getXQMakeConf QMAKE_CXX`
TEST_COMPILER=$QMAKE_CONF_COMPILER
if [ "$XPLATFORM_ANDROID" = "yes" ] ; then
ANDROID_NDK_TOOLCHAIN_PREFIX=
ANDROID_NDK_TOOLS_PREFIX=
ANDROID_PLATFORM_ARCH=
case $CFG_DEFAULT_ANDROID_TARGET_ARCH in
armeabi*)
ANDROID_NDK_TOOLS_PREFIX=arm-linux-androideabi
ANDROID_NDK_TOOLCHAIN_PREFIX=arm-linux-androideabi
ANDROID_PLATFORM_ARCH=arch-arm
;;
x86)
ANDROID_NDK_TOOLS_PREFIX=i686-linux-android
ANDROID_NDK_TOOLCHAIN_PREFIX=x86
ANDROID_PLATFORM_ARCH=arch-x86
;;
mips)
ANDROID_NDK_TOOLS_PREFIX=mipsel-linux-android
ANDROID_NDK_TOOLCHAIN_PREFIX=mipsel-linux-android
ANDROID_PLATFORM_ARCH=arch-mips
;;
arm64-v8a)
ANDROID_NDK_TOOLS_PREFIX=aarch64-linux-android
ANDROID_NDK_TOOLCHAIN_PREFIX=aarch64-linux-android
ANDROID_PLATFORM_ARCH=arch-arm64
;;
mips64)
ANDROID_NDK_TOOLS_PREFIX=mips64el-linux-android
ANDROID_NDK_TOOLCHAIN_PREFIX=mips64el-linux-android
ANDROID_PLATFORM_ARCH=arch-mips64
;;
x86_64)
ANDROID_NDK_TOOLS_PREFIX=x86_64-linux-android
ANDROID_NDK_TOOLCHAIN_PREFIX=x86_64
ANDROID_PLATFORM_ARCH=arch-x86_64
;;
*)
echo "ERROR: Unknown android arch $CFG_DEFAULT_ANDROID_TARGET_ARCH"
exit 1
;;
esac
QMAKE_CONF_COMPILER=$CFG_DEFAULT_ANDROID_NDK_ROOT/toolchains/$ANDROID_NDK_TOOLCHAIN_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/"
if [ "$CFG_ANDROID_STYLE_ASSETS" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG android-style-assets"
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 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";
}'
awkprog_result=`LC_ALL=C $TEST_COMPILER $SYSROOT_FLAG $TEST_COMPILER_CXXFLAGS -xc++ -E -v - < /dev/null 2>&1 > /dev/null | $AWK "$awkprog"`
eval "$awkprog_result"
[ "$OPT_VERBOSE" = "yes" ] && echo "$awkprog_result"
#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
#-------------------------------------------------------------------------------
# postprocess installation and deployment paths
#-------------------------------------------------------------------------------
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=`makeabs "$QT_INSTALL_PREFIX"`
if [ -z "$QT_EXT_PREFIX" ]; then
QT_EXT_PREFIX=$QT_INSTALL_PREFIX
if [ -n "$CFG_SYSROOT" ]; then
QMAKE_SYSROOTIFY=true
else
QMAKE_SYSROOTIFY=false
fi
else
QT_EXT_PREFIX=`makeabs "$QT_EXT_PREFIX"`
QMAKE_SYSROOTIFY=false
fi
if [ -z "$QT_HOST_PREFIX" ]; then
if $QMAKE_SYSROOTIFY; then
QT_HOST_PREFIX=$CFG_SYSROOT$QT_EXT_PREFIX
else
QT_HOST_PREFIX=$QT_EXT_PREFIX
fi
HAVE_HOST_PATH=false
else
QT_HOST_PREFIX=`makeabs "$QT_HOST_PREFIX"`
HAVE_HOST_PATH=true
fi
#------- make the paths relative to the prefixes --------
PREFIX_COMPLAINTS=
PREFIX_REMINDER=false
while read basevar baseoption var option; do
eval path=\$QT_${basevar}_$var
[ -z "$path" ] && continue
path=`makeabs "$path"`
eval base=\$QT_${basevar}_PREFIX
rel=${path##$base}
if [ x"$rel" = x"$path" ]; then
if [ x"$option" != x"sysconf" ]; then
PREFIX_COMPLAINTS="$PREFIX_COMPLAINTS
NOTICE: -${option}dir is not a subdirectory of ${baseoption}prefix."
eval \$HAVE_${basevar}_PATH || PREFIX_REMINDER=true
fi
eval QT_REL_${basevar}_$var=\$rel
elif [ -z "$rel" ]; then
eval QT_REL_${basevar}_$var=.
else
eval QT_REL_${basevar}_$var=\${rel#/}
fi
done <<EOF
INSTALL - DOCS doc
INSTALL - HEADERS header
INSTALL - LIBS lib
INSTALL - LIBEXECS libexec
INSTALL - BINS bin
INSTALL - PLUGINS plugin
INSTALL - IMPORTS import
INSTALL - QML qml
INSTALL - ARCHDATA archdata
INSTALL - DATA data
INSTALL - TRANSLATIONS translation
INSTALL - EXAMPLES examples
INSTALL - TESTS tests
INSTALL - SETTINGS sysconf
HOST -host BINS hostbin
HOST -host LIBS hostlib
HOST -host DATA hostdata
EOF
$PREFIX_REMINDER && PREFIX_COMPLAINTS="$PREFIX_COMPLAINTS
Maybe you forgot to specify -prefix/-hostprefix?"
if [ -z "$QT_REL_INSTALL_HEADERS" ]; then
QT_REL_INSTALL_HEADERS=include
fi
if [ -z "$QT_REL_INSTALL_LIBS" ]; then
QT_REL_INSTALL_LIBS=lib
fi
if [ -z "$QT_REL_INSTALL_BINS" ]; then
QT_REL_INSTALL_BINS=bin
fi
if [ -z "$QT_REL_INSTALL_ARCHDATA" ]; then
QT_REL_INSTALL_ARCHDATA=.
fi
if [ x"$QT_REL_INSTALL_ARCHDATA" != x. ]; then
QT_REL_INSTALL_ARCHDATA_PREFIX=$QT_REL_INSTALL_ARCHDATA/
fi
if [ -z "$QT_REL_INSTALL_LIBEXECS" ]; then
if [ "$XPLATFORM_MINGW" = "yes" ]; then
QT_REL_INSTALL_LIBEXECS=${QT_REL_INSTALL_ARCHDATA_PREFIX}bin
else
QT_REL_INSTALL_LIBEXECS=${QT_REL_INSTALL_ARCHDATA_PREFIX}libexec
fi
fi
if [ -z "$QT_REL_INSTALL_PLUGINS" ]; then
QT_REL_INSTALL_PLUGINS=${QT_REL_INSTALL_ARCHDATA_PREFIX}plugins
fi
if [ -z "$QT_REL_INSTALL_IMPORTS" ]; then
QT_REL_INSTALL_IMPORTS=${QT_REL_INSTALL_ARCHDATA_PREFIX}imports
fi
if [ -z "$QT_REL_INSTALL_QML" ]; then
QT_REL_INSTALL_QML=${QT_REL_INSTALL_ARCHDATA_PREFIX}qml
fi
if [ -z "$QT_REL_INSTALL_DATA" ]; then
QT_REL_INSTALL_DATA=.
fi
if [ x"$QT_REL_INSTALL_DATA" != x. ]; then
QT_REL_INSTALL_DATA_PREFIX=$QT_REL_INSTALL_DATA/
fi
if [ -z "$QT_REL_INSTALL_DOCS" ]; then
QT_REL_INSTALL_DOCS=${QT_REL_INSTALL_DATA_PREFIX}doc
fi
if [ -z "$QT_REL_INSTALL_TRANSLATIONS" ]; then
QT_REL_INSTALL_TRANSLATIONS=${QT_REL_INSTALL_DATA_PREFIX}translations
fi
if [ -z "$QT_REL_INSTALL_EXAMPLES" ]; then
QT_REL_INSTALL_EXAMPLES=examples
fi
if [ -z "$QT_REL_INSTALL_TESTS" ]; then
QT_REL_INSTALL_TESTS=tests
fi
if [ -z "$QT_REL_INSTALL_SETTINGS" ]; then
if [ "$XPLATFORM_MAC" = "yes" ]; then
QT_REL_INSTALL_SETTINGS=/Library/Preferences/Qt
else
QT_REL_INSTALL_SETTINGS=etc/xdg
fi
fi
#------- host paths --------
if [ -z "$QT_REL_HOST_BINS" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_BINS=bin
else
QT_REL_HOST_BINS=$QT_REL_INSTALL_BINS
fi
fi
if [ -z "$QT_REL_HOST_LIBS" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_LIBS=lib
else
QT_REL_HOST_LIBS=$QT_REL_INSTALL_LIBS
fi
fi
if [ -z "$QT_REL_HOST_DATA" ]; then
if $HAVE_HOST_PATH; then
QT_REL_HOST_DATA=.
else
QT_REL_HOST_DATA=$QT_REL_INSTALL_ARCHDATA
fi
fi
if [ "$CFG_COMPILE_EXAMPLES" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG compile_examples"
fi
shortxspec=`echo $XQMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
shortspec=`echo $QMAKESPEC | sed "s,^${relpath}/mkspecs/,,"`
QT_CONFIGURE_STR_OFF=0
addConfStr()
{
QT_CONFIGURE_STR_OFFSETS="$QT_CONFIGURE_STR_OFFSETS $QT_CONFIGURE_STR_OFF,"
QT_CONFIGURE_STRS="$QT_CONFIGURE_STRS \"$1\\0\"
"
count=`echo "$1" | wc -c`
QT_CONFIGURE_STR_OFF=`expr $QT_CONFIGURE_STR_OFF + $count`
}
QT_CONFIGURE_STR_OFFSETS=
QT_CONFIGURE_STRS=
addConfStr "$QT_REL_INSTALL_DOCS"
addConfStr "$QT_REL_INSTALL_HEADERS"
addConfStr "$QT_REL_INSTALL_LIBS"
addConfStr "$QT_REL_INSTALL_LIBEXECS"
addConfStr "$QT_REL_INSTALL_BINS"
addConfStr "$QT_REL_INSTALL_PLUGINS"
addConfStr "$QT_REL_INSTALL_IMPORTS"
addConfStr "$QT_REL_INSTALL_QML"
addConfStr "$QT_REL_INSTALL_ARCHDATA"
addConfStr "$QT_REL_INSTALL_DATA"
addConfStr "$QT_REL_INSTALL_TRANSLATIONS"
addConfStr "$QT_REL_INSTALL_EXAMPLES"
addConfStr "$QT_REL_INSTALL_TESTS"
QT_CONFIGURE_STR_OFFSETS_ALL=$QT_CONFIGURE_STR_OFFSETS
QT_CONFIGURE_STRS_ALL=$QT_CONFIGURE_STRS
QT_CONFIGURE_STR_OFFSETS=
QT_CONFIGURE_STRS=
addConfStr "$CFG_SYSROOT"
addConfStr "$QT_REL_HOST_BINS"
addConfStr "$QT_REL_HOST_LIBS"
addConfStr "$QT_REL_HOST_DATA"
addConfStr "$shortxspec"
addConfStr "$shortspec"
#-------------------------------------------------------------------------------
# generate qconfig.cpp
#-------------------------------------------------------------------------------
[ -d "$outpath/src/corelib/global" ] || mkdir -p "$outpath/src/corelib/global"
cat > "$outpath/src/corelib/global/qconfig.cpp.new" <<EOF
/* Installation date */
static const char qt_configure_installation [12+11] = "qt_instdate=2012-12-20";
/* Installation Info */
static const char qt_configure_prefix_path_str [256 + 12] = "qt_prfxpath=$QT_INSTALL_PREFIX";
#ifdef QT_BUILD_QMAKE
static const char qt_configure_ext_prefix_path_str [256 + 12] = "qt_epfxpath=$QT_EXT_PREFIX";
static const char qt_configure_host_prefix_path_str [256 + 12] = "qt_hpfxpath=$QT_HOST_PREFIX";
#endif
static const short qt_configure_str_offsets[] = {
$QT_CONFIGURE_STR_OFFSETS_ALL
#ifdef QT_BUILD_QMAKE
$QT_CONFIGURE_STR_OFFSETS
#endif
};
static const char qt_configure_strs[] =
$QT_CONFIGURE_STRS_ALL#ifdef QT_BUILD_QMAKE
$QT_CONFIGURE_STRS#endif
;
#define QT_CONFIGURE_SETTINGS_PATH "$QT_REL_INSTALL_SETTINGS"
#ifdef QT_BUILD_QMAKE
# define QT_CONFIGURE_SYSROOTIFY_PREFIX $QMAKE_SYSROOTIFY
#endif
#define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12
#ifdef QT_BUILD_QMAKE
# define QT_CONFIGURE_EXT_PREFIX_PATH qt_configure_ext_prefix_path_str + 12
# define QT_CONFIGURE_HOST_PREFIX_PATH qt_configure_host_prefix_path_str + 12
#endif
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" -version $QT_VERSION -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_CXX11) \$(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_CXX11
setBootstrapVariable QMAKE_CXXFLAGS_SPLIT_SECTIONS
setBootstrapVariable QMAKE_LFLAGS
setBootstrapVariable QMAKE_LFLAGS_GCSECTIONS
if [ "$CFG_DEBUG" = "no" ] || [ "$CFG_RELEASE_TOOLS" = "yes" ]; then
setBootstrapVariable QMAKE_CFLAGS_RELEASE
setBootstrapVariable QMAKE_CXXFLAGS_RELEASE
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
else
setBootstrapVariable QMAKE_CFLAGS_DEBUG
setBootstrapVariable QMAKE_CXXFLAGS_DEBUG
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
fi
case `basename "$PLATFORM"` in
win32-g++*)
EXTRA_CFLAGS="$EXTRA_CFLAGS -DUNICODE"
EXTRA_CXXFLAGS="$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="$EXTRA_LFLAGS -static -s -lole32 -luuid -ladvapi32 -lkernel32"
EXEEXT=".exe"
;;
*)
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=
;;
esac
if [ "$BUILD_ON_MAC" = "yes" ]; then
echo "COCOA_LFLAGS =-framework Foundation -framework CoreServices" >>"$mkfile"
echo "CARBON_LFLAGS =-framework ApplicationServices" >>"$mkfile"
echo "CARBON_CFLAGS =-fconstant-cfstrings" >>"$mkfile"
EXTRA_LFLAGS="$EXTRA_LFLAGS \$(COCOA_LFLAGS)"
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 \
qcore_mac_objc.o"
EXTRA_SRCS="$EXTRA_SRCS \
\"\$(SOURCE_PATH)/src/corelib/io/qsettings_mac.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac.cpp\" \
\"\$(SOURCE_PATH)/src/corelib/kernel/qcore_mac_objc.mm\""
fi
echo >>"$mkfile"
adjrelpath=`echo "$relpath" | sed 's/ /\\\\\\\\ /g'`
adjoutpath=`echo "$outpath" | sed 's/ /\\\\\\\\ /g'`
adjqmakespec=`echo "$QMAKESPEC" | sed 's/ /\\\\\\\\ /g'`
echo "BUILD_PATH = .." >> "$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 "QT_MAJOR_VERSION = $QT_MAJOR_VERSION" >> "$mkfile"
echo "QT_MINOR_VERSION = $QT_MINOR_VERSION" >> "$mkfile"
echo "QT_PATCH_VERSION = $QT_PATCH_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
if [ "$OPT_VERBOSE" = yes ]; then
# Show the output of make
(cd "$outpath/qmake"; "$MAKE") || exit 2
else
# Hide the output of make
# Use bash to print dots, if we have it, and stdout is a tty.
if test -t 1 && $WHICH bash > /dev/null 2>/dev/null; then
bash -c 'set -o pipefail
cd "$0/qmake"; "$1" | while read line; do
builtin echo -n .
done' "$outpath" "$MAKE" || exit 2
else
(cd "$outpath/qmake"; "$MAKE" -s) || exit 2
fi
echo "Done."
fi
fi # Build qmake
#-------------------------------------------------------------------------------
# create a qt.conf for the Qt build tree itself
#-------------------------------------------------------------------------------
QTCONFFILE="$outpath/bin/qt.conf"
cat > "$QTCONFFILE" <<EOF
[EffectivePaths]
Prefix=..
EOF
if [ -n "$CFG_HOST_QT_TOOLS_PATH" ]; then
cat >> "$QTCONFFILE" <<EOF
[Paths]
Prefix=$QT_EXT_PREFIX
Documentation=$QT_REL_INSTALL_DOCS
Headers=$QT_REL_INSTALL_HEADERS
Libraries=$QT_REL_INSTALL_LIBS
LibraryExecutables=$QT_REL_INSTALL_LIBEXECS
Binaries=$QT_REL_INSTALL_BINS
Plugins=$QT_REL_INSTALL_PLUGINS
Imports=$QT_REL_INSTALL_IMPORTS
Qml2Imports=$QT_REL_INSTALL_QML
ArchData=$QT_REL_INSTALL_ARCHDATA
Data=$QT_REL_INSTALL_DATA
Translations=$QT_REL_INSTALL_TRANSLATIONS
Examples=$QT_REL_INSTALL_EXAMPLES
Tests=$QT_REL_INSTALL_TESTS
HostPrefix=$QT_HOST_PREFIX
HostBinaries=$QT_REL_HOST_BINS
HostLibraries=$QT_REL_HOST_LIBS
HostData=$QT_REL_HOST_DATA
TargetSpec=$XPLATFORM
HostSpec=$PLATFORM
EOF
if [ -n "$CFG_SYSROOT" ]; then
cat >> "$QTCONFFILE" <<EOF
Sysroot=$CFG_SYSROOT
EOF
fi
fi
if [ x"$relpath" != x"$outpath" ]; then
cat >> "$QTCONFFILE" <<EOF
[EffectiveSourcePaths]
Prefix=$relpath
EOF
fi
[ -z "$CFG_HOST_QT_TOOLS_PATH" ] && CFG_HOST_QT_TOOLS_PATH="$outpath/bin"
CFG_QMAKE_PATH="$CFG_HOST_QT_TOOLS_PATH/qmake"
#-------------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------------
# write out host config.
#-------------------------------------------------------------------------------
HOST_VARS_OUTFILE="$outpath/mkspecs/qhost.pri"
if cmp -s "$HOST_VARS_FILE" "$HOST_VARS_OUTFILE"; then
rm -f "$HOST_VARS_FILE"
else
mv -f $HOST_VARS_FILE "$HOST_VARS_OUTFILE"
HOST_VARS_FILE="$HOST_VARS_OUTFILE"
fi
echo "Running configuration tests..."
#-------------------------------------------------------------------------------
# Verify makespec
#-------------------------------------------------------------------------------
QMAKE_OUTPUT=`"$CFG_QMAKE_PATH" -qtconf "$QTCONFFILE" -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="`"$CFG_QMAKE_PATH" -qtconf "$QTCONFFILE" -E -nocache -spec "$XQMAKESPEC" "CONFIG=" $DEV_NULL 2>&1 | sed -n -e 's,^PKG_CONFIG = \(.*\),\1,p'`"
[ -n "$PKG_CONFIG" ] && [ "$OPT_VERBOSE" = "yes" ] && echo "Found pkg-config from mkspec: $PKG_CONFIG"
fi
if [ -z "$PKG_CONFIG" ]; then
PKG_CONFIG=`"$WHICH" pkg-config 2>/dev/null`
[ -n "$PKG_CONFIG" ] && [ "$OPT_VERBOSE" = "yes" ] && echo "Found pkg-config from \$PATH: $PKG_CONFIG"
fi
if [ "$CFG_PKGCONFIG" = "no" ]; then
PKG_CONFIG=
[ "$OPT_VERBOSE" = "yes" ] && echo "pkg-config support disabled."
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" = "auto" ]; then
PKG_CONFIG=
echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_LIBDIR is not set and"
echo >&2 "the host's .pc files would 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 -pkg-config to override this test."
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" = "auto" ]; then
PKG_CONFIG=
echo >&2 "Warning: Disabling pkg-config since PKG_CONFIG_SYSROOT_DIR is not set."
echo >&2 "Set this variable to your sysroot for pkg-config to function correctly when"
echo >&2 "cross-compiling or use -pkg-config to override this test."
fi
fi
fi
if [ -n "$PKG_CONFIG" ]; then
CFG_PKGCONFIG=yes
else
CFG_PKGCONFIG=no
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
#-------------------------------------------------------------------------------
# run configure tests
#-------------------------------------------------------------------------------
# parameters: path, name, extra args
compileTest()
{
path=config.tests/$1
name=$2
shift 2
# allow config tests which behave differently depending on the type of
# library being built (shared/static) e.g. see config.tests/unix/icu
test_config="$QMAKE_CONFIG shared"
if [ "$CFG_SHARED" = "no" ]; then
test_config="$QMAKE_CONFIG static"
fi
echo $ECHO_N "checking for $name... $ECHO_C"
"$unixtests/compile.test" "$XQMAKESPEC" "$test_config" $OPT_VERBOSE "$relpath" "$outpath" "$path" "$name" "$CFG_QMAKE_PATH" "$QTCONFFILE" $I_FLAGS $D_FLAGS $L_FLAGS "$@"
}
compileTestWithPkgConfig()
{
if [ $# -lt 4 ]; then
echo "CompileTestWithPkgConfig requires at least 4 arguments."
echo "compileTestWithPkgConfig pkg_name configtest configtest_name qmake_postfix + additional arguments to compileTest"
exit 1
fi
local pkg_name=$1
local configtest=$2
local configtest_name="$3"
local qmake_postfix=$4
shift 4
local has_used_pkg_config="no"
local incdir_raw incdir_mod cflags
local libdir_raw libdir_mod libs
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists $pkg_name 2>/dev/null; then
incdir_raw=`$PKG_CONFIG --cflags-only-I $pkg_name 2>/dev/null`
cflags=`$PKG_CONFIG --cflags-only-other $pkg_name 2>/dev/null`
libdir_raw=`$PKG_CONFIG --libs-only-L $pkg_name 2>/dev/null`
libs=`$PKG_CONFIG --libs-only-l --libs-only-other $pkg_name 2>/dev/null`
incdir_mod=`echo $incdir_raw | sed -e 's,^-I,,g' -e 's, -I, ,g'`
libdir_mod=`echo $libdir_raw | sed -e 's,^-L,,g' -e 's, -L, ,g'`
has_used_pkg_config="yes"
fi
if compileTest $configtest "$configtest_name" $libdir_raw $incdir_raw $libs $cflags "$@"; then
if [ "$has_used_pkg_config" = "yes" ] && [ -n "$qmake_postfix" ]; then
QMakeVar set QMAKE_INCDIR_$qmake_postfix "`shellArgumentListToQMakeList $incdir_mod`"
QMakeVar set QMAKE_LIBDIR_$qmake_postfix "`shellArgumentListToQMakeList $libdir_mod`"
QMakeVar set QMAKE_LIBS_$qmake_postfix "`shellArgumentListToQMakeList $libs`"
QMakeVar set QMAKE_CFLAGS_$qmake_postfix "`shellArgumentListToQMakeList $cflags`"
fi
return 0
else
return 1
fi
}
#-------------------------------------------------------------------------------
# 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" $CFG_QMAKE_PATH $QTCONFFILE $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" $CFG_QMAKE_PATH $QTCONFFILE $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
#-------------------------------------------------------------------------------
# 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
# 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 -fuse-ld=gold support
if [ "$CFG_USE_GOLD_LINKER" != "no" ]; then
if compilerSupportsFlag $TEST_COMPILER -fuse-ld=gold; then
CFG_USE_GOLD_LINKER=yes
else
if [ "$CFG_USE_GOLD_LINKER" = "yes" ]; then
echo "-use-gold-linker was requested but this compiler does not support it"
exit 1
fi
CFG_USE_GOLD_LINKER=no
fi
fi
# auto-detect --enable-new-dtags support
if linkerSupportsFlag $TEST_COMPILER --enable-new-dtags; then
CFG_ENABLE_NEW_DTAGS=yes
else
CFG_ENABLE_NEW_DTAGS=no
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
if [ "$CFG_SEPARATE_DEBUG_INFO" = "yes" ]; then
# sanity-check for separate debug info
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
# Detect objcopy support
if [ "$XPLATFORM_MAC" = "no" ]; 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
fi
# Detect C++11 & up support
stdcxx_error=false
if ! compileTest common/c++11 "C++11"; then
echo "ERROR: Qt requires a C++11 compiler and yours does not seem to be that."
echo "Please upgrade."
exit 1
elif [ "$CFG_STDCXX" = "c++11" ]; then
: # CFG_STDCXX is correct
elif ! compileTest common/c++14 "C++14"; then
if [ "$CFG_STDCXX" != "auto" ]; then
stdcxx_error=true
else
CFG_STDCXX="c++11"
fi
elif [ "$CFG_STDCXX" = "c++14" ]; then
: # CFG_STDCXX is correct
elif ! compileTest common/c++1z "C++1z"; then
if [ "$CFG_STDCXX" != "auto" ]; then
stdcxx_error=true
else
CFG_STDCXX="c++14"
fi
else
CFG_STDCXX="c++1z"
fi
if $stdcxx_error && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "$CFG_STDCXX 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
# Detect whether 64-bit std::atomic works -- some 32-bit platforms require extra library support
if compileTest common/atomic64 "64-bit std::atomic"; then
CFG_STD_ATOMIC64=yes
elif compileTest common/atomic64 "64-bit std::atomic in -latomic" -latomic; then
CFG_STD_ATOMIC64=libatomic
else
CFG_STD_ATOMIC64=no
fi
# detect sse2 support
CFG_SSE_LIST=
if [ "${CFG_SSE2}" = "auto" ]; then
if compileTest common/sse2 "sse2"; then
CFG_SSE2=yes
CFG_SSE_LIST=SSE2
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
CFG_SSE_LIST="$CFG_SSE_LIST SSE3"
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
CFG_SSE_LIST="$CFG_SSE_LIST SSSE3"
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
CFG_SSE_LIST="$CFG_SSE_LIST SSE4.1"
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
CFG_SSE_LIST="$CFG_SSE_LIST SSE4.2"
else
CFG_SSE4_2=no
fi
fi
# detect avx support
CFG_AVX_LIST=
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
CFG_AVX_LIST=AVX
;;
esac
;;
*)
CFG_AVX=yes
CFG_AVX_LIST=AVX
;;
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
CFG_AVX_LIST="$CFG_AVX_LIST AVX2"
else
CFG_AVX2=no
fi
fi
# detect avx512 support
if [ "${CFG_AVX2}" = "no" ]; then
CFG_AVX512=
fi
if [ "${CFG_AVX512}" = "auto" ]; then
# First, test for AVX-512 Foundation
if compileTest common/avx512 "avx512f" AVX512=F; then
# Test for the sub-features
CFG_AVX512=f
CFG_AVX512_UPPER=AVX512F
for feature in er cd pf dq bw vl ifma vbmi; do
if [ -n "$BASH_VERSION" ] && [ "${BASH_VERSION%%.*}" -gt 3 ]; then
upper=${feature^^*}
elif [ -n "$ZSH_VERSION" ]; then
upper=${(U)feature}
else
upper=`echo $feature | tr a-z A-Z`
fi
if compileTest common/avx512 "avx512$feature" AVX512=$upper; then
CFG_AVX512="$CFG_AVX512 $feature"
CFG_AVX512_UPPER="$CFG_AVX512_UPPER AVX512$upper"
fi
done
else
CFG_AVX512=
fi
fi
# check Neon support
if [ "$CFG_NEON" = "auto" ]; then
# no compile test, just check what the compiler has
case "$CFG_CPUFEATURES" in
*neon*)
CFG_NEON=yes
;;
*)
CFG_NEON=no
;;
esac
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" "$CFG_QMAKE_PATH" "$QTCONFFILE" $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" "$CFG_QMAKE_PATH" "$QTCONFFILE" $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"
# check IPC support
if ! compileTest unix/ipc_sysv "ipc_sysv" ; then
# SYSV IPC is not supported - check POSIX IPC
if compileTest unix/ipc_posix "ipc_posix" ; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_POSIX_IPC"
else
if [ "$XPLATFORM_ANDROID" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] ; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SYSTEMSEMAPHORE QT_NO_SHAREDMEMORY"
fi
fi
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 [ "$XPLATFORM_INTEGRITY" = "yes" ]; then
CFG_INTEGRITYFB=yes
CFG_SHARED=no
CFG_LARGEFILE=no
fi
# detect zlib
if [ "$CFG_SYSTEM_ZLIB" = "auto" ]; then
if compileTest unix/zlib "zlib"; then
CFG_SYSTEM_ZLIB=yes
else
CFG_SYSTEM_ZLIB=no
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_SYSLOG" != "no" ]; then
if compileTest unix/syslog "syslog"; then
CFG_SYSLOG=yes
QMAKE_CONFIG="$QMAKE_CONFIG syslog"
else
if [ "$CFG_SYSLOG" != "auto" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "syslog 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_SYSLOG=no
fi
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 png
if [ "$CFG_LIBPNG" = "auto" ]; then
if compileTest unix/libpng "libpng"; then
CFG_LIBPNG=system
else
CFG_LIBPNG=qt
fi
fi
# detect dl
if ! compileTest unix/libdl "libdl"; then
QMakeVar add DEFINES QT_NO_DYNAMIC_LIBRARY
QMAKE_CONFIG="$QMAKE_CONFIG no-libdl"
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
# 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
QMAKE_CFLAGS_MYSQL=`$CFG_MYSQL_CONFIG --include 2>/dev/null | filterIncludeOptions`
# -rdynamic should not be returned by mysql_config, but is on RHEL 6.6
QMAKE_LIBS_MYSQL_R=`$CFG_MYSQL_CONFIG --libs_r 2>/dev/null | filterLibraryOptions | sed "s/-rdynamic//"`
QMAKE_LIBS_MYSQL=`$CFG_MYSQL_CONFIG --libs 2>/dev/null | filterLibraryOptions | sed "s/-rdynamic//"`
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"
QMAKE_LIBS_MYSQL=""
QMAKE_LIBS_MYSQL_R=""
QMAKE_CFLAGS_MYSQL=""
fi
else
if compileTest unix/mysql_r "MySQL (thread-safe)" $QMAKE_LIBS_MYSQL_R $QMAKE_CFLAGS_MYSQL; then
QMakeVar add CONFIG use_libmysqlclient_r
CFG_SQL_mysql=yes
QMAKE_LIBS_MYSQL="$QMAKE_LIBS_MYSQL_R"
elif compileTest unix/mysql "MySQL (thread-unsafe)" $QMAKE_LIBS_MYSQL $QMAKE_CFLAGS_MYSQL; then
CFG_SQL_mysql=yes
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
QMAKE_LIBS_MYSQL=""
QMAKE_LIBS_MYSQL_R=""
QMAKE_CFLAGS_MYSQL=""
fi
fi
fi
fi
;;
psql)
if [ "$CFG_SQL_psql" != "no" ]; then
[ -z "$CFG_PSQL_CONFIG" ] && CFG_PSQL_CONFIG=`"$WHICH" pg_config`
# Be careful not to use native pg_config when cross building.
if [ "$XPLATFORM_MINGW" != "yes" ] && [ -x "$CFG_PSQL_CONFIG" ]; then
QMAKE_CFLAGS_PSQL=`$CFG_PSQL_CONFIG --includedir 2>/dev/null | filterIncludePath`
QMAKE_LIBS_PSQL=`$CFG_PSQL_CONFIG --libdir 2>/dev/null | filterLibraryPath`
fi
[ -z "$QMAKE_CFLAGS_PSQL" ] || QMAKE_CFLAGS_PSQL="-I$QMAKE_CFLAGS_PSQL"
[ -z "$QMAKE_LIBS_PSQL" ] || QMAKE_LIBS_PSQL="-L$QMAKE_LIBS_PSQL"
# But, respect PSQL_LIBS if set
[ -z "$PSQL_LIBS" ] || QMAKE_LIBS_PSQL="$PSQL_LIBS"
if compileTest unix/psql "PostgreSQL" $QMAKE_LIBS_PSQL $QMAKE_CFLAGS_PSQL; then
CFG_SQL_psql=yes
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
QMAKE_CFLAGS_PSQL=""
QMAKE_LIBS_PSQL=""
fi
fi
fi
;;
odbc)
if [ "$CFG_SQL_odbc" != "no" ]; then
if [ "$XPLATFORM_MAC" != "yes" ] && compileTest unix/odbc "ODBC"; then
CFG_SQL_odbc=yes
else
if compileTest unix/iodbc "iODBC"; then
QMAKE_LIBS_ODBC="-liodbc"
CFG_SQL_odbc=yes
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
CFG_SQL_oci=yes
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" ] || QMAKE_LIBS_TDS="-L$SYBASE/lib"
[ -z "$SYBASE_LIBS" ] || QMAKE_LIBS_TDS="$QMAKE_LIBS_TDS $SYBASE_LIBS"
if compileTest unix/tds "TDS" $QMAKE_LIBS_TDS; then
CFG_SQL_tds=yes
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
CFG_SQL_db2=yes
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
CFG_SQL_ibase=yes
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
CFG_SQL_sqlite2=yes
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
QMAKE_CFLAGS_SQLITE=`$PKG_CONFIG --cflags sqlite3 2>/dev/null`
QMAKE_LIBS_SQLITE=`$PKG_CONFIG --libs sqlite3 2>/dev/null`
else
QMAKE_CFLAGS_SQLITE=
QMAKE_LIBS_SQLITE="-lsqlite3 -lz"
fi
if compileTest unix/sqlite "SQLite" $QMAKE_LIBS_SQLITE $QMAKE_CFLAGS_SQLITE; then
CFG_SQL_sqlite=yes
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
CFG_SQL_sqlite=yes
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
# auto: detect if libdbus-1 is present; if so, link to it
# linked: fail if libdbus-1 is not present; otherwise link to it
# runtime: no detection (cannot fail), load libdbus-1 at runtime
if [ "$CFG_DBUS" = "auto" ] || [ "$CFG_DBUS" = "linked" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --atleast-version="$MIN_DBUS_1_VERSION" dbus-1 2>/dev/null; then
QMAKE_CFLAGS_DBUS=`$PKG_CONFIG --cflags dbus-1 2>/dev/null`
QMAKE_LIBS_DBUS=`$PKG_CONFIG --libs dbus-1 2>/dev/null`
else
QMAKE_LIBS_DBUS="-ldbus-1"
fi
if compileTest unix/dbus "D-Bus" $QMAKE_CFLAGS_DBUS $QMAKE_LIBS_DBUS; then
QMakeVar set QMAKE_LIBS_DBUS "$QMAKE_LIBS_DBUS"
QMakeVar set QMAKE_CFLAGS_DBUS "$QMAKE_CFLAGS_DBUS"
# Try find correct host configuration for dbus tools when cross-compiling
if [ "$QT_CROSS_COMPILE" = "yes" ] && env -i PATH="$PATH" \
pkg-config --atleast-version="$MIN_DBUS_1_VERSION" dbus-1 2>/dev/null; then
QMAKE_CFLAGS_DBUS=`env -i PATH="$PATH" pkg-config --cflags dbus-1 2>/dev/null`
fi
QMakeVar set QT_HOST_CFLAGS_DBUS "$QMAKE_CFLAGS_DBUS"
CFG_DBUS=linked
else
# Failed to compile the test, so it's an error if CFG_DBUS is "linked"
if [ "$CFG_DBUS" = "linked" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "The Qt D-Bus module cannot be enabled because libdbus-1 version $MIN_DBUS_1_VERSION was not found."
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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_DBUS is "auto" here
CFG_DBUS=runtime
fi
fi
fi
# auto-detect libproxy support
if [ "$CFG_LIBPROXY" != "no" ]; then
if compileTest common/libproxy "libproxy"; then
CFG_LIBPROXY=yes
else
if [ "$CFG_LIBPROXY" = "auto" ]; then
CFG_LIBPROXY=no
elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
# CFG_LIBPROXY is "yes" here
echo "The libproxy support cannot be enabled because libproxy 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
QMAKE_CFLAGS_GLIB=`$PKG_CONFIG --cflags glib-2.0 gthread-2.0 2>/dev/null`
QMAKE_LIBS_GLIB=`$PKG_CONFIG --libs glib-2.0 gthread-2.0 2>/dev/null`
fi
if compileTest unix/glib "Glib" $QMAKE_CFLAGS_GLIB $QMAKE_LIBS_GLIB; then
CFG_GLIB=yes
QMakeVar set QMAKE_CFLAGS_GLIB "$QMAKE_CFLAGS_GLIB"
QMakeVar set QMAKE_LIBS_GLIB "$QMAKE_LIBS_GLIB"
else
if [ "$CFG_GLIB" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "Glib support cannot be enabled due to functionality tests!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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_GTK" != "no" ]; then
if [ -n "$PKG_CONFIG" ]; then
QMAKE_CFLAGS_GTK3=`$PKG_CONFIG --cflags gtk+-3.0 2>/dev/null`
QMAKE_LIBS_GTK3=`$PKG_CONFIG --libs gtk+-3.0 2>/dev/null`
fi
if [ -n "$QMAKE_CFLAGS_GTK3" ] ; then
CFG_GTK=yes
QT_CONFIG="$QT_CONFIG gtk3"
QMakeVar set QMAKE_CFLAGS_GTK3 "$QMAKE_CFLAGS_GTK3"
QMakeVar set QMAKE_LIBS_GTK3 "$QMAKE_LIBS_GTK3"
else
if [ "$CFG_GTK" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "GTK theme support cannot be enabled due to functionality tests!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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_GTK=no
fi
fi
elif [ "$CFG_GLIB" = "no" ]; then
CFG_GTK=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
QMAKE_CFLAGS_PULSEAUDIO=`$PKG_CONFIG --cflags libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
QMAKE_LIBS_PULSEAUDIO=`$PKG_CONFIG --libs libpulse '>=' 0.9.10 libpulse-mainloop-glib 2>/dev/null`
fi
if compileTest unix/pulseaudio "PulseAudio" $QMAKE_CFLAGS_PULSEAUDIO $QMAKE_LIBS_PULSEAUDIO; then
CFG_PULSEAUDIO=yes
QMakeVar set QMAKE_CFLAGS_PULSEAUDIO "$QMAKE_CFLAGS_PULSEAUDIO"
QMakeVar set QMAKE_LIBS_PULSEAUDIO "$QMAKE_LIBS_PULSEAUDIO"
else
if [ "$CFG_PULSEAUDIO" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo "PulseAudio support cannot be enabled due to functionality tests!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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.0 or higher)
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.0"; 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.0
compileTest unix/opengles2 "OpenGL ES 2.0"
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.0 or higher)
if [ "$CFG_OPENGL" = "auto" ] || [ "$CFG_OPENGL" = "yes" ]; then
if compileTestWithPkgConfig gl unix/opengldesktop "OpenGL" OPENGL; then
CFG_OPENGL=desktop
elif compileTestWithPkgConfig glesv2 unix/opengles2 "OpenGL ES 2.0" OPENGL_ES2; 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.0
compileTestWithPkgConfig glesv2 unix/opengles2 "OpenGL ES 2.0" OPENGL_ES2
if [ $? != "0" ]; then
echo "The OpenGL ES 2.0 functionality test failed!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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
compileTestWithPkgConfig gl unix/opengldesktop "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
fi
# If OpenGL ES 2.0 is enabled, check for 3.0 and higher. This is used to allow
# compile-time differentiation and including the version specific (but backwards
# compatible) ES headers (for example, GLES3/gl31.h). Other than that, there is
# no difference in the configuration, even the library is the same.
if [ "$CFG_OPENGL" = "es2" ]; then
if compileTestWithPkgConfig glesv2 unix/opengles3 "OpenGL ES 3.0" ""; then
# Add a define for ES3, in addition to ES and ES2.
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_3"
fi
if compileTestWithPkgConfig glesv2 unix/opengles31 "OpenGL ES 3.1" ""; then
# Add a define for ES31.
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_OPENGL_ES_3_1"
fi
fi
# auto-detect FontConfig support
ORIG_CFG_FREETYPE="$CFG_FREETYPE"
if [ "$CFG_FONTCONFIG" != "no" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists fontconfig --exists freetype2 2>/dev/null; then
QMAKE_CFLAGS_FONTCONFIG=`$PKG_CONFIG --cflags fontconfig --cflags freetype2 2>/dev/null`
QMAKE_LIBS_FONTCONFIG=`$PKG_CONFIG --libs fontconfig --libs freetype2 2>/dev/null`
else
QMAKE_CFLAGS_FONTCONFIG=
QMAKE_LIBS_FONTCONFIG="-lfreetype -lfontconfig"
fi
if compileTest unix/fontconfig "FontConfig" $QMAKE_CFLAGS_FONTCONFIG $QMAKE_LIBS_FONTCONFIG; then
QT_CONFIG="$QT_CONFIG fontconfig"
QMakeVar set QMAKE_CFLAGS_FONTCONFIG "$QMAKE_CFLAGS_FONTCONFIG"
QMakeVar set QMAKE_LIBS_FONTCONFIG "$QMAKE_LIBS_FONTCONFIG"
CFG_FONTCONFIG=yes
CFG_FREETYPE=system
else
CFG_FONTCONFIG=no
fi
fi
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`
QMAKE_CFLAGS_LIBUDEV=`$PKG_CONFIG --cflags 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_CFLAGS_LIBUDEV $QMAKE_LIBS_LIBUDEV; then
CFG_LIBUDEV=yes
QT_CONFIG="$QT_CONFIG libudev"
elif [ "$CFG_LIBUDEV" = "yes" ]; then
echo "The libudev functionality test failed!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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
if [ "$CFG_TSLIB" = "no" ]; then
QMakeVar add DEFINES QT_NO_TSLIB
fi
if [ "$CFG_XKBCOMMON_EVDEV" != "no" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists xkbcommon 2>/dev/null; then
QMAKE_INCDIR_XKBCOMMON_EVDEV=`$PKG_CONFIG --cflags-only-I xkbcommon 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
QMAKE_LIBS_XKBCOMMON_EVDEV=`$PKG_CONFIG --libs xkbcommon 2>/dev/null`
QMAKE_CFLAGS_XKBCOMMON_EVDEV=`$PKG_CONFIG --cflags xkbcommon 2>/dev/null`
QMakeVar set QMAKE_INCDIR_XKBCOMMON_EVDEV "$QMAKE_INCDIR_XKBCOMMON_EVDEV"
QMakeVar set QMAKE_LIBS_XKBCOMMON_EVDEV "$QMAKE_LIBS_XKBCOMMON_EVDEV"
fi
if compileTest unix/xkbcommon "xkbcommon" $QMAKE_CFLAGS_XKBCOMMON_EVDEV $QMAKE_LIBS_XKBCOMMON_EVDEV; then
CFG_XKBCOMMON_EVDEV=yes
QT_CONFIG="$QT_CONFIG xkbcommon-evdev"
elif [ "$CFG_XKBCOMMON_EVDEV" = "yes" ]; then
echo "The xkbcommon-evdev functionality test failed!"
exit 1
else
CFG_XKBCOMMON_EVDEV=no
fi
fi
if [ "$CFG_LIBINPUT" != "no" ] && [ "$CFG_LIBUDEV" != "no" ]; then
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists libinput 2>/dev/null; then
QMAKE_INCDIR_LIBINPUT=`$PKG_CONFIG --cflags-only-I libinput 2>/dev/null | sed -e 's,^-I,,g' -e 's, -I, ,g'`
QMAKE_LIBS_LIBINPUT=`$PKG_CONFIG --libs libinput 2>/dev/null`
QMAKE_CFLAGS_LIBINPUT=`$PKG_CONFIG --cflags libinput 2>/dev/null`
QMAKE_LIBINPUT_VERSION_MAJOR=`$PKG_CONFIG --modversion libinput 2>/dev/null | cut -d . -f 1`
QMAKE_LIBINPUT_VERSION_MINOR=`$PKG_CONFIG --modversion libinput 2>/dev/null | cut -d . -f 2`
QMakeVar set QMAKE_LIBINPUT_VERSION_MAJOR "$QMAKE_LIBINPUT_VERSION_MAJOR"
QMakeVar set QMAKE_LIBINPUT_VERSION_MINOR "$QMAKE_LIBINPUT_VERSION_MINOR"
QMakeVar set QMAKE_INCDIR_LIBINPUT "$QMAKE_INCDIR_LIBINPUT"
QMakeVar set QMAKE_LIBS_LIBINPUT "$QMAKE_LIBS_LIBINPUT"
fi
if compileTest unix/libinput "libinput" $QMAKE_CFLAGS_LIBINPUT $QMAKE_LIBS_LIBINPUT; then
CFG_LIBINPUT=yes
QT_CONFIG="$QT_CONFIG libinput"
elif [ "$CFG_LIBINPUT" = "yes" ]; then
echo "The libinput functionality test failed!"
exit 1
else
CFG_LIBINPUT=no
fi
else
CFG_LIBINPUT=no
fi
if [ "$CFG_LIBINPUT" = "no" ]; then
QMakeVar add DEFINES QT_NO_LIBINPUT
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
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists xi 2>/dev/null; then
QMAKE_XINPUT2_VERSION_MAJOR=`$PKG_CONFIG --modversion xi 2>/dev/null | cut -d . -f 1`
QMAKE_XINPUT2_VERSION_MINOR=`$PKG_CONFIG --modversion xi 2>/dev/null | cut -d . -f 2`
QMAKE_XINPUT2_VERSION_PATCH=`$PKG_CONFIG --modversion xi 2>/dev/null | cut -d . -f 3`
QMakeVar set QMAKE_XINPUT2_VERSION_MAJOR "$QMAKE_XINPUT2_VERSION_MAJOR"
QMakeVar set QMAKE_XINPUT2_VERSION_MINOR "$QMAKE_XINPUT2_VERSION_MINOR"
QMakeVar set QMAKE_XINPUT2_VERSION_PATCH "$QMAKE_XINPUT2_VERSION_PATCH"
fi
CFG_XINPUT2=yes
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"
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
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!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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_GBM" != "no" ]; then
if compileTest qpa/gbm "GBM"; then
CFG_GBM=yes
elif [ "$CFG_GBM" = "yes" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo " GBM 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_GBM=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
if [ "$CFG_MIRCLIENT" != "no" ]; then
if compileTest qpa/mirclient "Mir client"; then
CFG_MIRCLIENT=yes
elif [ "$CFG_MIRCLIENT" = "yes" ]; then
echo " Mir client 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_MIRCLIENT=no
fi
fi
# Detect libxkbcommon
MIN_REQ_XKBCOMMON="0.4.1"
# currently only xcb platform plugin supports building xkbcommon
if [ "$CFG_XCB" != "no" ]; then
if [ "$CFG_XKBCOMMON" != "no" ] && [ "$CFG_XKBCOMMON" != "qt" ]; then
# Check if there is a suitable system-wide xkbcommon
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
elif [ "$CFG_XKBCOMMON" = "system" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo " xkbcommon support cannot be enabled because either xkbcommon or "
echo " xkbcommon-x11 >= $MIN_REQ_XKBCOMMON was not found via pkg-config!"
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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
# 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."
[ -z "$PKG_CONFIG" ] && echo " Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
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"
# Detect eglfs backends.
if compileTest qpa/eglfs-brcm "eglfs-brcm"; then
CFG_EGLFS_BRCM=yes
else
CFG_EGLFS_BRCM=no
fi
if compileTest qpa/eglfs-egldevice "eglfs-egldevice"; then
CFG_EGLFS_EGLDEVICE=yes
else
CFG_EGLFS_EGLDEVICE=no
fi
if compileTest qpa/eglfs-mali "eglfs-mali" \
|| compileTest qpa/eglfs-mali-2 "eglfs-mali-2"; then
CFG_EGLFS_MALI=yes
else
CFG_EGLFS_MALI=no
fi
if compileTest qpa/eglfs-viv "eglfs-viv"; then
CFG_EGLFS_VIV=yes
else
CFG_EGLFS_VIV=no
fi
if [ "$CFG_EGLFS_VIV" = "yes" ] && compileTest qpa/wayland-server "wayland-server"; then
CFG_EGLFS_VIV_WL=yes
else
CFG_EGLFS_VIV_WL=no
fi
else
CFG_EGLFS="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"
elif [ "$XPLATFORM_INTEGRITY" = "yes" ]; then
QT_QPA_DEFAULT_PLATFORM="integrityfb"
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_GBM" = "yes" ]; then
QT_CONFIG="$QT_CONFIG gbm"
fi
if [ "$CFG_LINUXFB" = "yes" ]; then
QT_CONFIG="$QT_CONFIG linuxfb"
fi
if [ "$CFG_INTEGRITYFB" = "yes" ]; then
QT_CONFIG="$QT_CONFIG integrityfb"
fi
if [ "$CFG_KMS" = "yes" ]; then
QT_CONFIG="$QT_CONFIG kms"
fi
if [ "$CFG_MIRCLIENT" = "yes" ]; then
QT_CONFIG="$QT_CONFIG mirclient"
fi
# double-conversion support
if [ "$CFG_DOUBLECONVERSION" = "no" ]; then
if ! compileTest common/xlocalescanprint "XLocaleScanPrint"; then
echo "Your C library does not provide sscanf_l or snprintf_l."
echo "You need to use libdouble-conversion for double/string conversion."
exit 1
fi
elif [ "$CFG_DOUBLECONVERSION" != "qt" ]; then
if compileTest unix/doubleconversion "DoubleConversion"; then
CFG_DOUBLECONVERSION=system
elif [ "$CFG_DOUBLECONVERSION" = "system" ]; then
echo "No system libdouble-conversion found."
exit 1
else
CFG_DOUBLECONVERSION=qt
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=qt
if [ "$CFG_HARFBUZZ" = "auto" ] || [ "$CFG_HARFBUZZ" = "system" ]; then
if compileTest unix/harfbuzz "HarfBuzz"; then
CFG_HARFBUZZ=system
else
if [ "$CFG_HARFBUZZ" = "system" ] && [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then
echo " HarfBuzz system library 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_HARFBUZZ=qt
fi
fi
fi
if [ "$XPLATFORM_MAC" = "yes" -a "$CFG_HARFBUZZ" != "qt" ]; then
echo
echo "WARNING: On OS X, AAT is supported only with -qt-harfbuzz."
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
# find if the platform provides thread-safe CLOEXEC support
if compileTest unix/cloexec "cloexec"; then
CFG_CLOEXEC=yes
fi
if compileTest unix/ppoll "ppoll"; then
CFG_POLL="ppoll"
elif compileTest unix/pollts "pollts"; then
CFG_POLL="pollts"
elif compileTest unix/poll "poll"; then
CFG_POLL="poll"
else
CFG_POLL="select"
fi
if [ "$XPLATFORM_MAC" = "yes" ] && [ "$CFG_SECURETRANSPORT" != "no" ] && ([ "$CFG_OPENSSL" = "no" ] || [ "$CFG_OPENSSL" = "auto" ]); then
CFG_SECURETRANSPORT=yes
CFG_OPENSSL=no
else
CFG_SECURETRANSPORT=no
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" ]; 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
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
# detect GStreamer support
if [ "$CFG_GSTREAMER" = "auto" ] || [ "$CFG_GSTREAMER" = "yes" ]; then
if compileTest unix/gstreamer "GStreamer 1.0" -config gst-1.0; then
CFG_GSTREAMER=yes
CFG_GSTREAMER_VERSION=1.0
elif compileTest unix/gstreamer "GStreamer 0.10" -config gst-0.10; then
CFG_GSTREAMER=yes
CFG_GSTREAMER_VERSION=0.10
else
if [ "$CFG_GSTREAMER" = "yes" ]; then
echo "GStreamer support cannot be enabled due to functionality tests!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
exit 1
fi
CFG_GSTREAMER=no
fi
elif [ "$CFG_GSTREAMER" = "0.10" ]; then
if compileTest unix/gstreamer "GStreamer 0.10" -config gst-0.10; then
CFG_GSTREAMER=yes
CFG_GSTREAMER_VERSION=0.10
else
echo "The GStreamer 0.10 functionality test failed!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
exit 1
fi
elif [ "$CFG_GSTREAMER" = "1.0" ]; then
if compileTest unix/gstreamer "GStreamer 1.0" -config gst-1.0; then
CFG_GSTREAMER=yes
CFG_GSTREAMER_VERSION=1.0
else
echo "The GStreamer 1.0 functionality test failed!"
echo " Turn on verbose messaging (-v) to $0 to see the final report."
exit 1
fi
fi
# Detect DirectWrite 2 support on Windows
if [ "$CFG_DIRECTWRITE" = "no" ]; then
CFG_DIRECTWRITE2=no
fi
if [ "$CFG_DIRECTWRITE2" = "auto" ]; then
if compileTest win/directwrite2 "directwrite2"; then
CFG_DIRECTWRITE2=yes
else
CFG_DIRECTWRITE2=no
fi
fi
#-------------------------------------------------------------------------------
# ask for all that hasn't been auto-detected or specified in the arguments
#-------------------------------------------------------------------------------
# Set "c++11" unconditionally, as lots of code does contains(QT_CONFIG, c++11)
QT_CONFIG="$QT_CONFIG c++11"
if [ "$CFG_STDCXX" != "c++11" ]; then
QT_CONFIG="$QT_CONFIG c++14"
if [ "$CFG_STDCXX" != "c++14" ]; then
QT_CONFIG="$QT_CONFIG c++1z"
fi
fi
if [ "$CFG_STD_ATOMIC64" = "libatomic" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG atomic64-libatomic"
fi
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
# eglfs backends
if [ "$CFG_EGLFS_BRCM" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_brcm"
fi
if [ "$CFG_EGLFS_EGLDEVICE" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_egldevice"
fi
if [ "$CFG_EGLFS" = "yes" ] && [ "$CFG_KMS" = "yes" ] && [ "$CFG_GBM" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_gbm"
CFG_EGLFS_GBM="yes"
else
CFG_EGLFS_GBM="no"
fi
if [ "$CFG_EGLFS_MALI" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_mali"
fi
if [ "$CFG_EGLFS_VIV" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_viv"
if [ "$CFG_EGLFS_VIV_WL" = "yes" ]; then
QT_CONFIG="$QT_CONFIG eglfs_viv_wl"
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"
if testXConfig precompile_header; then
[ "$CFG_PRECOMPILE" = "no" ] && QMakeVar del CONFIG precompile_header
else
[ "$CFG_PRECOMPILE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG precompile_header"
fi
[ "$CFG_USE_GOLD_LINKER" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG use_gold_linker"
[ "$CFG_ENABLE_NEW_DTAGS" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG enable_new_dtags"
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"
for feature in $CFG_AVX512; do
QMAKE_CONFIG="$QMAKE_CONFIG avx512$feature"
done
[ "$CFG_NEON" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG neon"
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_CLOEXEC" = "yes" ]; then
QT_CONFIG="$QT_CONFIG threadsafe-cloexec"
fi
if [ "$CFG_POLL" = "select" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NATIVE_POLL"
fi
QT_CONFIG="$QT_CONFIG poll_$CFG_POLL"
if [ "$CFG_LIBJPEG" = "no" ]; then
CFG_JPEG="no"
elif [ "$CFG_LIBJPEG" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-jpeg"
fi
if [ "$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" = "yes" ]; then
QT_CONFIG="$QT_CONFIG png"
fi
if [ "$CFG_GIF" = "yes" ]; then
QT_CONFIG="$QT_CONFIG gif"
fi
if [ "$CFG_DOUBLECONVERSION" = "system" ]; then
QT_CONFIG="$QT_CONFIG doubleconversion system-doubleconversion"
elif [ "$CFG_DOUBLECONVERSION" = "qt" ]; then
QT_CONFIG="$QT_CONFIG doubleconversion"
fi
if [ "$CFG_FREETYPE" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
elif [ "$CFG_FREETYPE" = "system" ]; then
QT_CONFIG="$QT_CONFIG freetype system-freetype"
else
QT_CONFIG="$QT_CONFIG freetype"
fi
if [ "$CFG_HARFBUZZ" = "no" ]; then
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_HARFBUZZ"
elif [ "$CFG_HARFBUZZ" = "system" ]; then
QT_CONFIG="$QT_CONFIG harfbuzz 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_SYSTEM_ZLIB=yes
fi
if [ "$CFG_SYSTEM_ZLIB" = "yes" ]; 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" != "no" ] && 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" != "no" ] && QT_CONFIG="$QT_CONFIG dbus"
[ "$CFG_DBUS" = "linked" ] && QT_CONFIG="$QT_CONFIG dbus-linked"
[ "$CFG_OPENSSL" = "yes" ] && QT_CONFIG="$QT_CONFIG openssl"
[ "$CFG_OPENSSL" = "linked" ] && QT_CONFIG="$QT_CONFIG openssl-linked"
[ "$CFG_SECURETRANSPORT" = "yes" ] && QT_CONFIG="$QT_CONFIG ssl securetransport"
[ "$CFG_LIBPROXY" = "yes" ] && QT_CONFIG="$QT_CONFIG libproxy"
[ "$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"
[ "$CFG_DIRECTWRITE2" = "yes" ] && QT_CONFIG="$QT_CONFIG directwrite2"
[ '!' -z "$DEFINES" ] && QMakeVar add EXTRA_DEFINES "$DEFINES"
[ '!' -z "$INCLUDES" ] && QMakeVar add EXTRA_INCLUDEPATH "$INCLUDES"
[ '!' -z "$L_FLAGS" ] && QMakeVar add EXTRA_LIBS "$L_FLAGS"
if [ -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 EXTRA_RPATHS "$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"
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
[ "$CFG_GSTREAMER_VERSION" = "0.10" ] && QT_CONFIG="$QT_CONFIG gstreamer-0.10"
[ "$CFG_GSTREAMER_VERSION" = "1.0" ] && QT_CONFIG="$QT_CONFIG gstreamer-1.0"
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_LTCG" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG ltcg"
fi
if [ "$CFG_SANITIZERS" != "none" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG sanitizer"
if [ "$CFG_SANITIZE_ADDRESS" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG sanitize_address"
fi
if [ "$CFG_SANITIZE_THREAD" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG sanitize_thread"
fi
if [ "$CFG_SANITIZE_MEMORY" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG sanitize_memory"
fi
if [ "$CFG_SANITIZE_UNDEFINED" = "yes" ]; then
QTCONFIG_CONFIG="$QTCONFIG_CONFIG sanitize_undefined"
fi
fi
if [ "$CFG_PCRE" = "qt" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG pcre"
fi
CFG_CONCURRENT="yes"
QT_CONFIG="$QT_CONFIG concurrent"
# ### 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
QT_CONFIG="$QT_CONFIG no-qml-debug"
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
;;
*)
QT_GCC_MAJOR_VERSION=$COMPILER_VERSION
QT_GCC_MINOR_VERSION=0
QT_GCC_PATCH_VERSION=0
esac
;;
*)
#
;;
esac
echo "Done running configuration tests."
# Save stdout in fd 3
exec 3>&1
#-------------------------------------------------------------------------------
# part of configuration information goes into qconfig.h
#-------------------------------------------------------------------------------
# Open qconfig.h.new
exec > "$outpath/src/corelib/global/qconfig.h.new"
# start with Qt's version number
cat <<EOF
#define QT_VERSION_MAJOR $QT_MAJOR_VERSION
#define QT_VERSION_MINOR $QT_MINOR_VERSION
#define QT_VERSION_PATCH $QT_PATCH_VERSION
#define QT_VERSION_STR "$QT_VERSION"
EOF
echo '/* Compile time features */'
[ '!' -z "$LicenseKeyExt" ] && echo "#define QT_PRODUCT_LICENSEKEY \"$LicenseKeyExt\""
if [ "$CFG_SHARED" = "no" ]; then
cat <<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"
fi
if [ "$CFG_QREAL" != double ]; then
echo "#define QT_COORD_TYPE $CFG_QREAL"
echo "#define QT_COORD_TYPE_STRING $CFG_QREAL_STRING"
fi
if [ "$CFG_FRAMEWORK" = "yes" ]; then
echo "#define QT_MAC_FRAMEWORK_BUILD"
fi
if [ "$CFG_STD_ATOMIC64" = "no" ]; then
echo "#define QT_NO_STD_ATOMIC64"
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"
fi
# Add compiler sub-architecture support
echo ""
echo "// Compiler sub-arch support"
for SUBARCH in SSE2 SSE3 SSSE3 SSE4_1 SSE4_2 AVX AVX2 \
MIPS_DSP MIPS_DSPR2; do
eval "VAL=\$CFG_$SUBARCH"
case "$VAL" in
yes)
echo "#define QT_COMPILER_SUPPORTS_$SUBARCH 1" \
;;
esac
done
for feature in $CFG_AVX512_UPPER; do
echo "#define QT_COMPILER_SUPPORTS_$feature 1"
done
echo ""
if [ "$CFG_DEV" = "yes" ]; then
echo "#define QT_BUILD_INTERNAL"
fi
# Add QPA to config.h
QCONFIG_FLAGS="$QCONFIG_FLAGS"
# Add turned on SQL drivers
for DRIVER in $CFG_SQL_AVAILABLE; do
eval "VAL=\$CFG_SQL_$DRIVER"
if [ "$VAL" = "yes" ]; then
SQL_DRIVERS="$SQL_DRIVERS $DRIVER"
fi
done
QMakeVar set sql-drivers "$SQL_DRIVERS"
# Add other configuration options to the qconfig.h file
[ "$CFG_GIF" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_GIF"
[ "$CFG_PNG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
[ "$CFG_JPEG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
[ "$CFG_DBUS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DBUS"
[ "$CFG_LIBPROXY" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_LIBPROXY"
# 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_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_CLOEXEC" = "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_THREADSAFE_CLOEXEC=1"
[ "$CFG_NIS" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_NIS"
[ "$CFG_OPENSSL" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_OPENSSL"
[ "$CFG_OPENSSL" = "linked" ]&& QCONFIG_FLAGS="$QCONFIG_FLAGS QT_LINKED_OPENSSL"
[ "$CFG_OPENSSL" = "no" ] && [ "$CFG_SECURETRANSPORT" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SSL"
[ "$CFG_SECURETRANSPORT" = "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_SECURETRANSPORT"
[ "$CFG_SM" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_SESSIONMANAGER"
[ "$CFG_TSLIB" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_TSLIB"
[ "$CFG_FONTCONFIG" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FONTCONFIG"
[ "$CFG_XKB" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XKB"
[ "$CFG_XRENDER" = "no" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_XRENDER"
[ "$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 << 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 << EOF
#ifndef $cfgd
# define $cfg
#endif
EOF
else
cat << EOF
#if defined($cfgd) && defined($cfgdNeg)
# undef $cfgd
#elif !defined($cfgd) && !defined($cfgdNeg)
# define $cfg
#endif
EOF
fi
done
cat << EOF
#endif // QT_BOOTSTRAPPED
EOF
fi
if [ "$CFG_REDUCE_EXPORTS" = "yes" ]; then
cat << EOF
#define QT_VISIBILITY_AVAILABLE
EOF
fi
if [ -n "$QT_LIBINFIX" ]; then
cat << EOF
#define QT_LIBINFIX "$QT_LIBINFIX"
EOF
fi
echo "#define QT_QPA_DEFAULT_PLATFORM_NAME \"$QT_QPA_DEFAULT_PLATFORM\""
# Close qconfig.h.new (by restoring the original stdout)
exec >&3
# 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
#-------------------------------------------------------------------------------
# open qconfig.pri
QTCONFIG="$outpath/mkspecs/qconfig.pri"
exec > "$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
if [ "$CFG_HEADERSCLEAN" != "no" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG headersclean"
fi
else
if [ "$CFG_WERROR" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG warnings_are_errors"
fi
if [ "$CFG_HEADERSCLEAN" = "yes" ]; then
QMAKE_CONFIG="$QMAKE_CONFIG headersclean"
fi
fi
cat <<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
QT_EDITION = $Edition
EOF
if [ "$Edition" != "OpenSource" ] && [ "$Edition" != "Preview" ]; then
echo "QT_LICHECK = $Licheck"
echo "QT_RELEASE_DATE = $ReleaseDate"
fi
echo
if [ "$CFG_SHARED" = "no" ]; then
echo "QT_DEFAULT_QPA_PLUGIN = q$QT_QPA_DEFAULT_PLATFORM"
echo
fi
if [ -n "$PKG_CONFIG_SYSROOT_DIR" ] || [ -n "$PKG_CONFIG_LIBDIR" ]; then
echo "# pkgconfig"
echo "PKG_CONFIG_SYSROOT_DIR = $PKG_CONFIG_SYSROOT_DIR"
echo "PKG_CONFIG_LIBDIR = $PKG_CONFIG_LIBDIR"
echo
fi
if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
echo "# sysroot"
echo "!host_build {"
echo " QMAKE_CFLAGS += --sysroot=\$\$[QT_SYSROOT]"
echo " QMAKE_CXXFLAGS += --sysroot=\$\$[QT_SYSROOT]"
echo " QMAKE_LFLAGS += --sysroot=\$\$[QT_SYSROOT]"
echo "}"
echo
fi
if [ -n "$QT_GCC_MAJOR_VERSION" ]; then
echo "QT_GCC_MAJOR_VERSION = $QT_GCC_MAJOR_VERSION"
echo "QT_GCC_MINOR_VERSION = $QT_GCC_MINOR_VERSION"
echo "QT_GCC_PATCH_VERSION = $QT_GCC_PATCH_VERSION"
fi
if [ -n "$QT_ICC_MAJOR_VERSION" ]; then
echo "QT_ICC_MAJOR_VERSION = $QT_ICC_MAJOR_VERSION"
echo "QT_ICC_MINOR_VERSION = $QT_ICC_MINOR_VERSION"
echo "QT_ICC_PATCH_VERSION = $QT_ICC_PATCH_VERSION"
fi
if [ -n "$QT_CLANG_MAJOR_VERSION" ]; then
echo "QT_CLANG_MAJOR_VERSION = $QT_CLANG_MAJOR_VERSION"
echo "QT_CLANG_MINOR_VERSION = $QT_CLANG_MINOR_VERSION"
fi
if [ -n "$QT_APPLE_CLANG_MAJOR_VERSION" ]; then
echo "QT_APPLE_CLANG_MAJOR_VERSION = $QT_APPLE_CLANG_MAJOR_VERSION"
echo "QT_APPLE_CLANG_MINOR_VERSION = $QT_APPLE_CLANG_MINOR_VERSION"
fi
if [ -n "$QMAKE_INCDIR_OPENGL_ES2" ]; then
echo "#Qt opengl include path"
echo "QMAKE_INCDIR_OPENGL_ES2 = `shellArgumentListToQMakeList "$QMAKE_INCDIR_OPENGL_ES2"`"
fi
# Close qconfig.pri.tmp (by restoring the original stdout)
exec >&3
# 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
#-------------------------------------------------------------------------------
# open qmodule.pri
QTMODULE="$outpath/mkspecs/qmodule.pri"
exec > "$QTMODULE.tmp"
echo "CONFIG += $QMAKE_CONFIG"
echo "QT_BUILD_PARTS += $CFG_BUILD_PARTS"
if [ -n "$CFG_SKIP_MODULES" ]; then
echo "QT_SKIP_MODULES += $CFG_SKIP_MODULES"
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"
fi
cat <<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"
if [ -n "$QMAKE_CFLAGS_PSQL" ]; then
echo "QMAKE_CFLAGS_PSQL = $QMAKE_CFLAGS_PSQL"
fi
if [ -n "$QMAKE_LIBS_PSQL" ]; then
echo "QMAKE_LIBS_PSQL = $QMAKE_LIBS_PSQL"
fi
if [ -n "$QMAKE_CFLAGS_MYSQL" ]; then
echo "QMAKE_CFLAGS_MYSQL = $QMAKE_CFLAGS_MYSQL"
fi
if [ -n "$QMAKE_LIBS_MYSQL" ]; then
echo "QMAKE_LIBS_MYSQL = $QMAKE_LIBS_MYSQL"
fi
if [ -n "$QMAKE_CFLAGS_SQLITE" ]; then
echo "QMAKE_CFLAGS_SQLITE = $QMAKE_CFLAGS_SQLITE"
fi
if [ -n "$QMAKE_LIBS_SQLITE" ]; then
echo "QMAKE_LIBS_SQLITE = $QMAKE_LIBS_SQLITE"
fi
if [ -n "$QMAKE_LIBS_ODBC" ]; then
echo "QMAKE_LIBS_ODBC = $QMAKE_LIBS_ODBC"
fi
if [ -n "$QMAKE_LIBS_TDS" ]; then
echo "QMAKE_LIBS_TDS = $QMAKE_LIBS_TDS"
fi
#dump in the OPENSSL_LIBS info
if [ '!' -z "$OPENSSL_LIBS" ]; then
echo "OPENSSL_LIBS = $OPENSSL_LIBS"
elif [ "$CFG_OPENSSL" = "linked" ]; then
echo "OPENSSL_LIBS = -lssl -lcrypto"
fi
# cmdline args
cat "$QMAKE_VARS_FILE"
# QMAKE_VARS_FILE will be still needed for a status message.
# Close qmodule.pri.tmp (by restoring the original stdout)
exec >&3
# 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 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
build_mode="debug and $release; default link: $build_mode"
fi
if [ "$CFG_RELEASE_TOOLS" = "yes" ]; then
build_mode="$build_mode; optimized tools"
fi
echo " Mode ................... $build_mode"
unset build_mode release
echo " Using sanitizer(s)...... $CFG_SANITIZERS"
echo " Using C++ standard ..... $CFG_STDCXX"
echo " Using gold linker....... $CFG_USE_GOLD_LINKER"
echo " Using new DTAGS ........ $CFG_ENABLE_NEW_DTAGS"
echo " Using PCH .............. $CFG_PRECOMPILE"
echo " Using LTCG ............. $CFG_LTCG"
echo " Target compiler supports:"
if [ "$CFG_ARCH" = "i386" -o "$CFG_ARCH" = "x86_64" ]; then
echo " SSE .................. ${CFG_SSE_LIST:-<none>}"
echo " AVX .................. ${CFG_AVX_LIST:-<none>}"
echo " AVX512 ............... ${CFG_AVX512_UPPER:-<none>}"
elif [ "$CFG_ARCH" = "arm" -o "$CFG_ARCH" = "arm64" ]; then
echo " Neon ................. ${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" runtime "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 " 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 " DoubleConversion........" "$CFG_DOUBLECONVERSION" no "libc" system "system library" qt "bundled copy"
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 " GStreamer .............." "$CFG_GSTREAMER" yes "$CFG_GSTREAMER_VERSION"
report_support " GTK platformtheme ......" "$CFG_GTK"
report_support " HarfBuzz ..............." "$CFG_HARFBUZZ" system "system library" qt "bundled copy"
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 " libinput................" "$CFG_LIBINPUT"
report_support " Logging backends:"
report_support " journald ..............." "$CFG_JOURNALD"
report_support " syslog ..............." "$CFG_SYSLOG"
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 " libproxy.............." "$CFG_LIBPROXY"
report_support " OpenSSL .............." "$CFG_OPENSSL" yes "loading libraries at run-time" linked "linked to the libraries"
[ "$XPLATFORM_MAC" = "yes" ] && \
report_support " SecureTransport ......" "$CFG_SECURETRANSPORT"
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.0+"
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 " EGLFS i.MX6 ........" "$CFG_EGLFS_VIV"
report_support " EGLFS i.MX6 Wayland." "$CFG_EGLFS_VIV_WL"
report_support " EGLFS EGLDevice ...." "$CFG_EGLFS_EGLDEVICE"
report_support " EGLFS GBM .........." "$CFG_EGLFS_GBM"
report_support " EGLFS Mali ........." "$CFG_EGLFS_MALI"
report_support " EGLFS Raspberry Pi ." "$CFG_EGLFS_BRCM"
report_support " EGLFS X11 .........." "$CFG_EGL_X"
if [ "$XPLATFORM_INTEGRITY" = "yes" ]; then
report_support " INTEGRITY Framebuffer " "$CFG_INTEGRITYFB"
fi
report_support " LinuxFB .............." "$CFG_LINUXFB"
report_support " Mir client............" "$CFG_MIRCLIENT"
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 " Xcb-Xlib ..........." "$CFG_XCB_XLIB"
report_support " Xi2 ................" "$CFG_XINPUT2" runtime "loaded at runtime"
report_support " Xrender ............" "$CFG_XRENDER"
report_support " XKB ................" "$CFG_XKB"
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"
report_support " InterBase ............" "$CFG_SQL_ibase"
report_support " MySQL ................" "$CFG_SQL_mysql"
report_support " OCI .................." "$CFG_SQL_oci"
report_support " ODBC ................." "$CFG_SQL_odbc"
report_support " PostgreSQL ..........." "$CFG_SQL_psql"
report_support " SQLite 2 ............." "$CFG_SQL_sqlite2"
report_support_plugin " SQLite ..............." "$CFG_SQL_sqlite" "$CFG_SQLITE" QtSql
report_support " TDS .................." "$CFG_SQL_tds"
report_support " tslib .................." "$CFG_TSLIB"
report_support " udev ..................." "$CFG_LIBUDEV"
report_support " xkbcommon-x11..........." "$CFG_XKBCOMMON" system "system library" qt "bundled copy, XKB config root: $CFG_XKB_CONFIG_ROOT"
report_support " xkbcommon-evdev........." "$CFG_XKBCOMMON_EVDEV"
report_support " zlib ..................." "$CFG_SYSTEM_ZLIB" yes "system library" no "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."
fi
if [ "$CFG_FREETYPE" = "system" ]; then
if [ "$ORIG_CFG_FREETYPE" = "qt" ]; then
echo
echo "WARNING: Bundled FreeType can't be used. FontConfig use requires system FreeType."
elif [ "$ORIG_CFG_FREETYPE" = "no" ]; then
echo
echo "WARNING: FreeType can't be disabled. FontConfig use requires system FreeType."
fi
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"
fi
if [ "$CFG_JOURNALD" = "yes" ] || [ "$CFG_SYSLOG" = "yes" ] || [ "$CFG_SLOG2" = "yes" ]; then
echo
echo "NOTE: journald, syslog or slog2 integration is enabled."
echo "If your users intend on developing applications against this build,"
echo "ensure that the IDEs they use either set QT_LOGGING_TO_CONSOLE to 1"
echo "or the IDE is able to read the logged output from journald, syslog or slog2."
fi
if [ "$CFG_XKBCOMMON" = "qt" ] && [ "$CFG_XKB_CONFIG_ROOT" = "not found" ]; then
echo
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
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
if [ "$CFG_RELEASE_TOOLS" = "yes" -a \( "$CFG_DEBUG" = "no" -o "$CFG_DEBUG_RELEASE" = "yes" \) ]; then
echo
echo "NOTE: -optimized-tools is not useful in -release mode."
echo
fi
if [ "$CFG_GUI" = "yes" ] && [ "$XPLATFORM_MAC" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] && [ "$XPLATFORM_QNX" = "no" ] && [ "$XPLATFORM_ANDROID" = "no" ] && [ "$XPLATFORM_HAIKU" = "no" ] && [ "$XPLATFORM_INTEGRITY" = "no" ]; then
if [ "$CFG_XCB" = "no" ] && [ "$CFG_EGLFS" = "no" ] && [ "$CFG_DIRECTFB" = "no" ] && [ "$CFG_LINUXFB" = "no" ] && [ "$CFG_MIRCLIENT" = "no" ]; then
echo
echo "No QPA platform plugin enabled! This will"
echo "produce a Qt that cannot run GUI applications."
echo
fi
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
#-------------------------------------------------------------------------------
( # fork to make the cd stay local
relpathMangled=$relpath
if [ -n "$CFG_TOPLEVEL" ]; then
relpathMangled=`dirname "$relpath"`
cd ..
fi
"$CFG_QMAKE_PATH" -qtconf "$QTCONFFILE" "$relpathMangled"
) || exit
#-------------------------------------------------------------------------------
# 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 "$CONFIG_STATUS \"\$@\"" >> "$outpath/config.status"
chmod +x "$outpath/config.status"
fi
if [ -n "$RPATH_MESSAGE" ]; then
echo
echo "$RPATH_MESSAGE"
fi
if [ -n "$PREFIX_COMPLAINTS" ]; then
echo
echo "$PREFIX_COMPLAINTS"
echo
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