96d935cd05
CFG_WEBKIT is never set to anything (removed in 1b716724f, 2012),
so simply remove the dead code path.
Change-Id: I63ef7cc6a2bf2fbf9ceb63f1a54e28882ec6e01e
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
6610 lines
210 KiB
Bash
Executable File
6610 lines
210 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_CONFIG=
|
|
QTCONFIG_CONFIG=
|
|
QT_CONFIG=
|
|
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_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| \
|
|
-make| \
|
|
-nomake| \
|
|
-skip| \
|
|
-platform| \
|
|
-xplatform| \
|
|
-device| \
|
|
-device-option| \
|
|
-host-option| \
|
|
-sdk| \
|
|
-c++std | \
|
|
-mysql_config| \
|
|
-psql_config| \
|
|
-qpa| \
|
|
-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
|
|
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
|
|
OPT_VERBOSE=yes
|
|
elif [ "$VAL" = "no" ]; then
|
|
OPT_VERBOSE=no
|
|
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"
|
|
;;
|
|
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*)
|
|
#PLATFORM=solaris-g++
|
|
PLATFORM=solaris-cc
|
|
#PLATFORM=solaris-cc64
|
|
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
|
|
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
|
|
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
|
|
# find X11 prefix
|
|
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"
|
|
|
|
# both -qt-xcb and -system-xcb depends on libxcb from the system
|
|
XCB_DEP="xcb >= 1.5"
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "$XCB_DEP" 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 ! compileTest qpa/xcb "xcb" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
if [ "$CFG_XCB" != "auto" ]; then
|
|
echo "Missing dependency lib$XCB_DEP."
|
|
[ -z "$PKG_CONFIG" ] && echo "Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
|
|
exit 1
|
|
fi
|
|
CFG_XCB=no
|
|
fi
|
|
|
|
# xcb plugin depends on libxkbcommon
|
|
if [ "$CFG_XCB" != "no" ] && [ "$CFG_XKBCOMMON" = no ]; then
|
|
if [ "$CFG_XCB" != "auto" ]; then
|
|
echo "XCB plugin requires libxkbcommon. See -qt-xkbcommon-x11 and -system-xkbcommon-x11."
|
|
exit 1
|
|
fi
|
|
CFG_XCB=no
|
|
fi
|
|
|
|
if [ "$CFG_XCB" != "no" ]; then
|
|
if [ "$CFG_XCB" = "qt" ]; then
|
|
QT_CONFIG="$QT_CONFIG xcb-qt"
|
|
else
|
|
# 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
|
|
XKB_DEP="xcb-xkb >= 1.10"
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "$XKB_DEP" 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`"
|
|
fi
|
|
if compileTest qpa/xcb-xkb "xcb-xkb" $QMAKE_CFLAGS_XKB $QMAKE_LIBS_XKB; then
|
|
CFG_XKB=yes
|
|
else
|
|
QMakeVar add DEFINES QT_NO_XKB
|
|
fi
|
|
|
|
XCB_PACKAGES="xcb xcb-shm xcb-sync xcb-xfixes xcb-randr xcb-image xcb-keysyms xcb-icccm xcb-shape"
|
|
if [ -n "$PKG_CONFIG" ] && $PKG_CONFIG --exists "$XCB_PACKAGES" 2>/dev/null; then
|
|
QMAKE_CFLAGS_XCB="`$PKG_CONFIG --cflags $XCB_PACKAGES 2>/dev/null`"
|
|
QMAKE_LIBS_XCB="`$PKG_CONFIG --libs $XCB_PACKAGES 2>/dev/null`"
|
|
fi
|
|
if compileTest qpa/xcb-syslibs "xcb-syslibs" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
CFG_XCB="system"
|
|
if compileTest qpa/xcb-render "xcb-render" $QMAKE_CFLAGS_XCB $QMAKE_LIBS_XCB; then
|
|
QT_CONFIG="$QT_CONFIG xcb-render"
|
|
fi
|
|
else
|
|
if [ "$CFG_XCB" != "auto" ]; then
|
|
echo "The test for linking against libxcb and support libraries failed"
|
|
echo "(need $XCB_PACKAGES)."
|
|
echo "You might need to install dependency packages, or pass -qt-xcb."
|
|
echo "See src/plugins/platforms/xcb/README."
|
|
[ -z "$PKG_CONFIG" ] && echo "Use of pkg-config is not enabled, maybe you want to pass -pkg-config?"
|
|
exit 1
|
|
fi
|
|
CFG_XCB="no"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_XCB" != "no" ]; then
|
|
QT_CONFIG="$QT_CONFIG xcb-plugin"
|
|
|
|
# Other deps that are not bundled with -qt-xcb and therefore need to be
|
|
# checked for both -qt-xcb and -system-xcb
|
|
|
|
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
|
|
|
|
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
|
|
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
|
|
|
|
# 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_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
|
|
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
|